as-test 1.0.6 → 1.0.9

package/bin/coverage-points.js

@@ -0,0 +1,173 @@
+import { readFileSync } from "fs";
+import * as path from "path";
+const sourceLineCache = new Map();
+export function describeCoveragePoint(file, line, column, fallbackType) {
+    const context = getCoverageSourceContext(file, line, column);
+    if (!context) {
+        return {
+            displayType: fallbackType,
+            subjectName: null,
+            visible: "",
+            focus: 0,
+            highlightStart: 0,
+            highlightEnd: 0,
+        };
+    }
+    const declaration = detectCoverageDeclaration(context.visible);
+    if (declaration) {
+        const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
+        return {
+            displayType: declaration.type,
+            subjectName: declaration.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart,
+            highlightEnd,
+        };
+    }
+    const call = detectCoverageCall(context.visible, context.focus);
+    if (call) {
+        return {
+            displayType: "Call",
+            subjectName: call.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: call.start,
+            highlightEnd: call.end,
+        };
+    }
+    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
+    return {
+        displayType: fallbackType,
+        subjectName: null,
+        visible: context.visible,
+        focus: context.focus,
+        highlightStart,
+        highlightEnd,
+    };
+}
+export function readCoverageSourceLine(file, line) {
+    const resolved = path.resolve(process.cwd(), file);
+    let lines = sourceLineCache.get(resolved);
+    if (lines === undefined) {
+        try {
+            lines = readFileSync(resolved, "utf8").split(/\r?\n/);
+        }
+        catch {
+            lines = null;
+        }
+        sourceLineCache.set(resolved, lines);
+    }
+    if (!lines)
+        return "";
+    return lines[line - 1] ?? "";
+}
+export function resolveCoverageHighlightSpan(visible, focus) {
+    if (!visible.length)
+        return [0, 0];
+    const index = Math.max(0, Math.min(visible.length - 1, focus));
+    if (isCoverageBoundary(visible.charAt(index))) {
+        return [index, Math.min(visible.length, index + 1)];
+    }
+    let start = index;
+    let end = index + 1;
+    while (start > 0 && !isCoverageBoundary(visible.charAt(start - 1)))
+        start--;
+    while (end < visible.length && !isCoverageBoundary(visible.charAt(end)))
+        end++;
+    return [start, end];
+}
+function getCoverageSourceContext(file, line, column) {
+    const sourceLine = readCoverageSourceLine(file, line);
+    if (!sourceLine)
+        return null;
+    const expanded = sourceLine.replace(/\t/g, "  ");
+    const firstNonWhitespace = expanded.search(/\S/);
+    if (firstNonWhitespace == -1)
+        return null;
+    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+    if (!visible.length)
+        return null;
+    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    return { visible, focus };
+}
+function detectCoverageDeclaration(visible) {
+    const trimmed = visible.trim();
+    if (!trimmed.length)
+        return null;
+    let match = trimmed.match(/^(?:export\s+)?function\s+([A-Za-z_]\w*)(?:<[^>]+>)?\s*\(/);
+    if (match)
+        return { type: "Function", name: match[1] ?? null };
+    if (trimmed.startsWith("constructor(") ||
+        /^(?:public\s+|private\s+|protected\s+)constructor\s*\(/.test(trimmed)) {
+        return { type: "Constructor", name: "constructor" };
+    }
+    match = trimmed.match(/^(?:export\s+)?(?:public\s+|private\s+|protected\s+)?(?:static\s+)?([A-Za-z_]\w*)(?:<[^>]+>)?\([^)]*\)\s*:\s*[^{=]+[{]?$/);
+    if (match)
+        return { type: "Method", name: match[1] ?? null };
+    match = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:readonly\s+)?([A-Za-z_]\w*)(?:<[^>]+>)?\s*:\s*[^=;{]+(?:=.*)?;?$/);
+    if (match)
+        return { type: "Property", name: match[1] ?? null };
+    if (/^(?:export\s+)?class\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?class\s+([A-Za-z_]\w*)/);
+        return { type: "Class", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?enum\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?enum\s+([A-Za-z_]\w*)/);
+        return { type: "Enum", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?interface\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?interface\s+([A-Za-z_]\w*)/);
+        return { type: "Interface", name: match?.[1] ?? null };
+    }
+    if (/^(?:export\s+)?namespace\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:export\s+)?namespace\s+([A-Za-z_]\w*)/);
+        return { type: "Namespace", name: match?.[1] ?? null };
+    }
+    if (/^(?:const|let|var)\b/.test(trimmed)) {
+        match = trimmed.match(/^(?:const|let|var)\s+([A-Za-z_]\w*)/);
+        return { type: "Variable", name: match?.[1] ?? null };
+    }
+    return null;
+}
+function detectCoverageCall(visible, focus) {
+    const matches = [...visible.matchAll(/\b([A-Za-z_]\w*)(?:<[^>()]+>)?\s*\(/g)];
+    if (!matches.length)
+        return null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    let bestMatch = null;
+    for (const match of matches) {
+        const start = match.index ?? -1;
+        if (start == -1)
+            continue;
+        const end = start + match[0].length;
+        const distance = focus < start ? start - focus : focus >= end ? focus - end + 1 : 0;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestMatch = match;
+        }
+    }
+    if (!bestMatch)
+        return null;
+    const name = bestMatch[1] ?? null;
+    if (name == "if" ||
+        name == "for" ||
+        name == "while" ||
+        name == "switch" ||
+        name == "return" ||
+        name == "function") {
+        return null;
+    }
+    if (bestDistance > Math.max(12, Math.floor(visible.length / 3))) {
+        return null;
+    }
+    const start = bestMatch.index ?? 0;
+    return {
+        name,
+        start,
+        end: start + (name?.length ?? 1),
+    };
+}
+function isCoverageBoundary(ch) {
+    return /[\s()[\]{}.,;:+\-*/%&|^!?=<>]/.test(ch);
+}

package/bin/index.js

@@ -281,7 +281,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
         process.stdout.write("  --disable <feature>      Disable feature (coverage|try-as)\n");
         process.stdout.write("  --fuzz                   Run fuzz targets after the normal test pass\n");
-        process.stdout.write("  --fuzz-runs <n>          Override fuzz iteration count for this run\n");
+        process.stdout.write("  --fuzz-runs <value>      Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
         process.stdout.write("  --fuzz-seed <n>          Override fuzz seed for this run\n");
         process.stdout.write("  --parallel              Run files through an ordered worker pool using an automatic worker count\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
@@ -302,7 +302,7 @@ function printCommandHelp(command) {
         process.stdout.write(chalk.bold("Flags:\n"));
         process.stdout.write("  --config <path>          Use a specific config file\n");
         process.stdout.write("  --mode <name[,name...]>  Run one or multiple named config modes\n");
-        process.stdout.write("  --runs <n>               Override fuzz iteration count\n");
+        process.stdout.write("  --runs <value>           Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
         process.stdout.write("  --seed <n>               Override fuzz seed\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
         process.stdout.write("  --build-jobs <n>         Limit concurrent build tasks (defaults to --jobs)\n");
@@ -482,9 +482,10 @@ function resolveFuzzOverrides(rawArgs, command) {
                 runs: "--fuzz-runs",
                 seed: "--fuzz-seed",
             };
-        const runs = parseNumberFlag(rawArgs, i, direct.runs);
+        const runs = parseFuzzRunsFlag(rawArgs, i, direct.runs);
         if (runs) {
-            out.runs = runs.number;
+            out.runs = runs.absoluteRuns;
+            out.runsOverride = runs.override;
             if (runs.consumeNext)
                 i++;
             continue;
@@ -499,6 +500,63 @@ function resolveFuzzOverrides(rawArgs, command) {
     }
     return out;
 }
+function parseFuzzRunsFlag(rawArgs, index, flag) {
+    const arg = rawArgs[index];
+    let value = "";
+    let consumeNext = false;
+    if (arg == flag) {
+        const next = rawArgs[index + 1];
+        if (!next || !next.length) {
+            throw new Error(`${flag} requires a value such as 500, 1.5x, +10%, or +100000`);
+        }
+        value = next;
+        consumeNext = true;
+    }
+    else if (arg.startsWith(`${flag}=`)) {
+        value = arg.slice(flag.length + 1);
+        if (!value.length) {
+            throw new Error(`${flag} requires a value such as 500, 1.5x, +10%, or +100000`);
+        }
+    }
+    else {
+        return null;
+    }
+    const parsed = parseFuzzRunsValue(flag, value.trim());
+    return {
+        key: flag,
+        absoluteRuns: parsed.kind == "set" ? parsed.value : undefined,
+        override: parsed,
+        consumeNext,
+    };
+}
+function parseFuzzRunsValue(flag, value) {
+    if (/^\d+$/.test(value)) {
+        const parsed = parseIntegerFlag(flag, value);
+        return { kind: "set", value: parsed };
+    }
+    if (/^[+-]\d+$/.test(value)) {
+        const delta = Number(value);
+        if (!Number.isFinite(delta) || !Number.isInteger(delta)) {
+            throw new Error(`${flag} additive run override must be an integer`);
+        }
+        return { kind: "add", value: delta };
+    }
+    if (/^\d+(?:\.\d+)?x$/i.test(value)) {
+        const factor = Number(value.slice(0, -1));
+        if (!Number.isFinite(factor) || factor <= 0) {
+            throw new Error(`${flag} multiplier must be greater than 0`);
+        }
+        return { kind: "scale", value: factor };
+    }
+    if (/^[+-]\d+(?:\.\d+)?%$/.test(value)) {
+        const percent = Number(value.slice(0, -1));
+        if (!Number.isFinite(percent)) {
+            throw new Error(`${flag} percentage must be numeric`);
+        }
+        return { kind: "percent-add", value: percent };
+    }
+    throw new Error(`${flag} must be a run count or expression such as 500, 1.5x, +10%, or +100000`);
+}
 function resolveListFlags(rawArgs, command) {
     const out = {
         list: false,

package/bin/reporters/default.js

@@ -3,6 +3,7 @@ import { diff } from "typer-diff";
 import { readFileSync } from "fs";
 import * as path from "path";
 import { formatTime } from "../util.js";
+import { describeCoveragePoint, readCoverageSourceLine, resolveCoverageHighlightSpan, } from "../coverage-points.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
 };
@@ -633,21 +634,60 @@ function renderSummaryLine(label, summary, layout = {
     process.stdout.write(totalText.padStart(layout.totalWidth) + "\n");
 }
 function renderCoverageSummary(summary) {
+    console.log("");
+    console.log(chalk.bold("Coverage"));
+    if (!summary.files.length || summary.total <= 0) {
+        console.log(`  ${chalk.dim("No eligible source files were tracked for coverage.")}`);
+        return;
+    }
     const pct = summary.total
         ? ((summary.covered * 100) / summary.total).toFixed(2)
         : "100.00";
+    const missingLabel = summary.uncovered == 1 ? "1 point missing" : `${summary.uncovered} points missing`;
+    const fileLabel = summary.files.length == 1 ? "1 file" : `${summary.files.length} files`;
     const color = Number(pct) >= 90
         ? chalk.greenBright
         : Number(pct) >= 75
             ? chalk.yellowBright
             : chalk.redBright;
-    console.log("");
-    console.log(`${chalk.bold("Coverage:")} ${color(pct + "%")} ${chalk.dim(`(${summary.covered}/${summary.total} points, ${summary.uncovered} uncovered)`)}`);
+    console.log(`  ${color(pct + "%")} ${renderCoverageBar(summary.percent)} ${chalk.dim(`(${summary.covered}/${summary.total} covered, ${missingLabel}, ${fileLabel})`)}`);
+    const ranked = [...summary.files].sort((a, b) => {
+        if (a.percent != b.percent)
+            return a.percent - b.percent;
+        if (a.uncovered != b.uncovered)
+            return b.uncovered - a.uncovered;
+        return a.file.localeCompare(b.file);
+    });
+    console.log(chalk.bold("  File Breakdown"));
+    for (const file of ranked.slice(0, 8)) {
+        const filePct = file.total
+            ? ((file.covered * 100) / file.total).toFixed(2)
+            : "100.00";
+        const fileColor = Number(filePct) >= 90
+            ? chalk.greenBright
+            : Number(filePct) >= 75
+                ? chalk.yellowBright
+                : chalk.redBright;
+        const suffix = file.uncovered > 0
+            ? `${file.uncovered} missing`
+            : "fully covered";
+        console.log(`    ${fileColor(filePct.padStart(6) + "%")}  ${toRelativeResultPath(file.file).padEnd(36)} ${chalk.dim(`${file.covered}/${file.total} covered, ${suffix}`)}`);
+    }
+    if (ranked.length > 8) {
+        console.log(chalk.dim(`    ... ${ranked.length - 8} more files`));
+    }
 }
 function renderCoveragePoints(files) {
     console.log("");
-    console.log(chalk.bold("Coverage Points:"));
+    console.log(chalk.bold("Coverage Gaps"));
     const sortedFiles = [...files].sort((a, b) => a.file.localeCompare(b.file));
+    const missingPoints = sortedFiles.flatMap((file) => file.points
+        .filter((point) => !point.executed)
+        .map((point) => ({
+        ...point,
+        displayType: describeCoveragePoint(point.file, point.line, point.column, point.type).displayType,
+    })));
+    const layout = createCoverageGapLayout(missingPoints);
     for (const file of sortedFiles) {
         const points = [...file.points].sort((a, b) => {
             if (a.line != b.line)
@@ -656,10 +696,69 @@ function renderCoveragePoints(files) {
                 return a.column - b.column;
             return a.type.localeCompare(b.type);
         });
+        const missing = points.filter((point) => !point.executed);
+        if (!missing.length)
+            continue;
+        console.log(`  ${chalk.bold(toRelativeResultPath(file.file))} ${chalk.dim(`(${missing.length} uncovered)`)}`);
         for (const point of points) {
             if (point.executed)
                 continue;
-            console.log(`${chalk.bgRed(" MISS ")} ${chalk.dim(`${point.file}:${point.line}:${point.column}`)} ${chalk.dim(point.type)}`);
+            const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+            const snippet = formatCoverageSnippet(point.file, point.line, point.column);
+            const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 4);
+            const locationLabel = location.padEnd(layout.locationWidth + 4);
+            console.log(`    ${chalk.red("x")} ${chalk.dim(typeLabel)}${chalk.dim(locationLabel)}${snippet}`);
         }
     }
 }
+function renderCoverageBar(percent) {
+    const slots = 12;
+    const filled = Math.max(0, Math.min(slots, Math.round((Math.max(0, Math.min(100, percent)) / 100) * slots)));
+    return `[${"=".repeat(filled)}${"-".repeat(slots - filled)}]`;
+}
+function createCoverageGapLayout(points) {
+    return {
+        typeWidth: Math.max(...points.map((point) => point.displayType.length), 5),
+        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`.length), 1),
+    };
+}
+function formatCoverageSnippet(file, line, column) {
+    const sourceLine = readCoverageSourceLine(file, line);
+    if (!sourceLine)
+        return "";
+    const expanded = sourceLine.replace(/\t/g, "  ");
+    const firstNonWhitespace = expanded.search(/\S/);
+    if (firstNonWhitespace == -1)
+        return "";
+    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+    if (!visible.length)
+        return "";
+    const maxWidth = 72;
+    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    if (visible.length <= maxWidth) {
+        return styleCoverageSnippetWindow(visible, 0, visible.length, focus);
+    }
+    const start = Math.max(0, Math.min(visible.length - maxWidth, focus - Math.floor(maxWidth / 2)));
+    const end = Math.min(visible.length, start + maxWidth);
+    return styleCoverageSnippetWindow(visible, start, end, focus);
+}
+function styleCoverageSnippetWindow(visible, start, end, focus) {
+    const prefix = start > 0 ? "..." : "";
+    const suffix = end < visible.length ? "..." : "";
+    const slice = visible.slice(start, end);
+    const localFocus = Math.max(0, Math.min(slice.length - 1, focus - start));
+    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(visible, focus);
+    const localStart = Math.max(0, Math.min(slice.length, highlightStart - start));
+    const localEnd = Math.max(localStart + 1, Math.min(slice.length, highlightEnd - start));
+    if (!slice.length)
+        return "";
+    if (localStart >= slice.length) {
+        return chalk.dim(`${prefix}${slice}${suffix}`);
+    }
+    const head = slice.slice(0, localStart);
+    const body = slice.slice(localStart, localEnd || localStart + 1);
+    const tail = slice.slice(localEnd || localStart + 1);
+    return (chalk.dim(prefix + head) +
+        chalk.dim.underline(body.length ? body : slice.charAt(localFocus)) +
+        chalk.dim(tail + suffix));
+}

package/bin/types.js

@@ -21,6 +21,15 @@ export class CoverageOptions {
         this.includeSpecs = false;
         this.include = [];
         this.exclude = [];
+        this.ignore = new CoverageIgnoreOptions();
+    }
+}
+export class CoverageIgnoreOptions {
+    constructor() {
+        this.labels = [];
+        this.names = [];
+        this.locations = [];
+        this.snippets = [];
     }
 }
 export class Suite {

package/bin/util.js

@@ -340,6 +340,22 @@ function validateCoverageValue(value, path, issues) {
     }
     validateStringArrayField(obj, "include", path, issues);
     validateStringArrayField(obj, "exclude", path, issues);
+    if ("ignore" in obj && obj.ignore != undefined) {
+        if (!obj.ignore || typeof obj.ignore != "object" || Array.isArray(obj.ignore)) {
+            issues.push({
+                path: `${path}.ignore`,
+                message: "must be an object",
+                fix: 'set "ignore" to an object such as { "labels": ["Call"], "names": ["panic"] }',
+            });
+        }
+        else {
+            const ignore = obj.ignore;
+            validateStringArrayField(ignore, "labels", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "names", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "locations", `${path}.ignore`, issues);
+            validateStringArrayField(ignore, "snippets", `${path}.ignore`, issues);
+        }
+    }
 }
 function validateStringArrayField(raw, key, pathPrefix, issues) {
     if (!(key in raw) || raw[key] == undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -39,6 +39,7 @@
   "description": "Testing framework for AssemblyScript. Compatible with WASI or Bindings",
   "files": [
     "assembly/**/*.ts",
+    "assembly/**/*.d.ts",
     "!assembly/__tests__/**",
     "!assembly/tsconfig.json",
     "bin/**/*.js",