@rspack-debug/test-tools 1.4.11 → 1.6.2

package/dist/case/incremental.js

@@ -7,12 +7,13 @@ exports.createHotIncrementalCase = createHotIncrementalCase;
 exports.createWatchIncrementalCase = createWatchIncrementalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const hot_incremental_1 = require("../processor/hot-incremental");
-const watch_1 = require("../processor/watch");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const hot_1 = require("./hot");
+const watch_1 = require("./watch");
 const hotCreators = new Map();
+function createHotIncrementalProcessor(name, src, temp, target, webpackCases) {
+    return (0, hot_1.createHotProcessor)(name, src, temp, target, true);
+}
 function getHotCreator(target, webpackCases) {
     const key = JSON.stringify({ target, webpackCases });
     if (!hotCreators.has(key)) {
@@ -20,24 +21,21 @@ function getHotCreator(target, webpackCases) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                new hot_incremental_1.HotIncrementalProcessor({
-                    name,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"],
-                    webpackCases
-                })
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target, webpackCases)
             ],
-            runner: runner_1.HotRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: hot_1.createHotRunner
+            },
             concurrent: true
         }));
     }
     return hotCreators.get(key);
 }
-function createHotIncrementalCase(name, src, dist, target, webpackCases) {
+function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
     const creator = getHotCreator(target, webpackCases);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
 const watchCreators = new Map();
 function getWatchCreator(options) {
@@ -45,7 +43,10 @@ function getWatchCreator(options) {
     if (!watchCreators.has(key)) {
         watchCreators.set(key, new creator_1.BasicCaseCreator({
             clean: true,
-            runner: runner_1.WatchRunnerFactory,
+            runner: {
+                key: watch_1.getWatchRunnerKey,
+                runner: watch_1.createWatchRunner
+            },
             description: (name, index) => {
                 return index === 0
                     ? `${name} should compile`
@@ -57,37 +58,15 @@ function getWatchCreator(options) {
                 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"],
-                        defaultOptions(index, context) {
-                            return {
-                                experiments: {
-                                    incremental: "advance"
-                                },
-                                ignoreWarnings: options.ignoreNotFriendlyForIncrementalWarnings
-                                    ? [/is not friendly for incremental/]
-                                    : undefined
-                            };
-                        }
-                    }, 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));
+                    ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
+                        incremental: true
+                    })
+                    : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
+                        incremental: true
+                    }));
             },
             concurrent: true
         }));

package/dist/case/index.d.ts

@@ -1,20 +1,31 @@
-export * from "./builtin";
-export * from "./cache";
-export * from "./compiler";
-export * from "./config";
-export * from "./defaults";
-export * from "./diagnostic";
-export * from "./diff";
-export * from "./error";
-export * from "./hash";
-export * from "./hook";
-export * from "./hot";
-export * from "./hot-step";
-export * from "./incremental";
-export * from "./nativeWatcher";
-export * from "./normal";
-export * from "./serial";
-export * from "./stats-api";
-export * from "./stats-output";
-export * from "./treeshaking";
-export * from "./watch";
+export { createBuiltinCase } from "./builtin";
+export { createCacheCase } from "./cache";
+export type { TCompilerCaseConfig } from "./compiler";
+export { createCompilerCase } from "./compiler";
+export type { TConfigCaseConfig } from "./config";
+export { createConfigCase } from "./config";
+export type { TDefaultsCaseConfig } from "./defaults";
+export { createDefaultsCase, getRspackDefaultConfig } from "./defaults";
+export type { TDiagnosticOptions } from "./diagnostic";
+export { createDiagnosticCase } from "./diagnostic";
+export type { TErrorCaseConfig } from "./error";
+export { createErrorCase } from "./error";
+export { createEsmOutputCase } from "./esm-output";
+export { createExampleCase } from "./example";
+export type { THashCaseConfig } from "./hash";
+export { createHashCase } from "./hash";
+export type { THookCaseConfig } from "./hook";
+export { createHookCase } from "./hook";
+export { createHotCase } from "./hot";
+export { createHotStepCase } from "./hot-step";
+export { createHotIncrementalCase, createWatchIncrementalCase } from "./incremental";
+export type { TMultiCompilerCaseConfig } from "./multi-compiler";
+export { createMultiCompilerCase } from "./multi-compiler";
+export { createNativeWatcher } from "./native-watcher";
+export { createDevNormalCase, createHotNormalCase, createNormalCase, createProdNormalCase } from "./normal";
+export { createSerialCase } from "./serial";
+export type { TStatsAPICaseConfig } from "./stats-api";
+export { createStatsAPICase } from "./stats-api";
+export { createStatsOutputCase } from "./stats-output";
+export { createTreeShakingCase } from "./treeshaking";
+export { createWatchCase } from "./watch";

package/dist/case/index.js

@@ -1,36 +1,52 @@
 "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("./nativeWatcher"), 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.createProdNormalCase = exports.createNormalCase = exports.createHotNormalCase = exports.createDevNormalCase = exports.createNativeWatcher = exports.createMultiCompilerCase = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createExampleCase = exports.createEsmOutputCase = exports.createErrorCase = 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 error_1 = require("./error");
+Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
+var esm_output_1 = require("./esm-output");
+Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
+var example_1 = require("./example");
+Object.defineProperty(exports, "createExampleCase", { enumerable: true, get: function () { return example_1.createExampleCase; } });
+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 multi_compiler_1 = require("./multi-compiler");
+Object.defineProperty(exports, "createMultiCompilerCase", { enumerable: true, get: function () { return multi_compiler_1.createMultiCompilerCase; } });
+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, "createDevNormalCase", { enumerable: true, get: function () { return normal_1.createDevNormalCase; } });
+Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
+Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
+Object.defineProperty(exports, "createProdNormalCase", { enumerable: true, get: function () { return normal_1.createProdNormalCase; } });
+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/multi-compiler.d.ts

@@ -0,0 +1,19 @@
+import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+export type TMultiCompilerCaseConfig = {
+    description: string;
+    error?: boolean;
+    skip?: boolean;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    check?: ({ context, stats, files, compiler, compilation }: {
+        context: ITestContext;
+        stats?: StatsCompilation;
+        files?: Record<string, string>;
+        compiler: Compiler;
+        compilation?: Compilation;
+    }) => Promise<void>;
+    compilerCallback?: (error: Error | null, stats: Stats | null) => void;
+};

package/dist/case/multi-compiler.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiCompilerCase = createMultiCompilerCase;
+const node_path_1 = __importDefault(require("node:path"));
+const memfs_1 = require("memfs");
+const creator_1 = require("../test/creator");
+function createMultiCompilerProcessor(name, caseConfig) {
+    return {
+        config: async (context) => {
+            const compiler = context.getCompiler();
+            const options = Object.assign([
+                {
+                    name: "a",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./a.js"
+                },
+                {
+                    name: "b",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./b.js"
+                }
+            ], caseConfig.options?.(context) || {});
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            const compiler = context.getCompiler();
+            if (caseConfig.compilerCallback) {
+                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            }
+            else {
+                compiler.createCompiler();
+            }
+            const c = compiler.getCompiler();
+            c.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+            c.watchFileSystem = {
+                watch() {
+                    // watch should return a watcher instance
+                    // watcher instance should have close, pause and getInfo methods
+                    return {
+                        close: () => { },
+                        pause: () => { },
+                        getInfo: () => {
+                            return {
+                                changes: new Set(),
+                                removals: new Set(),
+                                fileTimeInfoEntries: new Map(),
+                                directoryTimeInfoEntries: new Map()
+                            };
+                        }
+                    };
+                }
+            };
+            await caseConfig.compiler?.(context, c);
+        },
+        build: async (context) => {
+            const compiler = context.getCompiler();
+            if (typeof caseConfig.build === "function") {
+                await caseConfig.build?.(context, compiler.getCompiler());
+            }
+            else {
+                await compiler.build();
+            }
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => { }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [
+            createMultiCompilerProcessor(name, caseConfig)
+        ];
+    },
+    concurrent: false
+});
+function createMultiCompilerCase(name, src, dist, testConfig) {
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
+    for (let i = 0; i < caseConfigList.length; i++) {
+        const caseConfig = caseConfigList[i];
+        if (caseConfig.skip) {
+            it.skip(`${name}[${i}]`, () => { });
+            continue;
+        }
+        creator.create(`${name}[${i}]`, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
+        });
+    }
+}

package/dist/case/{nativeWatcher.js → native-watcher.js}

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNativeWatcher = createNativeWatcher;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const watch_1 = require("../processor/watch");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const watch_1 = require("./watch");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    runner: runner_1.WatchRunnerFactory,
+    runner: {
+        key: watch_1.getWatchRunnerKey,
+        runner: watch_1.createWatchRunner
+    },
     description: (name, index) => {
         return index === 0
             ? `${name} should compile`
@@ -24,28 +25,15 @@ 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"],
+            ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
+                nativeWatcher: true
+            })
+            : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
                 nativeWatcher: true
-            }, 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));
+            }));
     },
     concurrent: true
 });

package/dist/case/normal.d.ts

@@ -1 +1,4 @@
 export declare function createNormalCase(name: string, src: string, dist: string): void;
+export declare function createHotNormalCase(name: string, src: string, dist: string): void;
+export declare function createDevNormalCase(name: string, src: string, dist: string): void;
+export declare function createProdNormalCase(name: string, src: string, dist: string): void;

package/dist/case/normal.js

@@ -4,26 +4,210 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
+exports.createHotNormalCase = createHotNormalCase;
+exports.createDevNormalCase = createDevNormalCase;
+exports.createProdNormalCase = createProdNormalCase;
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const normal_1 = require("../processor/normal");
-const runner_1 = require("../runner");
+const core_1 = require("@rspack/core");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [
-        new normal_1.NormalProcessor({
-            name,
-            root: node_path_1.default.resolve(__dirname, "../../tests/normalCases"),
-            compilerOptions: {}, // do not used in rspack
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack
-        })
-    ],
-    runner: runner_1.NormalRunnerFactory,
-    concurrent: true
-});
+const common_1 = require("./common");
+const runner_1 = require("./runner");
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, "normalCases");
+const createCaseOptions = (hot, mode) => {
+    return {
+        clean: true,
+        describe: false,
+        steps: ({ name }) => [
+            {
+                config: async (context) => {
+                    const compiler = context.getCompiler();
+                    let options = defaultOptions(context, {
+                        plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
+                    }, mode);
+                    options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
+                    overrideOptions(context, options);
+                    compiler.setOptions(options);
+                },
+                compiler: async (context) => {
+                    await (0, common_1.compiler)(context, name);
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    await (0, common_1.run)(env, context, name, findBundle);
+                },
+                check: async (env, context) => {
+                    await (0, common_1.check)(env, context, name);
+                },
+                after: async (context) => {
+                    await (0, common_1.afterExecute)(context, name);
+                }
+            }
+        ],
+        runner: {
+            key: (context, name, file) => name,
+            runner: runner_1.createRunner
+        },
+        concurrent: true
+    };
+};
+const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
 function createNormalCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
+function createHotNormalCase(name, src, dist) {
+    hotCreator.create(name, src, dist);
+}
+const devCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "development"));
+function createDevNormalCase(name, src, dist) {
+    devCreator.create(name, src, dist);
+}
+const prodCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "production"));
+function createProdNormalCase(name, src, dist) {
+    prodCreator.create(name, src, dist);
+}
+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, mode) {
+    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: mode === "development" ? false : compilerOptions?.devtool,
+        mode: compilerOptions?.mode || mode || "none",
+        optimization: compilerOptions?.mode
+            ? {
+                emitOnErrors: true,
+                minimizer: [terserForTesting],
+                minimize: false,
+                ...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",
+                minimize: false,
+                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,
+            // 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 } : {})
+        }
+    };
+}
+function overrideOptions(context, options) {
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}