as-test 1.0.0 → 1.0.3

package/bin/reporters/default.js

@@ -1,5 +1,7 @@
 import chalk from "chalk";
 import { diff } from "typer-diff";
+import { readFileSync } from "fs";
+import * as path from "path";
 import { formatTime } from "../util.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
@@ -14,6 +16,8 @@ class DefaultReporter {
         this.fileHasWarning = false;
         this.verboseMode = false;
         this.cleanMode = false;
+        this.hasRenderedTestFiles = false;
+        this.hasRenderedFuzzFiles = false;
     }
     canRewriteLine() {
         return (!this.cleanMode &&
@@ -118,6 +122,8 @@ class DefaultReporter {
     onRunStart(event) {
         this.verboseMode = Boolean(event.verbose);
         this.cleanMode = Boolean(event.clean);
+        this.hasRenderedTestFiles = false;
+        this.hasRenderedFuzzFiles = false;
     }
     onFileStart(event) {
         this.currentFile = event.file;
@@ -130,13 +136,24 @@ class DefaultReporter {
             this.renderVerboseState();
             return;
         }
-        if (this.verboseMode || !this.canRewriteLine()) {
+        if (!this.verboseMode) {
+            if (!this.canRewriteLine()) {
+                this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
+                return;
+            }
+            this.clearRenderedBlock();
+            this.context.stdout.write(`${this.badgeRunning()} ${event.file}`);
+            this.renderedLines = 1;
+            return;
+        }
+        if (!this.canRewriteLine()) {
             this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
             return;
         }
         this.renderLiveState();
     }
     onFileEnd(event) {
+        this.hasRenderedTestFiles = true;
         if (this.verboseMode && this.canRewriteLine()) {
             this.renderVerboseState(event);
             this.context.stdout.write("\n");
@@ -158,6 +175,8 @@ class DefaultReporter {
     onSuiteStart(event) {
         if (this.cleanMode)
             return;
+        if (!this.verboseMode)
+            return;
         const depth = Math.max(event.depth, 0);
         if (this.verboseMode && this.canRewriteLine()) {
             if (this.currentFile !== event.file)
@@ -183,6 +202,8 @@ class DefaultReporter {
     onSuiteEnd(event) {
         if (this.cleanMode)
             return;
+        if (!this.verboseMode)
+            return;
         const depth = Math.max(event.depth, 0);
         const verdict = String(event.verdict ?? "none");
         if (this.verboseMode && this.canRewriteLine()) {
@@ -214,7 +235,7 @@ class DefaultReporter {
     onAssertionFail(_event) { }
     onSnapshotMissing(event) {
         this.fileHasWarning = true;
-        const warnLine = `${chalk.bgYellow.black(" WARN ")} missing snapshot for ${chalk.dim(event.key)}. Re-run with ${chalk.bold("--update-snapshots")} to create it.\n`;
+        const warnLine = `${chalk.bgYellow.black(" WARN ")} missing snapshot for ${chalk.dim(event.key)}. Re-run with ${chalk.bold("--create-snapshots")} to create it.\n`;
         if (!this.canRewriteLine() || !this.currentFile) {
             this.context.stdout.write(warnLine);
             return;
@@ -228,13 +249,37 @@ class DefaultReporter {
             this.renderLiveState();
         }
     }
+    onWarning(event) {
+        this.fileHasWarning = true;
+        const warnLine = `${chalk.bgYellow.black(" WARN ")} ${event.message}\n`;
+        if (!this.canRewriteLine() || !this.currentFile) {
+            this.context.stdout.write(warnLine);
+            return;
+        }
+        this.clearRenderedBlock();
+        this.context.stdout.write(warnLine);
+        if (this.verboseMode) {
+            this.renderVerboseState();
+        }
+        else {
+            this.renderLiveState();
+        }
+    }
+    onLog(event) {
+        if (this.cleanMode)
+            return;
+        if (this.verboseMode || !this.canRewriteLine()) {
+            const depth = Math.max(event.depth, 0);
+            this.context.stdout.write(`${"  ".repeat(depth + 1)}${chalk.dim("LOG")} ${event.text}\n`);
+        }
+    }
     onRunComplete(event) {
         this.clearRenderedBlock();
         if (!event.clean) {
             renderFailedSuites(event.stats.failedEntries);
         }
         if (event.snapshotEnabled) {
-            renderSnapshotSummary(event.snapshotSummary);
+            renderSnapshotSummary(event.snapshotSummary, true);
         }
         if (event.coverageSummary.enabled) {
             renderCoverageSummary(event.coverageSummary);
@@ -244,6 +289,153 @@ class DefaultReporter {
         }
         renderTotals(event.stats, event);
     }
+    onFuzzComplete(event) {
+        renderFuzzSummary(this.context, event, this.hasRenderedTestFiles);
+    }
+    onFuzzFileComplete(event) {
+        this.hasRenderedFuzzFiles = true;
+        renderFuzzFileSummary(this.context, event.results);
+    }
+}
+function renderFuzzFileSummary(context, results) {
+    if (!results.length)
+        return;
+    const file = results[0].file;
+    const itemFailed = results.some((mode) => mode.crashes > 0 || mode.fuzzers.some((fuzzer) => fuzzer.failed > 0));
+    const itemSkipped = !itemFailed &&
+        results.length > 0 &&
+        results.every((mode) => mode.fuzzers.length > 0 &&
+            mode.fuzzers.every((fuzzer) => fuzzer.skipped > 0));
+    const itemBadge = itemFailed
+        ? chalk.bgRed.white(" FAIL ")
+        : itemSkipped
+            ? chalk.bgBlackBright.white(" SKIP ")
+            : chalk.bgGreenBright.black(" PASS ");
+    const detail = formatTime(averageFuzzModeTime(results));
+    const crashFile = firstFuzzCrashFile(results);
+    const crashSuffix = crashFile != null ? ` ${chalk.dim(`-> ${crashFile}`)}` : "";
+    context.stdout.write(`${itemBadge} ${path.basename(file)} ${chalk.dim(detail)}${crashSuffix}\n`);
+    renderFailedFuzzers(groupFuzzResultsByFile(results));
+}
+function renderFuzzSummary(context, event, hasRenderedTestFiles) {
+    context.stdout.write("\n");
+    if (!hasRenderedTestFiles) {
+        renderStandaloneFuzzTotals(event);
+    }
+}
+function renderFailedFuzzers(results) {
+    let rendered = false;
+    for (const result of results) {
+        for (const modeResult of result.modes) {
+            const relativeFile = toRelativeResultPath(modeResult.file);
+            const repro = buildFuzzReproCommand(relativeFile, modeResult.seed, modeResult.modeName);
+            if (modeResult.crashes > 0 && !modeResult.fuzzers.length) {
+                if (!rendered) {
+                    console.log("");
+                    rendered = true;
+                }
+                console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(path.basename(modeResult.file))} ${chalk.dim("(crash)")}`);
+                console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
+                console.log(chalk.dim(`Runs: ${modeResult.runs} configured`));
+                console.log(chalk.dim(`Repro: ${repro}`));
+                console.log(chalk.dim(`Seed: ${modeResult.seed}`));
+                if (modeResult.crashFiles.length) {
+                    console.log(chalk.dim(`Crash: ${modeResult.crashFiles[0]}`));
+                }
+                console.log("");
+                continue;
+            }
+            for (const fuzzer of modeResult.fuzzers) {
+                if (fuzzer.failed <= 0 && fuzzer.crashed <= 0)
+                    continue;
+                if (!rendered) {
+                    console.log("");
+                    rendered = true;
+                }
+                console.log(`${chalk.bgRed(" FAIL ")} ${formatFuzzFailureTitle(modeResult.file, fuzzer.name)}`);
+                if (fuzzer.failure?.message?.length) {
+                    console.log(chalk.dim(`Message: ${fuzzer.failure.message}`));
+                }
+                console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
+                console.log(chalk.dim(`Runs: ${fuzzer.passed + fuzzer.failed + fuzzer.crashed} completed (${fuzzer.passed} passed, ${fuzzer.failed} failed, ${fuzzer.crashed} crashed)`));
+                console.log(chalk.dim(`Repro: ${repro}`));
+                console.log(chalk.dim(`Seed: ${modeResult.seed}`));
+                if (modeResult.crashFiles.length) {
+                    console.log(chalk.dim(`Crash: ${modeResult.crashFiles[0]}`));
+                }
+                console.log("");
+            }
+        }
+    }
+    return rendered;
+}
+function groupFuzzResultsByFile(results) {
+    const grouped = new Map();
+    for (const result of results) {
+        const current = grouped.get(result.file) ?? [];
+        current.push(result);
+        grouped.set(result.file, current);
+    }
+    return [...grouped.entries()]
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([file, modes]) => ({ file, modes }));
+}
+function firstFuzzCrashFile(results) {
+    for (const result of results) {
+        if (result.crashFiles.length)
+            return result.crashFiles[0];
+    }
+    return null;
+}
+function averageFuzzModeTime(results) {
+    if (!results.length)
+        return 0;
+    return results.reduce((sum, result) => sum + result.time, 0) / results.length;
+}
+function buildFuzzReproCommand(file, seed, modeName) {
+    const modeArg = modeName != "default" ? ` --mode ${modeName}` : "";
+    return `ast fuzz ${file}${modeArg} --seed ${seed}`;
+}
+function toRelativeResultPath(file) {
+    const relative = path.relative(process.cwd(), path.resolve(process.cwd(), file));
+    return relative.length ? relative : file;
+}
+function formatFuzzFailureTitle(file, name) {
+    const location = findFuzzLocation(file, name);
+    const suffix = location
+        ? ` (${path.basename(file)}:${location})`
+        : ` (${path.basename(file)})`;
+    return `${chalk.dim(name)}${chalk.dim(suffix)}`;
+}
+function findFuzzLocation(file, name) {
+    try {
+        const source = readFileSync(path.resolve(process.cwd(), file), "utf8");
+        const patterns = [`fuzz("${name}"`, `fuzz('${name}'`];
+        patterns.push(`xfuzz("${name}"`, `xfuzz('${name}'`);
+        let index = -1;
+        for (const pattern of patterns) {
+            index = source.indexOf(pattern);
+            if (index != -1)
+                break;
+        }
+        if (index == -1)
+            return null;
+        let line = 1;
+        let column = 1;
+        for (let i = 0; i < index; i++) {
+            if (source.charCodeAt(i) == 10) {
+                line++;
+                column = 1;
+            }
+            else {
+                column++;
+            }
+        }
+        return `${line}:${column}`;
+    }
+    catch {
+        return null;
+    }
 }
 function renderFailedSuites(failedEntries) {
     if (!failedEntries.length)
@@ -272,7 +464,8 @@ function collectSuiteFailures(suite, file, path, printed) {
         const title = `${nextPath.join(" > ")}#${assertionIndex}`;
         const loc = String(test.location ?? "");
         const where = loc.length ? `${file}:${loc}` : file;
-        const dedupeKey = `${file}::${title}::${String(test.left)}::${String(test.right)}`;
+        const modeName = String(suiteAny.modeName ?? "");
+        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}`;
         if (printed.has(dedupeKey))
             continue;
         printed.add(dedupeKey);
@@ -300,6 +493,9 @@ function collectSuiteFailures(suite, file, path, printed) {
             }
         }
         console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
+        if (modeName.length) {
+            console.log(chalk.dim(`Mode: ${modeName}`));
+        }
         console.log(`${chalk.dim("(expected) ->")} ${expected}`);
         console.log(`${chalk.dim("(received) ->")} ${chalk.dim(left)}\n`);
     }
@@ -310,58 +506,94 @@ function collectSuiteFailures(suite, file, path, printed) {
         collectSuiteFailures(sub, file, nextPath, printed);
     }
 }
-function renderSnapshotSummary(snapshotSummary) {
-    console.log("");
+function renderSnapshotSummary(snapshotSummary, leadingGap = true) {
+    if (leadingGap) {
+        console.log("");
+    }
     console.log(`${chalk.bold("Snapshots:")} ${chalk.greenBright(snapshotSummary.matched)} matched, ${chalk.blueBright(snapshotSummary.created)} created, ${chalk.blueBright(snapshotSummary.updated)} updated, ${snapshotSummary.failed ? chalk.red(snapshotSummary.failed) : chalk.greenBright("0")} failed`);
 }
 function renderTotals(stats, event) {
     console.log("");
-    process.stdout.write(chalk.bold("Files:  "));
-    process.stdout.write(stats.failedFiles
-        ? chalk.bold.red(stats.failedFiles + " failed")
-        : chalk.bold.greenBright("0 failed"));
-    process.stdout.write(", " +
-        (stats.skippedFiles
-            ? chalk.gray(stats.skippedFiles + " skipped")
-            : chalk.gray("0 skipped")));
-    process.stdout.write(", " +
-        (stats.failedFiles + stats.passedFiles + stats.skippedFiles) +
-        " total\n");
-    process.stdout.write(chalk.bold("Suites: "));
-    process.stdout.write(stats.failedSuites
-        ? chalk.bold.red(stats.failedSuites + " failed")
-        : chalk.bold.greenBright("0 failed"));
-    process.stdout.write(", " +
-        (stats.skippedSuites
-            ? chalk.gray(stats.skippedSuites + " skipped")
-            : chalk.gray("0 skipped")));
-    process.stdout.write(", " +
-        (stats.failedSuites + stats.passedSuites + stats.skippedSuites) +
-        " total\n");
-    process.stdout.write(chalk.bold("Tests:  "));
-    process.stdout.write(stats.failedTests
-        ? chalk.bold.red(stats.failedTests + " failed")
-        : chalk.bold.greenBright("0 failed"));
-    process.stdout.write(", " +
-        (stats.skippedTests
-            ? chalk.gray(stats.skippedTests + " skipped")
-            : chalk.gray("0 skipped")));
-    process.stdout.write(", " + (stats.failedTests + stats.passedTests + stats.skippedTests) + " total\n");
+    const filesSummary = {
+        failed: stats.failedFiles,
+        skipped: stats.skippedFiles,
+        total: stats.failedFiles + stats.passedFiles + stats.skippedFiles,
+    };
+    const suitesSummary = {
+        failed: stats.failedSuites,
+        skipped: stats.skippedSuites,
+        total: stats.failedSuites + stats.passedSuites + stats.skippedSuites,
+    };
+    const testsSummary = {
+        failed: stats.failedTests,
+        skipped: stats.skippedTests,
+        total: stats.failedTests + stats.passedTests + stats.skippedTests,
+    };
+    const layout = createSummaryLayout([
+        event.fuzzSummary,
+        filesSummary,
+        suitesSummary,
+        testsSummary,
+        event.modeSummary,
+    ]);
+    if (event.fuzzSummary) {
+        renderFuzzTotals(event.fuzzSummary, layout);
+    }
+    renderSummaryLine("Files:", filesSummary, layout);
+    renderSummaryLine("Suites:", suitesSummary, layout);
+    renderSummaryLine("Tests:", testsSummary, layout);
     if (event.modeSummary) {
-        renderModeSummary(event.modeSummary);
+        renderModeSummary(event.modeSummary, layout);
     }
-    process.stdout.write(chalk.bold("Time:   ") + formatTime(stats.time) + "\n");
+    process.stdout.write(chalk.bold("Time:".padEnd(9)) +
+        formatTime(stats.time) +
+        chalk.dim(` (${formatTime(event.buildTime)} build)`) +
+        "\n");
+}
+function renderModeSummary(summary, layout) {
+    renderSummaryLine("Modes:", summary, layout);
+}
+function renderFuzzTotals(summary, layout) {
+    renderSummaryLine("Fuzz:", summary, layout);
+}
+function renderStandaloneFuzzTotals(event) {
+    console.log("");
+    const layout = createSummaryLayout([
+        event.fuzzingSummary,
+        event.suiteSummary,
+        event.modeSummary,
+    ]);
+    renderSummaryLine("Fuzz:", event.fuzzingSummary, layout);
+    renderSummaryLine("Suites:", event.suiteSummary, layout);
+    renderSummaryLine("Modes:", event.modeSummary, layout);
+    process.stdout.write(chalk.bold("Time:".padEnd(9)) +
+        formatTime(event.time) +
+        chalk.dim(` (${formatTime(event.buildTime)} build)`) +
+        "\n");
+}
+function createSummaryLayout(summaries) {
+    return {
+        failedWidth: Math.max(...summaries.map((summary) => summary ? `${summary.failed} failed`.length : 0)),
+        skippedWidth: Math.max(...summaries.map((summary) => summary ? `${summary.skipped} skipped`.length : 0)),
+        totalWidth: Math.max(...summaries.map((summary) => summary ? `${summary.total} total`.length : 0)),
+    };
 }
-function renderModeSummary(summary) {
-    process.stdout.write(chalk.bold("Modes:  "));
+function renderSummaryLine(label, summary, layout = {
+    failedWidth: `${summary.failed} failed`.length,
+    skippedWidth: `${summary.skipped} skipped`.length,
+    totalWidth: `${summary.total} total`.length,
+}) {
+    const failedText = `${summary.failed} failed`;
+    const skippedText = `${summary.skipped} skipped`;
+    const totalText = `${summary.total} total`;
+    process.stdout.write(chalk.bold(label.padEnd(9)));
     process.stdout.write(summary.failed
-        ? chalk.bold.red(summary.failed + " failed")
-        : chalk.bold.greenBright("0 failed"));
-    process.stdout.write(", " +
-        (summary.skipped
-            ? chalk.gray(summary.skipped + " skipped")
-            : chalk.gray("0 skipped")));
-    process.stdout.write(", " + summary.total + " total\n");
+        ? chalk.bold.red(failedText.padStart(layout.failedWidth))
+        : chalk.bold.greenBright(failedText.padStart(layout.failedWidth)));
+    process.stdout.write(", ");
+    process.stdout.write(chalk.gray(skippedText.padStart(layout.skippedWidth)));
+    process.stdout.write(", ");
+    process.stdout.write(totalText.padStart(layout.totalWidth) + "\n");
 }
 function renderCoverageSummary(summary) {
     const pct = summary.total
@@ -373,7 +605,7 @@ function renderCoverageSummary(summary) {
             ? chalk.yellowBright
             : chalk.redBright;
     console.log("");
-    console.log(`${chalk.bold("Coverage:")} ${color(pct + "%")} ${chalk.dim(`(${summary.covered}/${summary.total} points, ${summary.uncovered} uncovered)${Number(pct) < 100.0 ? " run with --show-coverage to see details" : ""}`)}`);
+    console.log(`${chalk.bold("Coverage:")} ${color(pct + "%")} ${chalk.dim(`(${summary.covered}/${summary.total} points, ${summary.uncovered} uncovered)`)}`);
 }
 function renderCoveragePoints(files) {
     console.log("");

package/bin/reporters/tap.js

@@ -10,9 +10,39 @@ class TapReporter {
     constructor(context, config) {
         this.context = context;
         this.config = config;
+        this.pendingRunEvent = null;
+        this.pendingFuzzEvent = null;
+        this.pendingFuzzPoints = [];
     }
     onRunComplete(event) {
-        const points = collectTapPoints(event.reports);
+        this.pendingRunEvent = event;
+    }
+    onFuzzComplete(event) {
+        this.pendingFuzzEvent = event;
+    }
+    onFuzzFileComplete(event) {
+        this.pendingFuzzPoints.push(...collectFuzzTapPoints({
+            results: event.results,
+            time: event.results.reduce((sum, item) => sum + item.time, 0),
+            buildTime: event.results.reduce((sum, item) => sum + item.buildTime, 0),
+            fuzzingSummary: { failed: 0, skipped: 0, total: 0 },
+            suiteSummary: { failed: 0, skipped: 0, total: 0 },
+            modeSummary: { failed: 0, skipped: 0, total: 0 },
+        }));
+    }
+    flush() {
+        if (!this.pendingRunEvent && !this.pendingFuzzEvent)
+            return;
+        const points = [];
+        if (this.pendingRunEvent) {
+            points.push(...collectTapPoints(this.pendingRunEvent.reports));
+        }
+        if (this.pendingFuzzPoints.length) {
+            points.push(...this.pendingFuzzPoints);
+        }
+        else if (this.pendingFuzzEvent) {
+            points.push(...collectFuzzTapPoints(this.pendingFuzzEvent));
+        }
         const output = buildTapDocument(points);
         this.context.stdout.write(output);
         for (const point of points) {
@@ -21,6 +51,9 @@ class TapReporter {
             emitGitHubAnnotation(this.context, point);
         }
         this.writeArtifacts(points, output);
+        this.pendingRunEvent = null;
+        this.pendingFuzzEvent = null;
+        this.pendingFuzzPoints = [];
     }
     writeArtifacts(points, output) {
         if (this.config.mode == "per-file") {
@@ -108,7 +141,10 @@ function buildTapDocument(points) {
     return lines.join("\n") + "\n";
 }
 function buildFailDetails(point) {
-    const lines = ["  ---", `  message: ${JSON.stringify(point.message ?? "assertion failed")}`];
+    const lines = [
+        "  ---",
+        `  message: ${JSON.stringify(point.message ?? "assertion failed")}`,
+    ];
     if (point.file) {
         lines.push(`  file: ${JSON.stringify(point.file)}`);
     }
@@ -149,6 +185,51 @@ function collectTapPoints(reports) {
     }
     return points;
 }
+function collectFuzzTapPoints(event) {
+    const points = [];
+    for (const result of event.results) {
+        const durationMs = result.time;
+        if (!result.fuzzers.length) {
+            points.push({
+                name: `fuzz ${path.basename(result.file)}`,
+                status: result.crashes > 0 ? "fail" : "ok",
+                file: result.file,
+                message: result.crashes > 0
+                    ? buildFuzzMessage(result.runs, result.seed, result.crashFiles[0])
+                    : `fuzz passed after ${result.runs} runs (seed ${result.seed})`,
+                durationMs,
+            });
+            continue;
+        }
+        for (const fuzzer of result.fuzzers) {
+            const crashed = fuzzer.crashed > 0 || result.crashes > 0;
+            const failed = crashed || fuzzer.failed > 0;
+            points.push({
+                name: `fuzz ${path.basename(result.file)} > ${fuzzer.name}`,
+                status: failed ? "fail" : "ok",
+                file: result.file,
+                message: failed
+                    ? buildFuzzerFailureMessage(result, fuzzer)
+                    : `fuzz passed after ${fuzzer.runs} runs (seed ${result.seed})`,
+                durationMs: fuzzer.time.end - fuzzer.time.start,
+            });
+        }
+    }
+    return points;
+}
+function buildFuzzerFailureMessage(result, fuzzer) {
+    if (fuzzer.crashed > 0 || result.crashes > 0) {
+        return buildFuzzMessage(result.runs, result.seed, result.crashFiles[0]);
+    }
+    if (fuzzer.failure?.message?.length) {
+        return `${fuzzer.failure.message} (runs ${fuzzer.runs}, seed ${result.seed})`;
+    }
+    return `fuzz failed after ${fuzzer.runs} runs (seed ${result.seed})`;
+}
+function buildFuzzMessage(runs, seed, crashFile) {
+    const crashSuffix = crashFile?.length ? `, crash ${crashFile}` : "";
+    return `fuzz crashed after ${runs} runs (seed ${seed}${crashSuffix})`;
+}
 function collectTapPointsFromSuite(suite, file, pathStack, points) {
     const suiteAny = suite;
     const description = String(suiteAny.description ?? "suite");

package/bin/types.js

@@ -7,17 +7,20 @@ export class Config {
         this.coverageDir = "./.as-test/coverage";
         this.snapshotDir = "./.as-test/snapshots";
         this.config = "none";
-        this.coverage = true;
+        this.coverage = false;
         this.env = {};
         this.buildOptions = new BuildOptions();
         this.runOptions = new RunOptions();
+        this.fuzz = new FuzzConfig();
         this.modes = {};
     }
 }
 export class CoverageOptions {
     constructor() {
-        this.enabled = true;
+        this.enabled = false;
         this.includeSpecs = false;
+        this.include = [];
+        this.exclude = [];
     }
 }
 export class Suite {
@@ -30,17 +33,20 @@ export class BuildOptions {
         this.cmd = "";
         this.args = [];
         this.target = "wasi";
+        this.env = {};
     }
 }
 export class RunOptions {
     constructor() {
         this.runtime = new Runtime();
         this.reporter = "";
+        this.env = {};
     }
 }
 export class Runtime {
     constructor() {
         this.cmd = "node ./.as-test/runners/default.wasi.js <file>";
+        this.browser = "";
     }
 }
 export class ModeConfig {
@@ -58,3 +64,14 @@ export class ReporterConfig {
         this.outFile = "";
     }
 }
+export class FuzzConfig {
+    constructor() {
+        this.input = ["./assembly/__fuzz__/*.fuzz.ts"];
+        this.runs = 1000;
+        this.seed = 1337;
+        this.maxInputBytes = 4096;
+        this.target = "bindings";
+        this.corpusDir = "./.as-test/fuzz/corpus";
+        this.crashDir = "./.as-test/crashes";
+    }
+}