@rspack-debug/test-tools 1.4.11 → 1.6.2

package/dist/case/watch.js

@@ -3,16 +3,201 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchInitialProcessor = createWatchInitialProcessor;
+exports.createWatchStepProcessor = createWatchStepProcessor;
 exports.createWatchCase = createWatchCase;
+exports.getWatchRunnerKey = getWatchRunnerKey;
+exports.createWatchRunner = createWatchRunner;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const watch_1 = require("../processor/watch");
+const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const compiler_1 = require("../compiler");
+const helper_1 = require("../helper");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const copyDiff_1 = __importDefault(require("../helper/legacy/copyDiff"));
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
+    const watchContext = {
+        currentTriggerFilename: null,
+        lastHash: null,
+        step,
+        tempDir,
+        nativeWatcher,
+        watchState
+    };
+    return {
+        before: async (context) => {
+            context.setValue("watchContext", watchContext);
+        },
+        config: async (context) => {
+            const testConfig = context.getTestConfig();
+            const multiCompilerOptions = [];
+            const caseOptions = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)), context, {});
+            for (const [index, options] of caseOptions.entries()) {
+                const compilerOptions = (0, webpack_merge_1.default)(defaultOptions({
+                    incremental,
+                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings
+                }), options);
+                overrideOptions(index, context, compilerOptions, tempDir, nativeWatcher);
+                multiCompilerOptions.push(compilerOptions);
+            }
+            const compilerOptions = multiCompilerOptions.length === 1
+                ? multiCompilerOptions[0]
+                : multiCompilerOptions;
+            const compiler = context.getCompiler();
+            compiler.setOptions(compilerOptions);
+            context.setValue("multiCompilerOptions", multiCompilerOptions);
+        },
+        compiler: async (context) => {
+            const c = await (0, common_1.compiler)(context, name);
+            c.hooks.invalid.tap("WatchTestCasesTest", (filename, mtime) => {
+                watchContext.currentTriggerFilename = filename;
+            });
+        },
+        build: async (context) => {
+            const compiler = context.getCompiler();
+            node_fs_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
+            (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
+            const task = new Promise((resolve, reject) => {
+                compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                    if (e)
+                        return reject(e);
+                    resolve(stats);
+                });
+            });
+            compiler.watch();
+            await task;
+        },
+        run: async (env, context) => {
+            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (index, context, options) => findBundle(index, context, options, step)));
+        },
+        check: async (env, context) => {
+            const testConfig = context.getTestConfig();
+            if (testConfig.noTests)
+                return;
+            const errors = (context.getError() || []).map(e => ({
+                message: e.message,
+                stack: e.stack
+            }));
+            const warnings = [];
+            const compiler = context.getCompiler();
+            const stats = compiler.getStats();
+            const options = compiler.getOptions();
+            const checkStats = testConfig.checkStats || (() => true);
+            if (stats) {
+                if (testConfig.writeStatsOuptut) {
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                        preset: "verbose",
+                        colors: false
+                    }), "utf-8");
+                }
+                const getJsonStats = (() => {
+                    let cached = null;
+                    return () => {
+                        if (!cached) {
+                            cached = stats.toJson({
+                                errorDetails: true
+                            });
+                        }
+                        return cached;
+                    };
+                })();
+                const getStringStats = (() => {
+                    let cached = null;
+                    return () => {
+                        if (!cached) {
+                            cached = stats.toString({
+                                logging: "verbose"
+                            });
+                        }
+                        return cached;
+                    };
+                })();
+                if (checkStats.length > 1) {
+                    if (!checkStats(watchContext.step, getJsonStats(), getStringStats())) {
+                        throw new Error("stats check failed");
+                    }
+                }
+                else {
+                    // @ts-expect-error only one param
+                    if (!checkStats(watchContext.step)) {
+                        throw new Error("stats check failed");
+                    }
+                }
+                if (testConfig.writeStatsJson) {
+                    node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(getJsonStats(), null, 2), "utf-8");
+                }
+                if (node_fs_1.default.existsSync(context.getSource(`${watchContext.step}/errors.js`)) ||
+                    node_fs_1.default.existsSync(context.getSource(`${watchContext.step}/warnings.js`)) ||
+                    stats.hasErrors() ||
+                    stats.hasWarnings()) {
+                    const statsJson = stats.toJson({
+                        errorDetails: true
+                    });
+                    if (statsJson.errors) {
+                        errors.push(...statsJson.errors);
+                    }
+                    if (statsJson.warnings) {
+                        warnings.push(...statsJson.warnings);
+                    }
+                }
+            }
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { errors }, "error", "errors", "Error", options);
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, "warning", "warnings", "Warning", options);
+            // clear error if checked
+            if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
+                context.clearError();
+            }
+            // check hash
+            if (testConfig.writeStatsOuptut) {
+                node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.txt"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.txt`));
+            }
+            if (testConfig.writeStatsJson) {
+                node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.json"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.json`));
+            }
+        },
+        after: async (context) => {
+            await (0, common_1.afterExecute)(context, name);
+        }
+    };
+}
+function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
+    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, { incremental });
+    processor.compiler = async (context) => {
+        // do nothing
+    };
+    processor.build = async (context) => {
+        const compiler = context.getCompiler();
+        const task = new Promise((resolve, reject) => {
+            compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                if (e)
+                    return reject(e);
+                resolve(stats);
+            });
+        });
+        // wait compiler to ready watch the files and diretories
+        // Native Watcher using [notify](https://github.com/notify-rs/notify) to watch files.
+        // After tests, notify will cost many milliseconds to watch in windows OS when jest run concurrently.
+        // So we need to wait a while to ensure the watcher is ready.
+        // If we don't wait, copyDiff will happen before the watcher is ready,
+        // which will cause the compiler not rebuild when the files change.
+        // The timeout is set to 400ms for windows OS and 100ms for other OS.
+        // TODO: This is a workaround, we can remove it when notify support windows better.
+        const timeout = nativeWatcher && process.platform === "win32" ? 400 : 100;
+        await new Promise(resolve => setTimeout(resolve, timeout));
+        (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), step), tempDir, false);
+        await task;
+    };
+    return processor;
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    runner: runner_1.WatchRunnerFactory,
+    runner: {
+        key: getWatchRunnerKey,
+        runner: createWatchRunner
+    },
     description: (name, index) => {
         return index === 0
             ? `${name} should compile`
@@ -24,30 +209,141 @@ const creator = new creator_1.BasicCaseCreator({
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
-            .filter(name => {
-            return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
-        })
+            .filter(name => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
             .map(name => ({ name }));
         return runs.map((run, index) => index === 0
-            ? new watch_1.WatchProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"]
-            }, watchState)
-            : new watch_1.WatchStepProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"]
-            }, watchState));
+            ? createWatchInitialProcessor(name, temp, run.name, watchState)
+            : createWatchStepProcessor(name, temp, run.name, watchState));
     },
     concurrent: true
 });
 function createWatchCase(name, src, dist, temp) {
     creator.create(name, src, dist, temp);
 }
+function overrideOptions(index, context, options, tempDir, nativeWatcher) {
+    if (!options.mode)
+        options.mode = "development";
+    if (!options.context)
+        options.context = tempDir;
+    if (!options.entry)
+        options.entry = "./index.js";
+    if (!options.target)
+        options.target = "async-node";
+    if (!options.devtool)
+        options.devtool = false;
+    if (!options.output)
+        options.output = {};
+    if (!options.output.path)
+        options.output.path = context.getDist();
+    if (typeof options.output.pathinfo === "undefined")
+        options.output.pathinfo = false;
+    if (!options.output.filename)
+        options.output.filename = "bundle.js";
+    if (options.cache && options.cache.type === "filesystem") {
+        const cacheDirectory = node_path_1.default.join(tempDir, ".cache");
+        options.cache.cacheDirectory = cacheDirectory;
+        options.cache.name = `config-${index}`;
+    }
+    options.optimization ??= {};
+    options.experiments ??= {};
+    options.experiments.css ??= true;
+    if (nativeWatcher) {
+        options.experiments.nativeWatcher ??= true;
+    }
+    options.experiments.rspackFuture ??= {};
+    options.experiments.rspackFuture.bundlerInfo ??= {};
+    options.experiments.rspackFuture.bundlerInfo.force ??=
+        false;
+    // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
+    options.experiments.incremental ??= "safe";
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(index, context, options, stepName) {
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(index, options, stepName);
+    }
+    return "./bundle.js";
+}
+function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+    if (incremental) {
+        return {
+            experiments: {
+                incremental: "advance"
+            },
+            ignoreWarnings: ignoreNotFriendlyForIncrementalWarnings
+                ? [/is not friendly for incremental/]
+                : undefined
+        };
+    }
+    return {};
+}
+function getWatchRunnerKey(context, name, file) {
+    const watchContext = context.getValue("watchContext");
+    const stepName = watchContext?.step;
+    return `${name}-${stepName}`;
+}
+function cachedWatchStats(context, name) {
+    const compiler = context.getCompiler();
+    const watchContext = context.getValue("watchContext");
+    const stepName = watchContext?.step;
+    const statsGetter = (() => {
+        const cached = {};
+        return () => {
+            if (cached[stepName]) {
+                return cached[stepName];
+            }
+            cached[stepName] = compiler.getStats().toJson({
+                errorDetails: true
+            });
+            return cached[stepName];
+        };
+    })();
+    return statsGetter;
+}
+function createWatchRunner(context, name, file, env) {
+    const compiler = context.getCompiler();
+    const compilerOptions = compiler.getOptions();
+    const watchContext = context.getValue("watchContext");
+    const stepName = watchContext?.step;
+    if (!stepName) {
+        throw new Error("Can not get watch step name from context");
+    }
+    const state = watchContext?.watchState;
+    if (!state) {
+        throw new Error("Can not get watch state from context");
+    }
+    const isWeb = Array.isArray(compilerOptions)
+        ? compilerOptions.some(option => {
+            return option.target === "web" || option.target === "webworker";
+        })
+        : compilerOptions.target === "web" ||
+            compilerOptions.target === "webworker";
+    const testConfig = context.getTestConfig();
+    return new runner_1.WebRunner({
+        env,
+        stats: cachedWatchStats(context, name),
+        name: name,
+        runInNewContext: isWeb,
+        cachable: false,
+        testConfig: {
+            ...(testConfig || {}),
+            moduleScope: (ms, stats, options) => {
+                ms.STATE = state;
+                ms.WATCH_STEP = stepName;
+                if (typeof testConfig.moduleScope === "function") {
+                    return testConfig.moduleScope(ms, stats, options);
+                }
+                return ms;
+            }
+        },
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions,
+        location: testConfig.location || "https://test.cases/path/index.html"
+    });
+}

package/dist/compiler.d.ts

@@ -1,28 +1,28 @@
 import EventEmitter from "node:events";
-import { ECompilerType, type ITestCompilerManager, type TCompiler, type TCompilerFactories, type TCompilerOptions, type TCompilerStats } from "./type";
+import { Compiler, type RspackOptions, type Stats } from "@rspack/core";
+import type { ITestCompilerManager, ITestContext } from "./type";
 export declare enum ECompilerEvent {
     Build = "build",
     Option = "option",
     Create = "create",
     Close = "close"
 }
-export declare const COMPILER_FACTORIES: TCompilerFactories;
-export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
-    protected type: T;
-    protected factories: TCompilerFactories;
-    protected compilerOptions: TCompilerOptions<T>;
-    protected compilerInstance: TCompiler<T> | null;
-    protected compilerStats: TCompilerStats<T> | null;
+export declare class TestCompilerManager implements ITestCompilerManager {
+    protected context: ITestContext;
+    protected compilerOptions: RspackOptions;
+    protected compilerInstance: Compiler | null;
+    protected compilerStats: Stats | null;
     protected emitter: EventEmitter;
-    constructor(type: T, factories?: TCompilerFactories);
-    getOptions(): TCompilerOptions<T>;
-    setOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
-    mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
-    getCompiler(): TCompiler<T> | null;
-    createCompiler(): TCompiler<T>;
-    build(): Promise<TCompilerStats<T>>;
+    constructor(context: ITestContext);
+    getOptions(): RspackOptions;
+    setOptions(newOptions: RspackOptions): RspackOptions;
+    mergeOptions(newOptions: RspackOptions): RspackOptions;
+    getCompiler(): Compiler | null;
+    createCompiler(): Compiler;
+    createCompilerWithCallback(callback: (error: Error | null, stats: Stats | null) => void): Compiler;
+    build(): Promise<Stats>;
     watch(timeout?: number): void;
-    getStats(): TCompilerStats<T> | null;
+    getStats(): Stats | null;
     getEmitter(): EventEmitter<[never]>;
     close(): Promise<void>;
 }

package/dist/compiler.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestCompilerManager = exports.COMPILER_FACTORIES = exports.ECompilerEvent = void 0;
+exports.TestCompilerManager = exports.ECompilerEvent = void 0;
 const node_events_1 = __importDefault(require("node:events"));
+const core_1 = require("@rspack/core");
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const type_1 = require("./type");
+const debug_1 = require("./test/debug");
 var ECompilerEvent;
 (function (ECompilerEvent) {
     ECompilerEvent["Build"] = "build";
@@ -14,14 +15,9 @@ var ECompilerEvent;
     ECompilerEvent["Create"] = "create";
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
-exports.COMPILER_FACTORIES = {
-    [type_1.ECompilerType.Rspack]: ((options) => require("@rspack/core")(options)),
-    [type_1.ECompilerType.Webpack]: ((options) => require("webpack")(options))
-};
 class TestCompilerManager {
-    constructor(type, factories = exports.COMPILER_FACTORIES) {
-        this.type = type;
-        this.factories = factories;
+    constructor(context) {
+        this.context = context;
         this.compilerOptions = {};
         this.compilerInstance = null;
         this.compilerStats = null;
@@ -44,7 +40,58 @@ class TestCompilerManager {
         return this.compilerInstance;
     }
     createCompiler() {
-        this.compilerInstance = this.factories[this.type](this.compilerOptions);
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "no-callback"
+            });
+        }
+        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
+        return this.compilerInstance;
+    }
+    createCompilerWithCallback(callback) {
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions, callback);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "callback"
+            });
+        }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
@@ -53,11 +100,39 @@ class TestCompilerManager {
             throw new Error("Compiler should be created before build");
         return new Promise((resolve, reject) => {
             try {
+                const context = this.context;
+                if (__DEBUG__) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                        method: "run"
+                    });
+                }
                 this.compilerInstance.run((error, newStats) => {
                     this.emitter.emit(ECompilerEvent.Build, error, newStats);
-                    if (error)
+                    if (error) {
+                        if (__DEBUG__) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "fatal",
+                                errors: [error]
+                            });
+                        }
                         return reject(error);
+                    }
                     this.compilerStats = newStats;
+                    if (__DEBUG__) {
+                        if (newStats?.hasErrors()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "stats",
+                                errors: newStats.toJson({
+                                    errors: true
+                                }).errors || []
+                            });
+                        }
+                        if (newStats?.hasWarnings()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                                warnings: true
+                            }).warnings || []);
+                        }
+                    }
                     resolve(newStats);
                 });
             }
@@ -69,7 +144,8 @@ class TestCompilerManager {
     watch(timeout = 1000) {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before watch");
-        this.compilerInstance.watch({
+        const context = this.context;
+        const watchOptions = {
             // IMPORTANT:
             // This is a workaround for the issue that watchpack cannot detect the file change in time
             // so we set the poll to 300ms to make it more sensitive to the file change
@@ -78,11 +154,40 @@ class TestCompilerManager {
             // want to watch all files, which aligns with webpack's default behavior
             ignored: [],
             aggregateTimeout: timeout
-        }, (error, newStats) => {
+        };
+        if (__DEBUG__) {
+            context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                method: "watch",
+                options: watchOptions
+            });
+        }
+        this.compilerInstance.watch(watchOptions, (error, newStats) => {
             this.emitter.emit(ECompilerEvent.Build, error, newStats);
-            if (error)
-                return error;
+            if (__DEBUG__) {
+                if (error) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                        type: "fatal",
+                        errors: [error]
+                    });
+                    return error;
+                }
+            }
             if (newStats) {
+                if (__DEBUG__) {
+                    if (newStats.hasErrors()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                            type: "stats",
+                            errors: newStats.toJson({
+                                errors: true
+                            }).errors || []
+                        });
+                    }
+                    if (newStats.hasWarnings()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                            warnings: true
+                        }).warnings || []);
+                    }
+                }
                 this.compilerStats = newStats;
             }
             return newStats;

package/dist/helper/directory.d.ts

@@ -7,6 +7,6 @@ export declare function describeByWalk(testFile: string, createCase: (name: stri
     source?: string;
     dist?: string;
     absoluteDist?: boolean;
-    describe?: jest.Describe;
+    describe?: Describe;
     exclude?: RegExp[];
 }): void;

package/dist/helper/directory.js

@@ -31,7 +31,7 @@ function describeByWalk(testFile, createCase, options = {}) {
             .filter(folder => {
             if (options.exclude) {
                 if (options.exclude.some(exclude => {
-                    return exclude.test(folder);
+                    return exclude.test(node_path_1.default.join(dirname, folder).replace(/\\/g, "/"));
                 })) {
                     return false;
                 }
@@ -54,7 +54,7 @@ function describeByWalk(testFile, createCase, options = {}) {
                 describeDirectory(caseName, currentLevel - 1);
             }
             else {
-                const name = (0, _1.escapeSep)(node_path_1.default.join(testId, caseName).split(".").shift());
+                const name = (0, _1.escapeSep)(node_path_1.default.join(`${testId}Cases`, caseName).split(".").shift());
                 describeFn(name, () => {
                     const source = node_path_1.default.join(sourceBase, caseName);
                     let dist = "";

package/dist/helper/expect/error.js

@@ -19,7 +19,7 @@ const prettyFormatOptions = {
                 return `"${val
                     .replace(/\\/gm, "/")
                     .replace(/"/gm, '\\"')
-                    .replace(/\r?\n/gm, "\\n")}"`;
+                    .replace(/\r?\n/gm, "")}"`;
             }
         }
     ]

package/dist/helper/expect/placeholder.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePlaceholder = void 0;
-const node_path_1 = __importDefault(require("node:path"));
 const path_serializer_1 = require("path-serializer");
 // 1. escapeEOL \r\n -> \n
 // 2. replace <RSPACK_ROOT> etc
@@ -13,14 +9,18 @@ const placeholderSerializer = (0, path_serializer_1.createSnapshotSerializer)({
     root: __dirname.includes("node_modules")
         ? // Use `process.cwd()` when using outside Rspack
             process.cwd()
-        : node_path_1.default.resolve(__dirname, "../../../../../"),
+        : __ROOT_PATH__,
     replace: [
         {
-            match: node_path_1.default.resolve(__dirname, "../../../"),
+            match: __RSPACK_TEST_TOOLS_PATH__,
             mark: "test_tools_root"
         },
         {
-            match: node_path_1.default.resolve(__dirname, "../../../../rspack"),
+            match: __TEST_PATH__,
+            mark: "test_root"
+        },
+        {
+            match: __RSPACK_PATH__,
             mark: "rspack_root"
         },
         {