as-test 1.2.0 → 1.4.0

package/bin/reporters/default.js

@@ -17,6 +17,7 @@ class DefaultReporter {
     this.fileHasWarning = false;
     this.verboseMode = false;
     this.cleanMode = false;
+    this.showLogsMode = false;
     this.hasRenderedTestFiles = false;
     this.hasRenderedFuzzFiles = false;
   }
@@ -127,6 +128,7 @@ class DefaultReporter {
   onRunStart(event) {
     this.verboseMode = Boolean(event.verbose);
     this.cleanMode = Boolean(event.clean);
+    this.showLogsMode = Boolean(event.showLogs);
     this.hasRenderedTestFiles = false;
     this.hasRenderedFuzzFiles = false;
   }
@@ -270,6 +272,9 @@ class DefaultReporter {
   }
   onLog(event) {
     if (this.cleanMode) return;
+    // With --show-logs we print one clean grouped block at the end instead of
+    // streaming inline, so suppress the inline emit here.
+    if (this.showLogsMode) return;
     if (this.verboseMode || !this.canRewriteLine()) {
       const depth = Math.max(event.depth, 0);
       this.context.stdout.write(
@@ -295,6 +300,35 @@ class DefaultReporter {
       }
     }
     renderTotals(event.stats, event);
+    this.renderLogs(event);
+  }
+  // After the totals: either point the user at the aggregated log file (default)
+  // or, with --show-logs, print the captured logs (the same cross-mode-deduped
+  // body that was written to latest.log). Skipped in clean mode. When logs were
+  // already streamed inline (verbose or a non-TTY stream), we only re-point at
+  // the file rather than printing them twice.
+  renderLogs(event) {
+    if (this.cleanMode) return;
+    const summary = event.logSummary;
+    if (!summary || summary.count <= 0) return;
+    const out = this.context.stdout;
+    const plural = summary.count === 1 ? "" : "s";
+    // --show-logs: print the clean, cross-mode-deduped block (inline streaming
+    // was suppressed in onLog). Otherwise just point at the aggregated file —
+    // unless logs were already streamed inline (verbose / non-TTY).
+    if (event.showLogs && summary.text) {
+      out.write(`\n${chalk.bold(`Logs (${summary.count})`)}\n\n`);
+      out.write(
+        summary.text.endsWith("\n") ? summary.text : `${summary.text}\n`,
+      );
+      return;
+    }
+    const shownInline = this.verboseMode || !this.canRewriteLine();
+    const where = summary.file ? ` → ${chalk.cyan(summary.file)}` : "";
+    out.write(`\n${summary.count} log${plural} captured${where}\n`);
+    if (!shownInline && summary.file) {
+      out.write(`${chalk.dim("  run with --show-logs to print them")}\n`);
+    }
   }
   onFuzzComplete(event) {
     renderFuzzSummary(this.context, event, this.hasRenderedTestFiles);

package/bin/types.js

@@ -8,6 +8,7 @@ export class Config {
     this.snapshotDir = "./.as-test/snapshots";
     this.config = "none";
     this.coverage = false;
+    this.features = [];
     this.env = {};
     this.buildOptions = new BuildOptions();
     this.runOptions = new RunOptions();
@@ -15,6 +16,12 @@ export class Config {
     this.modes = {};
   }
 }
+export const INTERNAL_FEATURE_NAMES = new Set(["try-as"]);
+export function normalizeFeatureName(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed == "try_as" || trimmed == "tryas") return "try-as";
+  return trimmed;
+}
 export class CoverageOptions {
   constructor() {
     this.enabled = false;

package/bin/util.js

@@ -6,6 +6,7 @@ import {
   CoverageIgnoreOptions,
   FuzzConfig,
   ModeConfig,
+  normalizeFeatureName,
   ReporterConfig,
   RunOptions,
   Runtime,
@@ -186,6 +187,7 @@ function parseConfigRaw(raw, configPath) {
     typeof config.fuzz.crashDir == "string" && config.fuzz.crashDir.length
       ? config.fuzz.crashDir
       : "./.as-test/crashes";
+  config.features = parseFeaturesField(raw.features);
   config.modes = parseModes(raw.modes, configDir);
   CONFIG_META.set(config, {
     sourcePath: configPath,
@@ -193,6 +195,19 @@ function parseConfigRaw(raw, configPath) {
   });
   return config;
 }
+function parseFeaturesField(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const value of raw) {
+    if (typeof value != "string") continue;
+    const name = normalizeFeatureName(value);
+    if (!name.length || seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
 const TOP_LEVEL_KEYS = new Set([
   "$schema",
   "input",
@@ -203,6 +218,7 @@ const TOP_LEVEL_KEYS = new Set([
   "snapshotDir",
   "config",
   "coverage",
+  "features",
   "env",
   "buildOptions",
   "fuzz",
@@ -238,6 +254,7 @@ function validateConfig(raw, configPath) {
   validateStringField(raw, "snapshotDir", "$", issues);
   validateStringField(raw, "config", "$", issues);
   validateCoverageField(raw, "coverage", "$", issues);
+  validateFeaturesField(raw, "features", "$", issues);
   validateEnvField(raw, "env", "$", issues);
   validateBuildOptionsField(raw, "buildOptions", "$", issues);
   validateFuzzField(raw, "fuzz", "$", issues);
@@ -742,12 +759,34 @@ function validateModesField(raw, key, pathPrefix, issues) {
     validateStringField(modeObj, "snapshotDir", modePath, issues);
     validateStringField(modeObj, "config", modePath, issues);
     validateCoverageField(modeObj, "coverage", modePath, issues);
+    validateFeaturesField(modeObj, "features", modePath, issues);
     validateFuzzField(modeObj, "fuzz", modePath, issues);
     validateEnvField(modeObj, "env", modePath, issues);
     validateBuildOptionsField(modeObj, "buildOptions", modePath, issues);
     validateRunOptionsField(modeObj, "runOptions", modePath, issues);
   }
 }
+function validateFeaturesField(raw, key, pathPrefix, issues) {
+  if (!(key in raw) || raw[key] == undefined) return;
+  const value = raw[key];
+  if (!Array.isArray(value)) {
+    issues.push({
+      path: `${pathPrefix}.${key}`,
+      message: "must be an array of feature name strings",
+      fix: 'example: "features": ["try-as", "simd"]',
+    });
+    return;
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] != "string" || !value[i].trim().length) {
+      issues.push({
+        path: `${pathPrefix}.${key}[${i}]`,
+        message: "must be a non-empty string",
+        fix: 'feature names look like "try-as" or "simd"',
+      });
+    }
+  }
+}
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item == "string");
 }
@@ -1051,6 +1090,7 @@ function cloneConfig(config) {
   cloned.runOptions = cloneRunOptions(config.runOptions);
   cloned.fuzz = cloneFuzzConfig(config.fuzz);
   cloned.coverage = cloneCoverageOptions(config.coverage);
+  cloned.features = [...config.features];
   cloned.modes = Object.fromEntries(
     Object.entries(config.modes).map(([name, mode]) => [
       name,
@@ -1211,6 +1251,9 @@ function mergeRootConfig(base, override) {
       raw.coverage,
     );
   }
+  if (Array.isArray(raw.features)) {
+    merged.features = [...override.features];
+  }
   if ("env" in raw) {
     merged.env = { ...override.env };
   }
@@ -1511,6 +1554,15 @@ export function resolveArtifactPath(file, inputPatterns) {
   const rel = resolveSpecRelativePath(file, inputPatterns);
   return rel.replace(/\.ts$/i, ".wasm");
 }
+// Absolute path to the `.snap` file owned by a given spec.
+//   assembly/__tests__/array.spec.ts -> <cwd>/<snapshotDir>/array.spec.snap
+export function resolveSnapshotPath(specFile, snapshotDir, inputPatterns) {
+  const rel = resolveSpecRelativePath(specFile, inputPatterns).replace(
+    /\.ts$/i,
+    ".snap",
+  );
+  return resolve(process.cwd(), snapshotDir, rel);
+}
 function toComponents(absPath) {
   return absPath
     .split(/[\\/]+/)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -12,9 +12,6 @@
     "typer-diff": "^1.1.1",
     "wipc-js": "^0.1.1"
   },
-  "peerDependencies": {
-    "json-as": ">=1.3.5"
-  },
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
     "@eslint/js": "^10.0.1",
@@ -24,7 +21,7 @@
     "assemblyscript": "^0.28.17",
     "assemblyscript-prettier": "^3.0.4",
     "husky": "^9.1.7",
-    "json-as": "^1.3.7",
+    "playwright": "^1.60.0",
     "prettier": "3.8.3",
     "try-as": "^1.1.0",
     "typescript": "^6.0.3",
@@ -91,8 +88,8 @@
     "typecheck": "tsc -p cli --noEmit && tsc -p tsconfig.lib.json --noEmit && tsc -p transform --noEmit",
     "lint": "eslint transform/src/**/*.ts tools/**/*.js eslint.config.js",
     "build:lib": "tsc -p ./tsconfig.lib.json",
-    "build:transform": "tsc -p ./transform",
-    "build:cli": "tsc -p cli",
+    "build:transform": "rm -rf ./transform/lib && tsc -p ./transform && prettier -w ./transform/",
+    "build:cli": "rm -rf ./bin/ && tsc -p cli && prettier -w ./cli/ && chmod +x ./bin/index.js",
     "build:run": "npm run build:cli",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
@@ -102,7 +99,6 @@
     "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run format",
     "commitmsg:verify": "bash ./scripts/commit-msg.sh",
     "precommit:verify": "bash ./scripts/pre-commit.sh",
-    "prepush:verify": "bash ./scripts/pre-push.sh",
     "prepare": "husky"
   },
   "type": "module"

package/transform/lib/equals.js

@@ -0,0 +1,388 @@
+import { Source, Tokenizer, } from "assemblyscript/dist/assemblyscript.js";
+import { NodeKind } from "./types.js";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { SimpleParser, isStdlib } from "./util.js";
+const EQUALS_METHOD = "__AS_TEST_EQUALS";
+const TOJSON_METHOD = "toJSON";
+const REFLECT_LOCAL = "__AS_TEST_REFLECT_EQUALS_INTERNAL";
+const STRINGIFY_LOCAL = "__AS_TEST_STRINGIFY_INTERNAL";
+const ALREADY_INJECTED_EQUALS = new WeakSet();
+const ALREADY_INJECTED_TOJSON = new WeakSet();
+const JSON_DECORATORS = ["json", "serializable"];
+export class EqualsTransform {
+    parser;
+    touchedSources = new Set();
+    classesByName = new Map();
+    constructor(parser) {
+        this.parser = parser;
+    }
+    apply(sources) {
+        for (const source of sources) {
+            if (isStdlib(source))
+                continue;
+            if (!isUserSource(source))
+                continue;
+            if (isAsTestInternal(source))
+                continue;
+            this.indexClasses(source.statements);
+        }
+        for (const source of this.parser.sources) {
+            if (isStdlib(source))
+                continue;
+            if (!isUserSource(source))
+                continue;
+            if (isAsTestInternal(source))
+                continue;
+            this.traverseStatements(source, source.statements);
+        }
+        for (const source of this.touchedSources) {
+            this.injectRuntimeImports(source);
+        }
+    }
+    indexClasses(statements) {
+        for (const stmt of statements) {
+            if (!stmt)
+                continue;
+            if (stmt.kind === NodeKind.ClassDeclaration) {
+                const klass = stmt;
+                const list = this.classesByName.get(klass.name.text);
+                if (list)
+                    list.push(klass);
+                else
+                    this.classesByName.set(klass.name.text, [klass]);
+            }
+            else if (stmt.kind === NodeKind.NamespaceDeclaration) {
+                const members = stmt.members;
+                if (members)
+                    this.indexClasses(members);
+            }
+        }
+    }
+    traverseStatements(source, statements) {
+        for (const stmt of statements) {
+            if (!stmt)
+                continue;
+            if (stmt.kind === NodeKind.ClassDeclaration) {
+                const klass = stmt;
+                const injectedEquals = this.injectEqualsMethod(klass);
+                const injectedToJSON = this.injectToJSONMethod(klass);
+                if (injectedEquals || injectedToJSON) {
+                    this.touchedSources.add(source);
+                }
+            }
+            else if (stmt.kind === NodeKind.NamespaceDeclaration) {
+                const members = stmt.members;
+                if (members)
+                    this.traverseStatements(source, members);
+            }
+        }
+    }
+    injectEqualsMethod(klass) {
+        if (ALREADY_INJECTED_EQUALS.has(klass))
+            return false;
+        if (declaresMethod(klass, EQUALS_METHOD))
+            return false;
+        if (klass.typeParameters && klass.typeParameters.length)
+            return false;
+        const fieldNames = [];
+        for (const member of klass.members) {
+            if (member.kind !== NodeKind.FieldDeclaration)
+                continue;
+            const field = member;
+            if (!field.is(262144))
+                continue;
+            if ((field.flags & 32) !== 0)
+                continue;
+            if (!field.name || !field.name.text)
+                continue;
+            fieldNames.push(field.name.text);
+        }
+        const fieldHashes = fieldNames.map((n) => djb2Hash(n).toString());
+        const className = klass.name.text;
+        const otherType = this.pinnedOtherType(klass);
+        const lines = [];
+        lines.push(`const __o = changetype<${className}>(other);`);
+        for (let i = 0; i < fieldNames.length; i++) {
+            const name = fieldNames[i];
+            const hash = fieldHashes[i];
+            lines.push(`if (!ignore.includes(${hash}) && ` +
+                `!${REFLECT_LOCAL}(this.${name}, __o.${name}, stack, strict)) return false;`);
+        }
+        const ignoreLiteral = fieldHashes.length
+            ? `[${fieldHashes.join(", ")}] as StaticArray<i64>`
+            : `[] as StaticArray<i64>`;
+        lines.push(`if (isDefined(super.__AS_TEST_EQUALS)) {` +
+            ` if (!super.__AS_TEST_EQUALS(other, stack, ` +
+            `StaticArray.concat<i64>(ignore, ${ignoreLiteral}), strict)) return false;` +
+            ` }`);
+        lines.push(`return true;`);
+        const code = `${EQUALS_METHOD}(` +
+            `other: ${otherType}, ` +
+            `stack: usize[], ` +
+            `ignore: StaticArray<i64>, ` +
+            `strict: bool` +
+            `): bool { ${lines.join(" ")} }`;
+        try {
+            const method = SimpleParser.parseClassMember(code, klass);
+            klass.members.push(method);
+            ALREADY_INJECTED_EQUALS.add(klass);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    pinnedOtherType(klass) {
+        const seen = new Set();
+        let current = klass;
+        let rootName = klass.name.text;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            const userType = userDeclaredEqualsOtherType(current);
+            if (userType)
+                return userType;
+            rootName = current.name.text;
+            const parentName = extendsName(current);
+            if (!parentName)
+                return rootName;
+            const parents = this.classesByName.get(parentName);
+            if (!parents || parents.length === 0)
+                return rootName;
+            current = parents[0];
+        }
+        return rootName;
+    }
+    injectRuntimeImports(source) {
+        const asTestPath = detectAsTestImportPath(source.text) ?? "as-test";
+        const importLine = `import { reflectEquals as ${REFLECT_LOCAL}, ` +
+            `__as_test_stringify as ${STRINGIFY_LOCAL} } from "${asTestPath}";`;
+        const tokenizer = new Tokenizer(new Source(0, source.normalizedPath, importLine));
+        this.parser.currentSource = tokenizer.source;
+        source.statements.unshift(this.parser.parseTopLevelStatement(tokenizer));
+        this.parser.currentSource = source;
+    }
+    injectToJSONMethod(klass) {
+        if (ALREADY_INJECTED_TOJSON.has(klass))
+            return false;
+        if (declaresMethod(klass, TOJSON_METHOD))
+            return false;
+        if (hasAnyDecorator(klass, JSON_DECORATORS))
+            return false;
+        if (klass.typeParameters && klass.typeParameters.length)
+            return false;
+        const fieldNames = this.collectChainFieldNames(klass);
+        const chainNames = this.collectChainClassNames(klass);
+        const renderable = [];
+        for (const name of fieldNames) {
+            const fieldType = this.fieldTypeName(klass, name);
+            if (fieldType && chainNames.has(fieldType))
+                continue;
+            renderable.push(name);
+        }
+        const parts = [];
+        for (let i = 0; i < renderable.length; i++) {
+            const name = renderable[i];
+            const prefix = i === 0 ? "" : ",";
+            parts.push(`"${prefix}\\"${name}\\":" + ${STRINGIFY_LOCAL}(this.${name})`);
+        }
+        const body = parts.length
+            ? `return "{" + ${parts.join(" + ")} + "}";`
+            : `return "{}";`;
+        const code = `toJSON(): string { ${body} }`;
+        try {
+            const method = SimpleParser.parseClassMember(code, klass);
+            klass.members.push(method);
+            ALREADY_INJECTED_TOJSON.add(klass);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    collectChainFieldNames(klass) {
+        const chain = [];
+        const seen = new Set();
+        let current = klass;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            chain.unshift(current);
+            const parentName = extendsName(current);
+            if (!parentName)
+                break;
+            const parents = this.classesByName.get(parentName);
+            if (!parents || parents.length === 0)
+                break;
+            current = parents[0];
+        }
+        const ordered = [];
+        const known = new Set();
+        for (const cls of chain) {
+            for (const member of cls.members) {
+                if (member.kind !== NodeKind.FieldDeclaration)
+                    continue;
+                const field = member;
+                if (!field.is(262144))
+                    continue;
+                if ((field.flags & 32) !== 0)
+                    continue;
+                if (!field.name || !field.name.text)
+                    continue;
+                const name = field.name.text;
+                if (known.has(name))
+                    continue;
+                known.add(name);
+                ordered.push(name);
+            }
+        }
+        return ordered;
+    }
+    collectChainClassNames(klass) {
+        const out = new Set();
+        const seen = new Set();
+        let current = klass;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            out.add(current.name.text);
+            const parentName = extendsName(current);
+            if (!parentName)
+                break;
+            const parents = this.classesByName.get(parentName);
+            if (!parents || parents.length === 0)
+                break;
+            current = parents[0];
+        }
+        return out;
+    }
+    fieldTypeName(klass, fieldName) {
+        const seen = new Set();
+        let current = klass;
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            for (const member of current.members) {
+                if (member.kind !== NodeKind.FieldDeclaration)
+                    continue;
+                const field = member;
+                if (!field.name || field.name.text !== fieldName)
+                    continue;
+                return namedTypeText(field.type);
+            }
+            const parentName = extendsName(current);
+            if (!parentName)
+                break;
+            const parents = this.classesByName.get(parentName);
+            if (!parents || parents.length === 0)
+                break;
+            current = parents[0];
+        }
+        return null;
+    }
+}
+function declaresMethod(klass, name) {
+    for (const member of klass.members) {
+        if (member.kind !== NodeKind.MethodDeclaration)
+            continue;
+        const method = member;
+        if (method.name && method.name.text === name)
+            return true;
+    }
+    return false;
+}
+function hasAnyDecorator(klass, names) {
+    if (!klass.decorators)
+        return false;
+    for (const dec of klass.decorators) {
+        const decName = dec.name.text;
+        if (decName && names.indexOf(decName) !== -1)
+            return true;
+    }
+    return false;
+}
+function userDeclaredEqualsOtherType(klass) {
+    for (const member of klass.members) {
+        if (member.kind !== NodeKind.MethodDeclaration)
+            continue;
+        const method = member;
+        if (!method.name || method.name.text !== EQUALS_METHOD)
+            continue;
+        const params = method.signature.parameters;
+        if (!params || params.length === 0)
+            return null;
+        return namedTypeText(params[0].type);
+    }
+    return null;
+}
+function extendsName(klass) {
+    const extendsType = klass
+        .extendsType;
+    if (!extendsType)
+        return null;
+    return namedTypeText(extendsType);
+}
+function namedTypeText(type) {
+    if (!type)
+        return null;
+    if (type.kind !== NodeKind.NamedType)
+        return null;
+    const named = type;
+    if (!named.name)
+        return null;
+    const ident = named.name
+        .identifier;
+    if (ident && typeof ident.text === "string")
+        return ident.text;
+    const text = named.name.text;
+    return text ?? null;
+}
+function isUserSource(source) {
+    return (source.sourceKind === 0 ||
+        source.sourceKind === 1);
+}
+let cachedIsAsTestCwd = null;
+function isAsTestOwnCwd() {
+    if (cachedIsAsTestCwd !== null)
+        return cachedIsAsTestCwd;
+    try {
+        const raw = readFileSync(join(process.cwd(), "package.json"), "utf8");
+        const pkg = JSON.parse(raw);
+        cachedIsAsTestCwd = pkg.name === "as-test";
+    }
+    catch {
+        cachedIsAsTestCwd = false;
+    }
+    return cachedIsAsTestCwd;
+}
+function isAsTestInternal(source) {
+    const p = source.normalizedPath;
+    if (/(?:^|\/)as-test\/assembly\/(?!__tests__\/)/.test(p))
+        return true;
+    if (isAsTestOwnCwd() && /^assembly\/(?!__tests__\/)/.test(p))
+        return true;
+    return false;
+}
+function detectAsTestImportPath(sourceText) {
+    const text = sourceText
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/.*$/gm, "");
+    const imports = text.matchAll(/import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g);
+    for (const match of imports) {
+        const specifiers = match[1] ?? "";
+        const modulePath = (match[2] ?? "").trim();
+        if (!modulePath.length)
+            continue;
+        if (modulePath === "as-test" || modulePath.endsWith("/as-test")) {
+            return modulePath;
+        }
+        if (/\b(?:describe|test|it|expect|beforeAll|afterAll|beforeEach|afterEach|mockFn|unmockFn|mockImport|unmockImport|snapshotFn|log|run)\b/.test(specifiers)) {
+            return modulePath;
+        }
+    }
+    return null;
+}
+function djb2Hash(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++) {
+        h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+    }
+    return h >>> 0;
+}

package/transform/lib/index.js

@@ -4,9 +4,12 @@ import { CoverageTransform } from "./coverage.js";
 import { MockTransform } from "./mock.js";
 import { LocationTransform } from "./location.js";
 import { LogTransform } from "./log.js";
+import { EqualsTransform } from "./equals.js";
 import { isStdlib } from "./util.js";
+import { NodeKind } from "./types.js";
 export default class Transformer extends Transform {
     afterParse(parser) {
+        patchModeName(parser, process.env.AS_TEST_MODE_NAME ?? "default");
         const mock = new MockTransform();
         const location = new LocationTransform();
         const log = new LogTransform(parser);
@@ -79,6 +82,31 @@ export default class Transformer extends Transform {
         if (coverage) {
             coverage.globalStatements = [];
         }
+        new EqualsTransform(parser).apply(parser.sources);
+    }
+}
+function patchModeName(parser, modeName) {
+    for (const source of parser.sources) {
+        if (!source.normalizedPath.endsWith("assembly/src/mode.ts"))
+            continue;
+        for (const stmt of source.statements) {
+            if (stmt.kind !== NodeKind.Variable)
+                continue;
+            const decls = stmt.declarations;
+            for (const decl of decls) {
+                if (decl.name.text !== "AS_TEST_MODE_NAME")
+                    continue;
+                if (!decl.initializer)
+                    continue;
+                if (decl.initializer.kind !== NodeKind.Literal)
+                    continue;
+                const literal = decl.initializer;
+                if (literal.literalKind !== 2)
+                    continue;
+                literal.value = modeName;
+                return;
+            }
+        }
     }
 }
 function collectMockImportTargets(sources) {