@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/case/index.js

@@ -1,36 +1,46 @@
 "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("./builtin"), exports);
-__exportStar(require("./cache"), exports);
-__exportStar(require("./compiler"), exports);
-__exportStar(require("./config"), exports);
-__exportStar(require("./defaults"), exports);
-__exportStar(require("./diagnostic"), exports);
-__exportStar(require("./diff"), exports);
-__exportStar(require("./error"), exports);
-__exportStar(require("./hash"), exports);
-__exportStar(require("./hook"), exports);
-__exportStar(require("./hot"), exports);
-__exportStar(require("./hot-step"), exports);
-__exportStar(require("./incremental"), exports);
-__exportStar(require("./native-watcher"), exports);
-__exportStar(require("./normal"), exports);
-__exportStar(require("./serial"), exports);
-__exportStar(require("./stats-api"), exports);
-__exportStar(require("./stats-output"), exports);
-__exportStar(require("./treeshaking"), exports);
-__exportStar(require("./watch"), exports);
+exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
+var builtin_1 = require("./builtin");
+Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "createCacheCase", { enumerable: true, get: function () { return cache_1.createCacheCase; } });
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "createCompilerCase", { enumerable: true, get: function () { return compiler_1.createCompilerCase; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "createConfigCase", { enumerable: true, get: function () { return config_1.createConfigCase; } });
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "createDefaultsCase", { enumerable: true, get: function () { return defaults_1.createDefaultsCase; } });
+Object.defineProperty(exports, "getRspackDefaultConfig", { enumerable: true, get: function () { return defaults_1.getRspackDefaultConfig; } });
+var diagnostic_1 = require("./diagnostic");
+Object.defineProperty(exports, "createDiagnosticCase", { enumerable: true, get: function () { return diagnostic_1.createDiagnosticCase; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "createDiffCase", { enumerable: true, get: function () { return diff_1.createDiffCase; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
+var hook_1 = require("./hook");
+Object.defineProperty(exports, "createHookCase", { enumerable: true, get: function () { return hook_1.createHookCase; } });
+var hot_1 = require("./hot");
+Object.defineProperty(exports, "createHotCase", { enumerable: true, get: function () { return hot_1.createHotCase; } });
+var hot_step_1 = require("./hot-step");
+Object.defineProperty(exports, "createHotStepCase", { enumerable: true, get: function () { return hot_step_1.createHotStepCase; } });
+var incremental_1 = require("./incremental");
+Object.defineProperty(exports, "createHotIncrementalCase", { enumerable: true, get: function () { return incremental_1.createHotIncrementalCase; } });
+Object.defineProperty(exports, "createWatchIncrementalCase", { enumerable: true, get: function () { return incremental_1.createWatchIncrementalCase; } });
+var native_watcher_1 = require("./native-watcher");
+Object.defineProperty(exports, "createNativeWatcher", { enumerable: true, get: function () { return native_watcher_1.createNativeWatcher; } });
+var normal_1 = require("./normal");
+Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
+Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
+var serial_1 = require("./serial");
+Object.defineProperty(exports, "createSerialCase", { enumerable: true, get: function () { return serial_1.createSerialCase; } });
+var stats_api_1 = require("./stats-api");
+Object.defineProperty(exports, "createStatsAPICase", { enumerable: true, get: function () { return stats_api_1.createStatsAPICase; } });
+var stats_output_1 = require("./stats-output");
+Object.defineProperty(exports, "createStatsOutputCase", { enumerable: true, get: function () { return stats_output_1.createStatsOutputCase; } });
+var treeshaking_1 = require("./treeshaking");
+Object.defineProperty(exports, "createTreeShakingCase", { enumerable: true, get: function () { return treeshaking_1.createTreeShakingCase; } });
+var watch_1 = require("./watch");
+Object.defineProperty(exports, "createWatchCase", { enumerable: true, get: function () { return watch_1.createWatchCase; } });

package/dist/case/normal.js

@@ -5,24 +5,171 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
 exports.createHotNormalCase = createHotNormalCase;
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@rspack/core");
-const normal_1 = require("../processor/normal");
+const processor_1 = require("../processor");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
+function findBundle(context, options) {
+    const testConfig = context.getTestConfig();
+    if (typeof testConfig.findBundle === "function") {
+        return testConfig.findBundle(0, options);
+    }
+    const filename = options.output?.filename;
+    return typeof filename === "string" ? filename : undefined;
+}
+function defaultOptions(context, compilerOptions) {
+    let testConfig = {};
+    const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
+    if (node_fs_1.default.existsSync(testConfigPath)) {
+        testConfig = require(testConfigPath);
+    }
+    const TerserPlugin = require("terser-webpack-plugin");
+    const terserForTesting = new TerserPlugin({
+        parallel: false
+    });
+    return {
+        amd: {},
+        context: NORMAL_CASES_ROOT,
+        entry: `./${node_path_1.default.relative(NORMAL_CASES_ROOT, context.getSource())}/`,
+        target: compilerOptions?.target || "async-node",
+        devtool: compilerOptions?.devtool,
+        mode: compilerOptions?.mode || "none",
+        optimization: compilerOptions?.mode
+            ? {
+                // emitOnErrors: true,
+                minimizer: [terserForTesting],
+                ...testConfig.optimization
+            }
+            : {
+                removeAvailableModules: true,
+                removeEmptyChunks: true,
+                mergeDuplicateChunks: true,
+                // CHANGE: rspack does not support `flagIncludedChunks` yet.
+                // flagIncludedChunks: true,
+                sideEffects: true,
+                providedExports: true,
+                usedExports: true,
+                mangleExports: true,
+                // CHANGE: rspack does not support `emitOnErrors` yet.
+                // emitOnErrors: true,
+                concatenateModules: !!testConfig?.optimization?.concatenateModules,
+                innerGraph: true,
+                // CHANGE: size is not supported yet
+                // moduleIds: "size",
+                // chunkIds: "size",
+                moduleIds: "named",
+                chunkIds: "named",
+                minimizer: [terserForTesting],
+                ...compilerOptions?.optimization
+            },
+        // CHANGE: rspack does not support `performance` yet.
+        // performance: {
+        // 	hints: false
+        // },
+        node: {
+            __dirname: "mock",
+            __filename: "mock"
+        },
+        cache: compilerOptions?.cache && {
+            // cacheDirectory,
+            ...compilerOptions.cache
+        },
+        output: {
+            pathinfo: "verbose",
+            path: context.getDist(),
+            filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
+        },
+        resolve: {
+            modules: ["web_modules", "node_modules"],
+            mainFields: ["webpack", "browser", "web", "browserify", "main"],
+            aliasFields: ["browser"],
+            extensions: [".webpack.js", ".web.js", ".js", ".json"]
+        },
+        resolveLoader: {
+            modules: ["web_loaders", "web_modules", "node_loaders", "node_modules"],
+            mainFields: ["webpackLoader", "webLoader", "loader", "main"],
+            extensions: [".webpack-loader.js", ".web-loader.js", ".loader.js", ".js"]
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.coffee$/,
+                    loader: "coffee-loader"
+                },
+                {
+                    test: /\.pug/,
+                    loader: "@webdiscus/pug-loader"
+                },
+                {
+                    test: /\.wat$/i,
+                    loader: "wast-loader",
+                    type: "webassembly/async"
+                }
+            ]
+        },
+        plugins: (compilerOptions?.plugins || [])
+            .concat(testConfig.plugins || [])
+            .concat(function () {
+            this.hooks.compilation.tap("TestCasesTest", compilation => {
+                const hooks = [
+                // CHANGE: the following hooks are not supported yet, so comment it out
+                // "optimize",
+                // "optimizeModules",
+                // "optimizeChunks",
+                // "afterOptimizeTree",
+                // "afterOptimizeAssets"
+                ];
+                for (const hook of hooks) {
+                    compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
+                }
+            });
+        }),
+        experiments: {
+            css: false,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            asyncWebAssembly: true,
+            topLevelAwait: true,
+            inlineConst: true,
+            lazyBarrel: true,
+            // CHANGE: rspack does not support `backCompat` yet.
+            // backCompat: false,
+            // CHANGE: Rspack enables `css` by default.
+            // Turning off here to fallback to webpack's default css processing logic.
+            ...(compilerOptions?.module ? { outputModule: true } : {})
+        }
+        // infrastructureLogging: compilerOptions?.cache && {
+        //   debug: true,
+        //   console: createLogger(infraStructureLog)
+        // }
+    };
+}
+function overrideOptions(context, options) {
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
 const createCaseOptions = (hot) => {
     return {
         clean: true,
         describe: false,
         steps: ({ name }) => [
-            new normal_1.NormalProcessor({
+            new processor_1.BasicProcessor({
                 name,
-                root: NORMAL_CASES_ROOT,
-                compilerOptions: {
+                findBundle,
+                defaultOptions: context => defaultOptions(context, {
                     plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
-                },
+                }),
+                overrideOptions,
                 runable: true,
                 compilerType: type_1.ECompilerType.Rspack
             })

package/dist/case/serial.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSerialCase = createSerialCase;
-const config_1 = require("../processor/config");
+const processor_1 = require("../processor");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const config_1 = require("./config");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -20,11 +21,14 @@ const creator = new creator_1.BasicCaseCreator({
         };
     },
     steps: ({ name }) => [
-        new config_1.ConfigProcessor({
+        new processor_1.MultiTaskProcessor({
             name,
             runable: true,
             compilerType: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"]
+            configFiles: ["rspack.config.js", "webpack.config.js"],
+            defaultOptions: config_1.defaultOptions,
+            overrideOptions: config_1.overrideOptions,
+            findBundle: config_1.findBundle
         })
     ],
     runner: runner_1.MultipleRunnerFactory

package/dist/case/stats-api.d.ts

@@ -1,6 +1 @@
-import { type IStatsAPIProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TStatsAPICaseConfig = Omit<IStatsAPIProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
-    description: string;
-};
 export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -1,10 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
+const memfs_1 = require("memfs");
 const processor_1 = require("../processor");
 const simple_1 = require("../test/simple");
 const type_1 = require("../type");
 let addedSerializer = false;
+function options(context, custom) {
+    const res = (custom?.(context) ||
+        {});
+    res.experiments ??= {};
+    res.experiments.css ??= true;
+    res.experiments.rspackFuture ??= {};
+    res.experiments.rspackFuture.bundlerInfo ??= {};
+    res.experiments.rspackFuture.bundlerInfo.force ??= false;
+    if (!global.printLogger) {
+        res.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    return res;
+}
+async function compiler(context, compiler, custom) {
+    if (custom) {
+        await custom(context, compiler);
+    }
+    if (compiler) {
+        compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+    }
+}
+async function check(env, context, compiler, stats, custom) {
+    env.expect(typeof stats).toBe("object");
+    await custom?.(stats, compiler);
+}
 function createStatsAPICase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
@@ -12,10 +40,13 @@ function createStatsAPICase(name, src, dist, testConfig) {
     const caseConfig = require(testConfig);
     const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
     it(caseConfig.description, async () => {
-        await runner(name, new processor_1.StatsAPIProcessor({
+        await runner(name, new processor_1.SimpleTaskProcessor({
             name: name,
             compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
+            options: context => options(context, caseConfig.options),
+            compiler: (context, c) => compiler(context, c, caseConfig.compiler),
+            build: caseConfig.build,
+            check: (env, context, compiler, stats) => check(env, context, compiler, stats, caseConfig.check)
         }));
     });
 }

package/dist/case/stats-output.js

@@ -1,21 +1,211 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsOutputCase = createStatsOutputCase;
-const stats_1 = require("../processor/stats");
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const placeholder_1 = require("../helper/expect/placeholder");
+const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
+const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const REG_ERROR_CASE = /error$/;
+function defaultOptions(index, context) {
+    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
+        return {
+            experiments: {
+                css: true,
+                rspackFuture: {
+                    bundlerInfo: {
+                        force: false
+                    }
+                }
+            }
+        };
+    }
+    return {
+        context: context.getSource(),
+        mode: "development",
+        entry: "./index.js",
+        output: {
+            filename: "bundle.js",
+            path: context.getDist()
+        },
+        optimization: {
+            minimize: false
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+}
+function overrideOptions(index, context, options) {
+    if (!options.context)
+        options.context = context.getSource();
+    if (!options.output)
+        options.output = options.output || {};
+    if (!options.output.path)
+        options.output.path = context.getDist();
+    if (!options.plugins)
+        options.plugins = [];
+    if (!options.optimization)
+        options.optimization = {};
+    if (options.optimization.minimize === undefined) {
+        options.optimization.minimize = false;
+    }
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+class RspackStats {
+    constructor(value) {
+        this.value = value;
+    }
+}
+function createStatsProcessor(name) {
+    const writeStatsOuptut = false;
+    const snapshotName = "stats.txt";
+    const processor = new processor_1.MultiTaskProcessor({
+        name,
+        compilerType: type_1.ECompilerType.Rspack,
+        configFiles: ["rspack.config.js", "webpack.config.js"],
+        runable: false,
+        defaultOptions: (index, context) => defaultOptions(index, context),
+        overrideOptions: (index, context, options) => overrideOptions(index, context, options),
+        async check(env, context, compiler, stats) {
+            if (!stats || !compiler)
+                return;
+            for (const compilation of []
+                .concat(stats.stats || stats)
+                .map((s) => s.compilation)) {
+                compilation.logging.delete("webpack.Compilation.ModuleProfile");
+            }
+            if (REG_ERROR_CASE.test(name)) {
+                env.expect(stats.hasErrors()).toBe(true);
+            }
+            else if (stats.hasErrors()) {
+                throw new Error(stats.toString({
+                    all: false,
+                    errors: true
+                    // errorStack: true,
+                    // errorDetails: true
+                }));
+            }
+            else if (writeStatsOuptut) {
+                fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                    preset: "verbose",
+                    // context: context.getSource(),
+                    colors: false
+                }), "utf-8");
+            }
+            let toStringOptions = {
+                context: context.getSource(),
+                colors: false
+            };
+            let hasColorSetting = false;
+            if (typeof compiler.options.stats !== "undefined") {
+                toStringOptions = compiler.options.stats;
+                if (toStringOptions === null || typeof toStringOptions !== "object")
+                    toStringOptions = { preset: toStringOptions };
+                if (!toStringOptions.context)
+                    toStringOptions.context = context.getSource();
+                hasColorSetting = typeof toStringOptions.colors !== "undefined";
+            }
+            if (Array.isArray(compiler.options) && !toStringOptions.children) {
+                toStringOptions.children = compiler.options.map(o => o.stats);
+            }
+            // mock timestamps
+            for (const { compilation: s } of [].concat(stats.stats || stats)) {
+                env.expect(s.startTime).toBeGreaterThan(0);
+                env.expect(s.endTime).toBeGreaterThan(0);
+                s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
+                s.startTime = s.endTime - 1234;
+            }
+            let actual = stats.toString(toStringOptions);
+            env.expect(typeof actual).toBe("string");
+            actual = stderr.toString() + actual;
+            if (!hasColorSetting) {
+                actual = actual
+                    .replace(/\u001b\[[0-9;]*m/g, "")
+                    // CHANGE: The time unit display in Rspack is second
+                    .replace(/[.0-9]+(\s?s)/g, "X$1")
+                    // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
+                    .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
+            }
+            const snapshotPath = node_path_1.default.isAbsolute(snapshotName)
+                ? snapshotName
+                : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshotName}`);
+            env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
+            const testConfig = context.getTestConfig();
+            if (typeof testConfig?.validate === "function") {
+                testConfig.validate(stats, stderr.toString());
+            }
+        },
+        async compiler(context, compiler) {
+            const compilers = compiler.compilers
+                ? compiler.compilers
+                : [compiler];
+            for (const compiler of compilers) {
+                if (!compiler.inputFileSystem) {
+                    continue;
+                }
+                const ifs = compiler.inputFileSystem;
+                const inputFileSystem = Object.create(ifs);
+                compiler.inputFileSystem = inputFileSystem;
+                inputFileSystem.readFile = (...args) => {
+                    const callback = args.pop();
+                    ifs.readFile.apply(ifs, args.concat([
+                        (err, result) => {
+                            if (err)
+                                return callback(err);
+                            if (!/\.(js|json|txt)$/.test(args[0]))
+                                return callback(null, result);
+                            callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
+                        }
+                    ]));
+                };
+                // CHANGE: The checkConstraints() function is currently not implemented in rspack
+                // compiler.hooks.compilation.tap("StatsTestCasesTest", compilation => {
+                // 	[
+                // 		"optimize",
+                // 		"optimizeModules",
+                // 		"optimizeChunks",
+                // 		"afterOptimizeTree",
+                // 		"afterOptimizeAssets",
+                // 		"beforeHash"
+                // 	].forEach(hook => {
+                // 		compilation.hooks[hook].tap("TestCasesTest", () =>
+                // 			compilation.checkConstraints()
+                // 		);
+                // 	});
+                // });
+            }
+        }
+    });
+    let stderr;
+    processor.before = async (context) => {
+        stderr = (0, captureStdio_1.default)(process.stderr, true);
+    };
+    processor.after = async (context) => {
+        stderr.restore();
+    };
+    return processor;
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [
-        new stats_1.StatsProcessor({
-            name,
-            snapshotName: "stats.txt",
-            writeStatsOuptut: false,
-            compilerType: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"]
-        })
-    ],
+    steps: ({ name }) => [createStatsProcessor(name)],
     description: () => "should print correct stats for"
 });
 function createStatsOutputCase(name, src, dist) {

package/dist/case/treeshaking.js

@@ -1,9 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTreeShakingCase = createTreeShakingCase;
-const treeshaking_1 = require("../processor/treeshaking");
+const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const builtin_1 = require("./builtin");
+function overrideOptions(context, options) {
+    options.target = options.target || ["web", "es2022"];
+    options.optimization ??= {};
+    options.optimization.providedExports = true;
+    options.optimization.innerGraph = true;
+    options.optimization.usedExports = true;
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -11,10 +24,13 @@ const creator = new creator_1.BasicCaseCreator({
         return `${name} with newTreeshaking should match snapshot`;
     },
     steps: ({ name }) => [
-        new treeshaking_1.TreeShakingProcessor({
+        new processor_1.SnapshotProcessor({
             name,
             snapshot: "treeshaking.snap.txt",
-            compilerType: type_1.ECompilerType.Rspack
+            compilerType: type_1.ECompilerType.Rspack,
+            runable: false,
+            defaultOptions: builtin_1.defaultOptions,
+            overrideOptions
         })
     ]
 });

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

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

package/dist/processor/basic.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompilerOptions } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerMultiStats, TCompilerOptions, TCompilerStats } from "../type";
 export interface IBasicProcessorOptions<T extends ECompilerType> {
     defaultOptions?: (context: ITestContext) => TCompilerOptions<T>;
     configFiles?: string[];
@@ -7,6 +7,9 @@ export interface IBasicProcessorOptions<T extends ECompilerType> {
     compilerType: T;
     runable: boolean;
     name: string;
+    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    check?: (env: ITestEnv, context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T> | TCompilerMultiStats<T> | null) => Promise<void>;
 }
 export declare class BasicProcessor<T extends ECompilerType> implements ITestProcessor {
     protected _options: IBasicProcessorOptions<T>;