as-test 1.0.16 → 1.1.1

package/assembly/util/format.ts

@@ -0,0 +1,104 @@
+export function formatValue<T>(value: T, deep: boolean = false): string {
+  if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
+    return "null";
+  }
+
+  if (isString<T>()) {
+    const text = value as string;
+    return deep ? "'" + text + "'" : text;
+  }
+
+  if (isBoolean<T>() || isInteger<T>() || isFloat<T>()) {
+    // @ts-expect-error: primitive formatting
+    return value.toString();
+  }
+
+  if (isArray<T>()) {
+    // @ts-expect-error: array-like handling
+    const values = value as valueof<T>[];
+    if (!values.length) return "[]";
+    let out = "[";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue<valueof<T>>(unchecked(values[i]), true);
+    }
+    out += "]";
+    return out;
+  }
+
+  if (value instanceof Map) {
+    // @ts-expect-error: generic runtime access
+    const keys = value.keys();
+    if (!keys.length) return "Map(0) {}";
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    let out = "Map(" + keys.length.toString() + ") { ";
+    for (let i = 0; i < keys.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(changetype<valueof<typeof keys>>(unchecked(keys[i])), true);
+      out += " => ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (value instanceof Set) {
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    if (!values.length) return "Set(0) {}";
+    let out = "Set(" + values.length.toString() + ") { ";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (isManaged<T>()) {
+    // @ts-expect-error: custom serializer when provided
+    if (isDefined(value.__as_test_json)) {
+      // @ts-expect-error: dynamic method dispatch
+      return value.__as_test_json();
+    }
+  }
+
+  return nameof<T>();
+}
+
+@inline
+export function colorText(format: i32[], text: string): string {
+  return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`;
+}
+
+@inline
+export function red(text: string): string {
+  return colorText([31, 39], text);
+}
+
+@inline
+export function green(text: string): string {
+  return colorText([32, 39], text);
+}
+
+@inline
+export function bgRed(text: string): string {
+  return colorText([41, 49], text);
+}
+
+@inline
+export function bgGreen(text: string): string {
+  return colorText([42, 49], text);
+}
+
+@inline
+export function bold(text: string): string {
+  return colorText([1, 22], text);
+}

package/assembly/util/helpers.ts

@@ -1,4 +1,4 @@
-import { rainbow } from "as-rainbow";
+import { bgGreen, bgRed } from "./format";
 
 export function visualize<T>(value: T): string {
   if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
@@ -61,16 +61,16 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
     const rChar = right.charAt(i);
     if (not) {
       if (lChar == rChar) {
-        lDiff += rainbow.bgGreen(rChar);
-        rDiff += rainbow.bgRed(lChar);
+        lDiff += bgGreen(rChar);
+        rDiff += bgRed(lChar);
       } else {
         lDiff += rChar;
         rDiff += lChar;
       }
     } else {
       if (lChar != rChar) {
-        lDiff += rainbow.bgGreen(rChar);
-        rDiff += rainbow.bgRed(lChar);
+        lDiff += bgGreen(rChar);
+        rDiff += bgRed(lChar);
       } else {
         lDiff += rChar;
         rDiff += lChar;
@@ -80,9 +80,9 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
 
   if (!not) {
     for (; i < left.length; i++) {
-      rDiff += rainbow.bgRed(left.charAt(i));
+      rDiff += bgRed(left.charAt(i));
     }
-    for (; i < right.length; i++) lDiff += rainbow.bgRed(right.charAt(i));
+    for (; i < right.length; i++) lDiff += bgRed(right.charAt(i));
   }
 
   return {
@@ -90,9 +90,3 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
     right: rDiff,
   };
 }
-
-// @ts-ignore
-@inline
-export function colorText(format: i32[], text: string): string {
-  return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`;
-}

package/assembly/util/json.ts

@@ -1,4 +1,4 @@
-import { stringify } from "as-console/stringify";
+import { formatValue } from "./format";
 
 export function quote(value: string): string {
   return '"' + escape(value) + '"';
@@ -36,7 +36,7 @@ export function stringifyValue<T>(value: T): string {
     return value.__as_test_json();
   }
 
-  const formatted = stringify<T>(value);
+  const formatted = formatValue<T>(value);
   if (formatted != "none") {
     return quote(formatted);
   }

package/assembly/util/wipc.ts

@@ -34,6 +34,8 @@ const HEADER_SIZE: i32 = 9;
 const IOV_SIZE: usize = sizeof<usize>() * 2;
 const U32_SIZE: usize = sizeof<u32>();
 const REPORT_CHUNK_BYTES: i32 = 65536;
+const WASI_ERRNO_AGAIN: i32 = 6;
+const WASI_ERRNO_INTR: i32 = 27;
 
 // @ts-ignore
 const IS_BINDINGS: bool = isDefined(AS_TEST_BINDINGS);
@@ -303,9 +305,12 @@ function wasiWriteAll(data: ArrayBuffer): void {
     store<usize>(iovPtr, <usize>left, sizeof<usize>());
     store<u32>(writtenPtr, 0, 0);
     const errno = wasi_fd_write(1, iovPtr, 1, writtenPtr);
+    if (errno == WASI_ERRNO_AGAIN || errno == WASI_ERRNO_INTR) {
+      continue;
+    }
     if (errno != 0) return;
     const written = <i32>load<u32>(writtenPtr, 0);
-    if (written <= 0) return;
+    if (written <= 0) continue;
     offset += written;
   }
 }
@@ -319,10 +324,15 @@ function wasiRead(max: i32): ArrayBuffer {
 
   store<usize>(iovPtr, changetype<usize>(out), 0);
   store<usize>(iovPtr, <usize>max, sizeof<usize>());
-  store<u32>(readPtr, 0, 0);
-
-  const errno = wasi_fd_read(0, iovPtr, 1, readPtr);
-  if (errno != 0) return new ArrayBuffer(0);
+  while (true) {
+    store<u32>(readPtr, 0, 0);
+    const errno = wasi_fd_read(0, iovPtr, 1, readPtr);
+    if (errno == WASI_ERRNO_AGAIN || errno == WASI_ERRNO_INTR) {
+      continue;
+    }
+    if (errno != 0) return new ArrayBuffer(0);
+    break;
+  }
 
   const size = <i32>load<u32>(readPtr, 0);
   if (size <= 0) return new ArrayBuffer(0);

package/bin/commands/clean-core.js

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+import { existsSync, rmSync } from "fs";
+import * as path from "path";
+import { applyMode, loadConfig } from "../util.js";
+const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+export async function clean(configPath = DEFAULT_CONFIG_PATH, modes = [undefined], fullClean = false) {
+    const loadedConfig = loadConfig(configPath, true);
+    const targets = new Map();
+    const ownership = buildOwnershipMap(loadedConfig);
+    if (fullClean) {
+        collectRootTarget(targets, loadedConfig.outDir, "build");
+        collectRootTarget(targets, loadedConfig.fuzz.crashDir, "crashes");
+        collectRootTarget(targets, loadedConfig.coverageDir, "coverage");
+        collectRootTarget(targets, loadedConfig.logs, "logs");
+        for (const modeName of modes) {
+            const active = applyMode(loadedConfig, modeName).config;
+            collectTarget(targets, active.outDir, modeName, "build");
+            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+            collectTarget(targets, active.coverageDir, modeName, "coverage");
+            collectTarget(targets, active.logs, modeName, "logs");
+        }
+        pruneNestedTargets(targets);
+    }
+    else {
+        for (const modeName of modes) {
+            const active = applyMode(loadedConfig, modeName).config;
+            collectTarget(targets, active.outDir, modeName, "build");
+            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+            collectTarget(targets, active.coverageDir, modeName, "coverage");
+            collectTarget(targets, active.logs, modeName, "logs");
+        }
+    }
+    let removed = 0;
+    for (const [targetPath, owners] of [...targets.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        if (!fullClean) {
+            const allOwners = ownership.get(targetPath) ?? owners;
+            const unselectedOwners = allOwners.filter((owner) => !owners.includes(owner));
+            if (unselectedOwners.length) {
+                continue;
+            }
+        }
+        if (!existsSync(targetPath)) {
+            continue;
+        }
+        rmSync(targetPath, { recursive: true, force: true });
+        removed++;
+        process.stdout.write(`${chalk.bgGreenBright.black(" CLEAN ")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
+    }
+    process.stdout.write(`${chalk.bold("Summary:")} removed ${removed} path(s)\n`);
+}
+function buildOwnershipMap(loadedConfig) {
+    const ownership = new Map();
+    const modeNames = [
+        undefined,
+        ...Object.keys(loadedConfig.modes),
+    ];
+    for (const modeName of modeNames) {
+        const active = applyMode(loadedConfig, modeName).config;
+        collectOwnership(ownership, active.outDir, modeName, "build");
+        collectOwnership(ownership, active.fuzz.crashDir, modeName, "crashes");
+        collectOwnership(ownership, active.coverageDir, modeName, "coverage");
+        collectOwnership(ownership, active.logs, modeName, "logs");
+    }
+    return ownership;
+}
+function collectRootTarget(targets, rawPath, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `all:${kind}`;
+    const existing = targets.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    targets.set(resolved, [owner]);
+}
+function collectOwnership(ownership, rawPath, modeName, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `${modeName ?? "default"}:${kind}`;
+    const existing = ownership.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    ownership.set(resolved, [owner]);
+}
+function collectTarget(targets, rawPath, modeName, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `${modeName ?? "default"}:${kind}`;
+    const existing = targets.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    targets.set(resolved, [owner]);
+}
+function pruneNestedTargets(targets) {
+    const paths = [...targets.keys()].sort((a, b) => a.length - b.length);
+    for (const targetPath of paths) {
+        for (const otherPath of paths) {
+            if (targetPath == otherPath)
+                continue;
+            const relative = path.relative(targetPath, otherPath);
+            if (!relative.length || relative == ".." || relative.startsWith(`..${path.sep}`)) {
+                continue;
+            }
+            targets.delete(otherPath);
+        }
+    }
+}
+function ensureSafeCleanPath(resolvedPath, rawPath, kind) {
+    const cwd = path.resolve(process.cwd());
+    const relative = path.relative(cwd, resolvedPath);
+    if (!relative.length ||
+        relative == ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.parse(resolvedPath).root == resolvedPath) {
+        throw new Error(`refusing to clean unsafe ${kind} path "${rawPath}" (${resolvedPath})`);
+    }
+}
+function toRelativePath(targetPath) {
+    const relative = path.relative(process.cwd(), targetPath);
+    return relative.length ? relative : ".";
+}

package/bin/commands/clean.js

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+import { createInterface } from "readline";
+import { clean } from "./clean-core.js";
+import { loadConfig } from "../util.js";
+export { clean } from "./clean-core.js";
+export async function executeCleanCommand(rawArgs, configPath, selectedModes, resolveExecutionModes) {
+    const force = rawArgs.includes("-f") || rawArgs.includes("--force");
+    const modeTargets = selectedModes.length > 0
+        ? resolveExecutionModes(configPath, selectedModes)
+        : resolveAllCleanModes(configPath);
+    if (!force && selectedModes.length == 0) {
+        await confirmFullClean(configPath);
+    }
+    await clean(configPath, modeTargets, selectedModes.length == 0);
+}
+function resolveAllCleanModes(configPath) {
+    const resolvedConfigPath = configPath ?? "./as-test.config.json";
+    const config = loadConfig(resolvedConfigPath, true);
+    return [undefined, ...Object.keys(config.modes)];
+}
+async function confirmFullClean(configPath) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('clean without --mode requires confirmation. Re-run with "-f" or "--force" to skip the prompt.');
+    }
+    const target = configPath ? ` in ${configPath}` : "";
+    process.stdout.write(chalk.bold.blue("◇  Confirm Clean") +
+        "\n" +
+        `│  This will remove configured build outputs, crash reports, and logs for every mode${target}.\n` +
+        "│\n");
+    const answer = await promptLine("Continue? [Y/n] ");
+    const normalized = answer.trim().toLowerCase();
+    if (normalized == "" || normalized == "y" || normalized == "yes")
+        return;
+    if (normalized == "n" || normalized == "no") {
+        process.stdout.write(chalk.dim("clean cancelled\n"));
+        process.exit(0);
+    }
+    throw new Error(`invalid answer "${answer}". Expected yes or no.`);
+}
+function promptLine(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}