@rspack-debug/test-tools 1.3.14

package/dist/helper/legacy/warmup-webpack.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/legacy/warmup-webpack.js

@@ -0,0 +1,26 @@
+"use strict";
+// @ts-nocheck
+describe("warmup", () => {
+    it("should warmup webpack", done => {
+        let webpack = require("@rspack/core");
+        const END = new Error("end warmup");
+        webpack({
+            entry: "data:text/javascript,import 'data:text/javascript,'",
+            plugins: [
+                c => c.hooks.emit.tap("Warmup", () => {
+                    throw END;
+                })
+            ]
+        }, err => {
+            webpack = undefined;
+            try {
+                // CHANGE: rspack will format error into diagnostic.
+                expect(err.message).toContain("end warmup");
+                done();
+            }
+            catch (e) {
+                done(e);
+            }
+        });
+    }, 300000);
+});

package/dist/helper/loaders/hot-update.d.ts

@@ -0,0 +1 @@
+export default function (this: any, c: string): string;

package/dist/helper/loaders/hot-update.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(c) {
+    let content = c;
+    if (content.includes("NEXT_HMR")) {
+        content = `
+			${content}
+			let __hmr_children__ = [...module.children];
+      let __hmr_used_exports__ = __hmr_children__.reduce((res, child) => {
+        if (__webpack_module_cache__[child]) {
+          res[child] = __webpack_module_cache__[child].exports;
+        }
+				return res;
+			}, {});
+			module.hot.accept(__hmr_children__, () => {
+				__hmr_children__.forEach((child) => {
+					const reexports = __webpack_require__(child);
+          for (let key in reexports) {
+            if (!__hmr_used_exports__[child]) { continue; }
+						Object.defineProperty(__hmr_used_exports__[child], key, {
+							configurable: true,
+							enumerable: true,
+							get: () => reexports[key]
+						});
+					}
+				});
+			});
+		`;
+    }
+    content = content.replace(/NEXT_HMR/g, "NEXT_HMR.bind(null, module)");
+    const options = this.getOptions();
+    const items = content.split(/---+\r?\n/g);
+    if (items.length <= 1) {
+        return content;
+    }
+    options.totalUpdates = Math.max(options.totalUpdates, items.length);
+    options.changedFiles.push(this.resourcePath);
+    return items[options.updateIndex];
+}

package/dist/helper/parse-modules.d.ts

@@ -0,0 +1,7 @@
+export declare function parseModules(content: string, options?: {
+    bootstrap?: boolean;
+    renameModule?: (name: string) => string;
+}): {
+    modules: Record<string, string>;
+    runtimeModules: Record<string, string>;
+};

package/dist/helper/parse-modules.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModules = parseModules;
+const BOOTSTRAP_SPLIT_LINE = "/************************************************************************/";
+const MODULE_START_FLAG = "/* start::";
+const MODULE_END_FLAG = "/* end::";
+const MODULE_FLAG_END = " */";
+function getStringBetween(raw, position, start, end) {
+    const startFlagIndex = raw.indexOf(start, position);
+    if (startFlagIndex === -1) {
+        return {
+            result: null,
+            remain: position
+        };
+    }
+    const endFlagIndex = raw.indexOf(end, startFlagIndex + start.length);
+    if (endFlagIndex === -1) {
+        return {
+            result: null,
+            remain: position
+        };
+    }
+    return {
+        result: raw.slice(startFlagIndex + start.length, endFlagIndex),
+        remain: endFlagIndex + end.length
+    };
+}
+function isValidModule(name) {
+    if (name.startsWith("data:")) {
+        return false;
+    }
+    if (name.startsWith("https:")) {
+        return false;
+    }
+    return true;
+}
+function parseModules(content, options = {}) {
+    const modules = {};
+    const runtimeModules = {};
+    let currentPosition = 0;
+    if (options.bootstrap) {
+        // parse bootstrap code
+        const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
+        if (bootstrap.result) {
+            runtimeModules["webpack/runtime/bootstrap"] = bootstrap.result;
+        }
+    }
+    // parse module & runtime module code
+    let moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;
+    while (moduleName) {
+        const moduleContent = getStringBetween(content, currentPosition, `${MODULE_START_FLAG}${moduleName}${MODULE_FLAG_END}`, `${MODULE_END_FLAG}${moduleName}${MODULE_FLAG_END}`);
+        if (!moduleContent.result) {
+            throw new Error(`Module code parsed error: ${moduleName}`);
+        }
+        const renamedModuleName = typeof options.renameModule === "function"
+            ? options.renameModule(moduleName)
+            : moduleName;
+        if (moduleName.startsWith("webpack/runtime")) {
+            runtimeModules[renamedModuleName] = moduleContent.result;
+        }
+        else {
+            if (isValidModule(moduleName)) {
+                modules[renamedModuleName] = moduleContent.result;
+            }
+        }
+        currentPosition = moduleContent.remain;
+        moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;
+    }
+    return {
+        modules,
+        runtimeModules
+    };
+}

package/dist/helper/plugins/hot-update.d.ts

@@ -0,0 +1,7 @@
+import type { Compiler } from "@rspack/core";
+import type { TUpdateOptions } from "../../type";
+export declare class TestHotUpdatePlugin {
+    private updateOptions;
+    constructor(updateOptions: TUpdateOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/helper/plugins/hot-update.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestHotUpdatePlugin = void 0;
+class TestHotUpdatePlugin {
+    constructor(updateOptions) {
+        this.updateOptions = updateOptions;
+    }
+    apply(compiler) {
+        let isRebuild = false;
+        compiler.hooks.beforeRun.tap("TestHotUpdatePlugin", () => {
+            if (isRebuild) {
+                compiler.modifiedFiles = new Set(this.updateOptions.changedFiles);
+            }
+            else {
+                compiler.modifiedFiles = new Set();
+            }
+            this.updateOptions.changedFiles = [];
+            isRebuild = true;
+        });
+        compiler.hooks.compilation.tap("TestHotUpdatePlugin", compilation => {
+            compilation.hooks.additionalTreeRuntimeRequirements.tap("HMR_TEST_PLUGIN", (_chunk, set) => {
+                set.add(compiler.webpack.RuntimeGlobals.moduleCache);
+            });
+            compilation.hooks.runtimeModule.tap("HMR_TEST_PLUGIN", (module, _set) => {
+                if (module.constructorName === "DefinePropertyGettersRuntimeModule") {
+                    module.source.source = Buffer.from(`
+										__webpack_require__.d = function (exports, definition) {
+												for (var key in definition) {
+														if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+																Object.defineProperty(exports, key, { configurable: true, enumerable: true, get: definition[key] });
+														}
+												}
+										};
+										`, "utf-8");
+                }
+            });
+        });
+    }
+}
+exports.TestHotUpdatePlugin = TestHotUpdatePlugin;

package/dist/helper/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from "./hot-update";

package/dist/helper/plugins/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hot-update"), exports);

package/dist/helper/read-config-file.d.ts

@@ -0,0 +1,2 @@
+import type { ECompilerType, TCompilerOptions } from "../type";
+export declare function readConfigFile<T extends ECompilerType>(files: string[], functionApply?: (config: (TCompilerOptions<T> | ((...args: unknown[]) => TCompilerOptions<T>))[]) => TCompilerOptions<T>[]): TCompilerOptions<T>[];

package/dist/helper/read-config-file.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfigFile = readConfigFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function readConfigFile(files, functionApply) {
+    const existsFile = files.find(i => fs_extra_1.default.existsSync(i));
+    const fileConfig = existsFile ? require(existsFile) : {};
+    const configArr = Array.isArray(fileConfig) ? fileConfig : [fileConfig];
+    return functionApply ? functionApply(configArr) : configArr;
+}

package/dist/helper/serializers.d.ts

@@ -0,0 +1,2 @@
+import type { Plugins } from "pretty-format";
+export declare const serializers: Plugins;

package/dist/helper/serializers.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializers = void 0;
+const diff_1 = require("./expect/diff");
+const error_1 = require("./expect/error");
+const placeholder_1 = require("./expect/placeholder");
+const rspack_1 = require("./expect/rspack");
+exports.serializers = [
+    {
+        test(received) {
+            return typeof received === "string";
+        },
+        print(received) {
+            return (0, placeholder_1.normalizePlaceholder)(received.trim());
+        }
+    },
+    // for diff
+    {
+        test(received) {
+            return received?.constructor?.name === "RspackTestDiff";
+        },
+        print(received, next) {
+            return next((0, diff_1.normalizeDiff)(received));
+        }
+    },
+    // for errors
+    {
+        test(received) {
+            return received?.constructor?.name === "RspackStatsDiagnostics";
+        },
+        print(received, next) {
+            return next((0, error_1.normalizeDignostics)(received));
+        }
+    },
+    {
+        test(received) {
+            return typeof received?.message === "string";
+        },
+        print(received, next) {
+            return next((0, error_1.normalizeError)(received));
+        }
+    },
+    // for stats
+    {
+        test(received) {
+            return received?.constructor?.name === "RspackStats";
+        },
+        print(received, next) {
+            return next((0, rspack_1.normalizeStats)(received));
+        }
+    }
+];

package/dist/helper/setup-env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/setup-env.js

@@ -0,0 +1,80 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+if (process.env.ALTERNATIVE_SORT) {
+    const oldSort = Array.prototype.sort;
+    Array.prototype.sort = function (cmp) {
+        oldSort.call(this, cmp);
+        if (cmp) {
+            for (let i = 1; i < this.length; i++) {
+                if (cmp(this[i - 1], this[i]) === 0) {
+                    let j = i + 1;
+                    for (; j < this.length; j++) {
+                        if (cmp(this[j - 1], this[j]) !== 0) {
+                            break;
+                        }
+                    }
+                    for (let x = i - 1, y = j - 1; x < y; x++, y--) {
+                        const temp = this[x];
+                        this[x] = this[y];
+                        this[y] = temp;
+                    }
+                    i = j;
+                }
+            }
+        }
+        return this;
+    };
+}
+// Setup debugging info for tests
+if (process.env.DEBUG_INFO) {
+    const addDebugInfo = it => {
+        return (name, fn, timeout) => {
+            if (fn.length === 0) {
+                it(name, () => {
+                    process.stdout.write(`START1 ${name}\n`);
+                    try {
+                        const promise = fn();
+                        if (promise?.then) {
+                            return promise.then(r => {
+                                process.stdout.write(`DONE OK ${name}\n`);
+                                return r;
+                            }, e => {
+                                process.stdout.write(`DONE FAIL ${name}\n`);
+                                throw e;
+                            });
+                        }
+                        process.stdout.write(`DONE OK ${name}\n`);
+                    }
+                    catch (e) {
+                        process.stdout.write(`DONE FAIL ${name}\n`);
+                        throw e;
+                    }
+                }, timeout);
+            }
+            else {
+                it(name, done => {
+                    process.stdout.write(`START2 ${name}\n`);
+                    return fn(err => {
+                        if (err) {
+                            process.stdout.write(`DONE FAIL ${name}\n`);
+                        }
+                        else {
+                            process.stdout.write(`DONE OK ${name}\n`);
+                        }
+                        return done(err);
+                    });
+                }, timeout);
+            }
+        };
+    };
+    // eslint-disable-next-line no-global-assign
+    it = addDebugInfo(it);
+}
+// cspell:word wabt
+// Workaround for a memory leak in wabt
+// It leaks an Error object on construction
+// so it leaks the whole stack trace
+require("wast-loader");
+process.removeAllListeners("uncaughtException");
+process.removeAllListeners("unhandledRejection");

package/dist/helper/setup-expect.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/setup-expect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const to_be_typeof_1 = require("./expect/to-be-typeof");
+const to_end_with_1 = require("./expect/to-end-with");
+const to_match_file_snapshot_1 = require("./expect/to-match-file-snapshot");
+const serializers_1 = require("./serializers");
+expect.extend({
+    // CHANGE: new test matcher for `rspack-test-tools`
+    // @ts-ignore
+    toMatchFileSnapshot: to_match_file_snapshot_1.toMatchFileSnapshot,
+    toBeTypeOf: to_be_typeof_1.toBeTypeOf,
+    toEndWith: to_end_with_1.toEndWith
+});
+for (const serializer of serializers_1.serializers) {
+    expect.addSnapshotSerializer(serializer);
+}

package/dist/helper/update-snapshot.d.ts

@@ -0,0 +1 @@
+export declare function isUpdateSnapshot(): boolean;

package/dist/helper/update-snapshot.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUpdateSnapshot = isUpdateSnapshot;
+function isUpdateSnapshot() {
+    return global.updateSnapshot || process.env.UPDATE_SNAPSHOT === "true";
+}

package/dist/helper/util/checkSourceMap.d.ts

@@ -0,0 +1 @@
+export default function checkSourceMap(out: any, outCodeMap: any, toSearch: any, _checkColumn?: boolean): Promise<boolean>;

package/dist/helper/util/checkSourceMap.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkSourceMap;
+// @ts-nocheck
+// Check the mapping of various key locations back to the original source
+async function checkSourceMap(out, outCodeMap, toSearch, _checkColumn = true // passing `false` indicating it's an `OriginalSource`.
+) {
+    let failed = false;
+    const recordCheck = (success, message) => {
+        if (!success) {
+            failed = true;
+            console.error(`❌ ${message}`);
+        }
+    };
+    const sourceMap = require("source-map");
+    const path = require("node:path");
+    const sources = JSON.parse(outCodeMap).sources;
+    for (const source of sources) {
+        if (sources.filter(s => s === source).length > 1) {
+            throw new Error(`Duplicate source ${JSON.stringify(source)} found in source map`);
+        }
+    }
+    const map = await new sourceMap.SourceMapConsumer(outCodeMap);
+    for (const id in toSearch) {
+        const isSearchConfig = typeof toSearch[id] === "object" && toSearch[id] !== null;
+        const outId = isSearchConfig ? (toSearch[id].outId ?? id) : id;
+        const checkColumn = isSearchConfig
+            ? (toSearch[id].checkColumn ?? _checkColumn)
+            : _checkColumn;
+        const inSource = isSearchConfig ? toSearch[id].inSource : toSearch[id];
+        const outIndex = out.indexOf(outId);
+        if (outIndex < 0)
+            throw new Error(`Failed to find "${outId}" in output ${out}`);
+        const outLines = out.slice(0, outIndex).split("\n");
+        const outLine = outLines.length;
+        const outLastLine = outLines[outLines.length - 1];
+        let outColumn = outLastLine.length;
+        const { source, line, column } = map.originalPositionFor({
+            line: outLine,
+            column: outColumn
+        });
+        recordCheck(source === inSource, `expected source: ${inSource}, observed source: ${source}@${line}:${column}, {out_source}@${outLine}:${outColumn}. ${checkColumn ? "" : "(column ignored)"}`);
+        const inCode = map.sourceContentFor(source);
+        let inIndex = inCode.indexOf(id);
+        if (inIndex < 0)
+            inIndex = inCode.indexOf(`'${id}'`);
+        if (inIndex < 0)
+            throw new Error(`Failed to find "${id}" in input ${inCode}`);
+        const inLines = inCode.slice(0, inIndex).split("\n");
+        const inLine = inLines.length;
+        const inLastLine = inLines[inLines.length - 1];
+        let inColumn = inLastLine.length;
+        if (path.extname(source) === "css") {
+            const outMatch = /\s*content:\s*$/.exec(outLastLine);
+            const inMatch = /\bcontent:\s*$/.exec(inLastLine);
+            if (outMatch)
+                outColumn -= outMatch[0].length;
+            if (inMatch)
+                inColumn -= inMatch[0].length;
+        }
+        const expected = JSON.stringify({
+            source,
+            line: inLine,
+            column: checkColumn ? inColumn : 0
+        });
+        const observed = JSON.stringify({ source, line, column });
+        recordCheck(expected === observed, `expected original position: ${expected}, observed original position: ${observed}, out: ${`${outLine},${outColumn},${outIndex}:${outId}`}, ${checkColumn ? "" : "(column ignored)"}`);
+        // Also check the reverse mapping
+        const positions = map.allGeneratedPositionsFor({
+            source,
+            line: inLine,
+            column: checkColumn ? inColumn : 0
+        });
+        recordCheck(positions.length > 0, `expected generated positions: 1, observed generated positions: ${positions.length} ${checkColumn ? "" : "(column ignored)"}`);
+        let found = false;
+        for (const { line, column } of positions) {
+            if (line === outLine) {
+                if (!checkColumn && column === 0) {
+                    found = true;
+                    break;
+                }
+                if (checkColumn && column === outColumn) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        const expectedPosition = JSON.stringify({
+            line: outLine,
+            column: outColumn
+        });
+        const observedPositions = JSON.stringify(positions);
+        recordCheck(found, `expected generated position: ${expectedPosition}, observed generated positions: ${observedPositions} ${checkColumn ? "" : "(column ignored)"}`);
+    }
+    return !failed;
+}

package/dist/helper/util/checkStats.d.ts

@@ -0,0 +1,2 @@
+export function checkChunkModules(statsJson: any, chunkModulesMap: any, strict?: boolean): boolean;
+export function checkChunkRuntime(statsJson: any, chunkModulesMap: any, strict?: boolean): boolean;

package/dist/helper/util/checkStats.js

@@ -0,0 +1,43 @@
+"use strict";
+// @ts-nocheck
+exports.checkChunkModules = function checkChunkModules(statsJson, chunkModulesMap, strict = true) {
+    for (const chunkId of Reflect.ownKeys(chunkModulesMap)) {
+        const chunk = getChunk(statsJson, chunkId);
+        const expectedModules = chunkModulesMap[chunkId];
+        const chunkModules = chunk.modules.map(m => m.identifier);
+        if (strict && expectedModules.length !== chunkModules.length) {
+            throw new Error(`expect chunk ${chunkId} has ${chunkModules.length} modules: ${chunkModules}\nbut received ${chunkModules.length} modules`);
+        }
+        for (const module of expectedModules) {
+            if (!chunkModules.find(moduleId => moduleId.includes(module))) {
+                throw new Error(`chunk ${chunkId} has no module contains id: ${module}`);
+            }
+        }
+    }
+    return true;
+};
+exports.checkChunkRuntime = function checkChunkModules(statsJson, chunkModulesMap, strict = true) {
+    for (const chunkId of Reflect.ownKeys(chunkModulesMap)) {
+        const chunk = getChunk(statsJson, chunkId);
+        const expectedRuntime = chunkModulesMap[chunkId];
+        const chunkRuntime = chunk.runtime;
+        if (strict) {
+            expectedRuntime.length === chunkRuntime.length;
+        }
+        for (let i = 0; i < expectedRuntime.length; i++) {
+            const expected = expectedRuntime[i];
+            const rt = chunkRuntime[i];
+            if (expected !== rt) {
+                throw new Error(`chunk ${chunkId} runtime not equal, expected: ${expectedRuntime}, but got: ${chunkRuntime}`);
+            }
+        }
+    }
+    return true;
+};
+function getChunk(statsJson, id) {
+    const chunk = statsJson.chunks.find(chunk => chunk.id.includes(id));
+    if (!chunk) {
+        throw new Error(`cannot find chunk with id: ${id}`);
+    }
+    return chunk;
+}

package/dist/helper/util/currentWatchStep.d.ts

@@ -0,0 +1 @@
+export const step: {};

package/dist/helper/util/currentWatchStep.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.step = {};

package/dist/helper/util/expectWarningFactory.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): (...regexp: any[]) => void;
+export = _exports;

package/dist/helper/util/expectWarningFactory.js

@@ -0,0 +1,21 @@
+"use strict";
+// @ts-nocheck
+module.exports = () => {
+    const warnings = [];
+    let oldWarn;
+    beforeEach(done => {
+        oldWarn = console.warn;
+        console.warn = m => warnings.push(m);
+        done();
+    });
+    afterEach(done => {
+        expectWarning();
+        console.warn = oldWarn;
+        done();
+    });
+    const expectWarning = (...regexp) => {
+        expect(warnings).toEqual(regexp.map(r => expect.stringMatching(r)));
+        warnings.length = 0;
+    };
+    return expectWarning;
+};

package/dist/helper/util/filterUtil.d.ts

@@ -0,0 +1,8 @@
+export namespace FilteredStatus {
+    let TODO: string;
+    let PARTIAL_PASS: string;
+    let FAILED: string;
+    let NO_PLAN: string;
+}
+export function decodeFilteredTest(encoded: any): any;
+export function normalizeFilteredTestName(flag: any, testName: any): string;

package/dist/helper/util/filterUtil.js

@@ -0,0 +1,50 @@
+"use strict";
+// @ts-nocheck
+const FilteredStatus = {
+    TODO: "TODO",
+    PARTIAL_PASS: "PARTIAL_PASS",
+    FAILED: "FAILED",
+    NO_PLAN: "NO_PLAN"
+};
+function validateFilteredStatus(status) {
+    return Object.values(FilteredStatus).includes(status);
+}
+function normalizeFilterFlag(flag, testName) {
+    if (flag === false) {
+        return { status: FilteredStatus.TODO, reason: "TODO" };
+    }
+    if (flag === -1) {
+        return { status: FilteredStatus.NO_PLAN, reason: "No plan" };
+    }
+    if (typeof flag === "string") {
+        return { status: FilteredStatus.FAILED, reason: flag };
+    }
+    if (Array.isArray(flag)) {
+        const [status, reason = "empty"] = flag;
+        if (validateFilteredStatus(status)) {
+            return { status, reason };
+        }
+    }
+    throw new Error(`Unvalidate filter flag "${flag}" for "${testName}"`);
+}
+function encodeFilteredTest(status, reason) {
+    return `{{ status = ${status}, reason = ${reason} }}`;
+}
+function decodeFilteredTest(encoded) {
+    const regex = /(.*) {{ status = (.*), reason = (.*) }}$/;
+    const result = encoded.match(regex);
+    if (result === null) {
+        return result;
+    }
+    const [, fullName, status, reason] = result;
+    return { fullName, status, reason };
+}
+function normalizeFilteredTestName(flag, testName) {
+    const { status, reason } = normalizeFilterFlag(flag, testName);
+    return encodeFilteredTest(status, reason);
+}
+module.exports = {
+    FilteredStatus,
+    decodeFilteredTest,
+    normalizeFilteredTestName
+};