@rspack/test-tools 1.7.0-beta.1 → 1.7.0

package/dist/case/builtin.d.ts

@@ -1,4 +1,4 @@
-import type { RspackOptions } from "@rspack/core";
-import type { ITestContext } from "../type";
+import type { RspackOptions } from '@rspack/core';
+import type { ITestContext } from '../type';
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
 export declare function defaultOptions(context: ITestContext): RspackOptions;

package/dist/case/builtin.js

@@ -36,12 +36,12 @@ const creator = new creator_1.BasicCaseCreator({
                     // no need to run, just check snapshot
                 },
                 check: async (env, context) => {
-                    await (0, common_1.checkSnapshot)(env, context, name, "output.snap.txt", filter);
-                }
-            }
+                    await (0, common_1.checkSnapshot)(env, context, name, 'output.snap.txt', filter);
+                },
+            },
         ];
     },
-    concurrent: true
+    concurrent: true,
 });
 function createBuiltinCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -50,113 +50,113 @@ function defaultOptions(context) {
     let defaultOptions = {
         entry: {
             main: {
-                import: "./index"
-            }
+                import: './index',
+            },
         },
         output: {
-            publicPath: "/",
+            publicPath: '/',
             path: context.getDist(),
-            filename: "[name].js",
-            chunkFilename: "[name].js",
-            chunkFormat: "array-push",
-            cssFilename: "[name].css",
-            cssChunkFilename: "[name].css",
-            assetModuleFilename: "[hash][ext][query]",
-            sourceMapFilename: "[file].map",
-            chunkLoadingGlobal: "webpackChunkwebpack",
-            chunkLoading: "jsonp",
-            uniqueName: "__rspack_test__",
-            enabledLibraryTypes: ["system"],
+            filename: '[name].js',
+            chunkFilename: '[name].js',
+            chunkFormat: 'array-push',
+            cssFilename: '[name].css',
+            cssChunkFilename: '[name].css',
+            assetModuleFilename: '[hash][ext][query]',
+            sourceMapFilename: '[file].map',
+            chunkLoadingGlobal: 'webpackChunkwebpack',
+            chunkLoading: 'jsonp',
+            uniqueName: '__rspack_test__',
+            enabledLibraryTypes: ['system'],
             strictModuleErrorHandling: false,
             iife: true,
             module: false,
             asyncChunks: true,
             scriptType: false,
-            globalObject: "self",
-            importFunctionName: "import",
-            wasmLoading: "fetch",
-            webassemblyModuleFilename: "[hash].module.wasm",
-            workerChunkLoading: "import-scripts",
-            workerWasmLoading: "fetch"
+            globalObject: 'self',
+            importFunctionName: 'import',
+            wasmLoading: 'fetch',
+            webassemblyModuleFilename: '[hash].module.wasm',
+            workerChunkLoading: 'import-scripts',
+            workerWasmLoading: 'fetch',
         },
         module: {
             rules: [
                 {
                     test: /\.json$/,
-                    type: "json"
+                    type: 'json',
                 },
                 {
                     test: /\.mjs$/,
-                    type: "javascript/esm"
+                    type: 'javascript/esm',
                 },
                 {
                     test: /\.cjs$/,
-                    type: "javascript/dynamic"
+                    type: 'javascript/dynamic',
                 },
                 {
                     test: /\.js$/,
-                    type: "javascript/auto"
+                    type: 'javascript/auto',
                 },
                 {
                     test: /\.css$/,
-                    type: "css"
+                    type: 'css',
                 },
                 {
                     test: /\.wasm$/,
-                    type: "webassembly/async"
-                }
-            ]
+                    type: 'webassembly/async',
+                },
+            ],
         },
         node: {
-            __dirname: "mock",
-            __filename: "mock",
-            global: "warn"
+            __dirname: 'mock',
+            __filename: 'mock',
+            global: 'warn',
         },
         optimization: {
             runtimeChunk: {
-                name: "runtime"
+                name: 'runtime',
             },
             minimize: false,
             removeAvailableModules: true,
             removeEmptyChunks: true,
-            moduleIds: "named",
-            chunkIds: "named",
+            moduleIds: 'named',
+            chunkIds: 'named',
             sideEffects: false,
             mangleExports: false,
             inlineExports: false,
             usedExports: false,
             concatenateModules: false,
-            nodeEnv: false
+            nodeEnv: false,
         },
         resolve: {
             extensions: [
-                ".js",
-                ".jsx",
-                ".ts",
-                ".tsx",
-                ".json",
-                ".d.ts",
-                ".css",
-                ".wasm"
-            ]
+                '.js',
+                '.jsx',
+                '.ts',
+                '.tsx',
+                '.json',
+                '.d.ts',
+                '.css',
+                '.wasm',
+            ],
         },
         resolveLoader: {
-            extensions: [".js"]
+            extensions: ['.js'],
         },
         experiments: {
             css: true,
             futureDefaults: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
+                    force: false,
+                },
+            },
         },
         devtool: false,
         context: context.getSource(),
-        plugins: []
+        plugins: [],
     };
-    const testConfigFile = context.getSource("rspack.config.js");
+    const testConfigFile = context.getSource('rspack.config.js');
     if (fs_extra_1.default.existsSync(testConfigFile)) {
         const caseOptions = require(testConfigFile);
         if (caseOptions.entry) {
@@ -166,13 +166,13 @@ function defaultOptions(context) {
     }
     if (!global.printLogger) {
         defaultOptions.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
     return defaultOptions;
 }
 const FILTERS = {
-    "plugin-css": (file) => file.endsWith(".css"),
-    "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
-    "plugin-html": (file) => file.endsWith(".html")
+    'plugin-css': (file) => file.endsWith('.css'),
+    'plugin-css-modules': (file) => file.endsWith('.css') || ((0, helper_1.isJavaScript)(file) && !file.includes('runtime')),
+    'plugin-html': (file) => file.endsWith('.html'),
 };

package/dist/case/cache.d.ts

@@ -1,2 +1,2 @@
-import { type RspackOptions } from "@rspack/core";
-export declare function createCacheCase(name: string, src: string, dist: string, target: RspackOptions["target"], temp: string): void;
+import { type RspackOptions } from '@rspack/core';
+export declare function createCacheCase(name: string, src: string, dist: string, target: RspackOptions['target'], temp: string): void;

package/dist/case/cache.js

@@ -18,7 +18,7 @@ function createCacheProcessor(name, src, temp, target) {
     return {
         before: async (context) => {
             await updatePlugin.initialize();
-            context.setValue("hotUpdateContext", updatePlugin);
+            context.setValue('hotUpdateContext', updatePlugin);
         },
         config: async (context) => {
             const compiler = context.getCompiler();
@@ -32,7 +32,7 @@ function createCacheProcessor(name, src, temp, target) {
             await (0, common_1.build)(context, name);
         },
         run: async (env, context) => {
-            await (0, common_1.run)(env, context, name, context => findBundle(name, target, context));
+            await (0, common_1.run)(env, context, name, (context) => findBundle(name, target, context));
         },
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
@@ -46,7 +46,7 @@ function createCacheProcessor(name, src, temp, target) {
             if (updateIndex + 1 !== totalUpdates) {
                 throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
             }
-        }
+        },
     };
 }
 function getCreator(target) {
@@ -56,13 +56,13 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, src, target, temp }) => [
-                createCacheProcessor(name, src, temp, target)
+                createCacheProcessor(name, src, temp, target),
             ],
             runner: {
                 key: (context, name, file) => name,
-                runner: createRunner
+                runner: createRunner,
             },
-            concurrent: true
+            concurrent: true,
         }));
     }
     return creators.get(target);
@@ -75,51 +75,51 @@ const creators = new Map();
 async function generateOptions(context, temp, target, updatePlugin) {
     let options = {
         context: temp,
-        mode: "production",
+        mode: 'production',
         cache: true,
         devtool: false,
         output: {
             path: context.getDist(),
-            filename: "bundle.js",
-            chunkFilename: "[name].chunk.[fullhash].js",
-            publicPath: "https://test.cases/path/",
-            library: { type: "commonjs2" }
+            filename: 'bundle.js',
+            chunkFilename: '[name].chunk.[fullhash].js',
+            publicPath: 'https://test.cases/path/',
+            library: { type: 'commonjs2' },
         },
         optimization: {
-            moduleIds: "named",
-            emitOnErrors: true
+            moduleIds: 'named',
+            emitOnErrors: true,
         },
         target,
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
     options.plugins ??= [];
     options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
-    options = await (0, common_1.config)(context, "cacheCase", ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)), options);
+    options = await (0, common_1.config)(context, 'cacheCase', ['rspack.config.js', 'webpack.config.js'].map((i) => node_path_1.default.resolve(temp, i)), options);
     // overwrite
     if (!options.entry) {
-        options.entry = "./index.js";
+        options.entry = './index.js';
     }
     // rewrite context to temp dir
     options.context = temp;
     options.module ??= {};
-    for (const cssModuleType of ["css/auto", "css/module", "css"]) {
+    for (const cssModuleType of ['css/auto', 'css/module', 'css']) {
         options.module.generator ??= {};
         options.module.generator[cssModuleType] ??= {};
         options.module.generator[cssModuleType].exportsOnly ??=
-            target === "async-node";
+            target === 'async-node';
     }
     options.plugins ??= [];
     options.plugins.push(updatePlugin);
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
     return options;
@@ -129,15 +129,15 @@ function findBundle(name, target, context) {
     const prefiles = [];
     const compiler = context.getCompiler();
     if (!compiler)
-        throw new Error("Compiler should exists when find bundle");
+        throw new Error('Compiler should exists when find bundle');
     const stats = compiler.getStats();
     if (!stats)
-        throw new Error("Stats should exists when find bundle");
+        throw new Error('Stats should exists when find bundle');
     const info = stats.toJson({
         all: false,
-        entrypoints: true
+        entrypoints: true,
     });
-    if (target === "web" || target === "webworker") {
+    if (target === 'web' || target === 'webworker') {
         for (const file of info.entrypoints.main.assets) {
             if ((0, helper_1.isJavaScript)(file.name)) {
                 files.push(file.name);
@@ -148,7 +148,7 @@ function findBundle(name, target, context) {
         }
     }
     else {
-        const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
+        const assets = info.entrypoints.main.assets.filter((s) => (0, helper_1.isJavaScript)(s.name));
         files.push(assets[assets.length - 1].name);
     }
     return [...prefiles, ...files];
@@ -160,7 +160,7 @@ function createRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const updatePlugin = context.getValue("hotUpdateContext");
+    const updatePlugin = context.getValue('hotUpdateContext');
     const getWebRunner = () => {
         return new runner_1.NodeRunner({
             env,
@@ -171,7 +171,7 @@ function createRunner(context, name, file, env) {
             testConfig: {
                 ...testConfig,
                 moduleScope(ms, stats, options) {
-                    const moduleScope = typeof testConfig.moduleScope === "function"
+                    const moduleScope = typeof testConfig.moduleScope === 'function'
                         ? testConfig.moduleScope(ms, stats, options)
                         : ms;
                     moduleScope.COMPILER_INDEX = compilerIndex;
@@ -179,18 +179,18 @@ function createRunner(context, name, file, env) {
                     moduleScope.NEXT_START = nextStart;
                     moduleScope.NEXT_MOVE_DIR_START = nextMoveDirStart;
                     return moduleScope;
-                }
+                },
             },
             source,
             dist,
-            compilerOptions: options
+            compilerOptions: options,
         });
     };
     const checkStats = async (stats) => {
         const compilerOptions = compiler.getOptions();
         const updateIndex = updatePlugin.getUpdateIndex();
-        await (0, checkArrayExpectation_1.default)(source, stats, "error", `errors${updateIndex}`, "Error", compilerOptions);
-        await (0, checkArrayExpectation_1.default)(source, stats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, stats, 'error', `errors${updateIndex}`, 'Error', compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, stats, 'warning', `warnings${updateIndex}`, 'Warning', compilerOptions);
     };
     const nextHmr = async (m, options) => {
         await updatePlugin.goNext();
@@ -201,7 +201,7 @@ function createRunner(context, name, file, env) {
         await checkStats(jsonStats);
         const updatedModules = await m.hot.check(options || true);
         if (!updatedModules) {
-            throw new Error("No update available");
+            throw new Error('No update available');
         }
         return jsonStats;
     };

package/dist/case/common.d.ts

@@ -1,5 +1,5 @@
-import type { Compiler, RspackOptions } from "@rspack/core";
-import type { ITestContext, ITestEnv } from "../type";
+import type { Compiler, RspackOptions } from '@rspack/core';
+import type { ITestContext, ITestEnv } from '../type';
 export declare function config(context: ITestContext, name: string, configFiles: string[], defaultOptions?: RspackOptions): Promise<RspackOptions>;
 export declare function compiler(context: ITestContext, name: string): Promise<Compiler>;
 export declare function build(context: ITestContext, name: string): Promise<Compiler>;

package/dist/case/common.js

@@ -23,7 +23,7 @@ async function config(context, name, configFiles, defaultOptions = {}) {
     const compiler = context.getCompiler();
     compiler.setOptions(defaultOptions);
     if (Array.isArray(configFiles)) {
-        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, defaultOptions)[0];
+        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, defaultOptions)[0];
         compiler.mergeOptions(fileOptions);
     }
     return compiler.getOptions();
@@ -43,17 +43,17 @@ async function run(env, context, name, findBundle) {
     if (testConfig.noTests)
         return;
     const compiler = context.getCompiler();
-    if (typeof testConfig.beforeExecute === "function") {
+    if (typeof testConfig.beforeExecute === 'function') {
         testConfig.beforeExecute(compiler.getOptions());
     }
     let bundles;
-    if (typeof findBundle === "function") {
+    if (typeof findBundle === 'function') {
         bundles = findBundle(context, compiler.getOptions());
     }
     else {
         bundles = [];
     }
-    if (typeof bundles === "string") {
+    if (typeof bundles === 'string') {
         bundles = [bundles];
     }
     if (__DEBUG__) {
@@ -76,11 +76,11 @@ async function run(env, context, name, findBundle) {
             runLogs?.push(`Start running entry: ${bundle} in ${runner.constructor.name}(${runner.__key__})`);
         }
         const mod = runner.run(bundle);
-        const result = context.getValue("modules") || [];
+        const result = context.getValue('modules') || [];
         result.push(mod);
-        context.setValue("modules", result);
+        context.setValue('modules', result);
     }
-    const results = context.getValue("modules") || [];
+    const results = context.getValue('modules') || [];
     await Promise.all(results);
 }
 async function check(env, context, name) {
@@ -88,32 +88,32 @@ async function check(env, context, name) {
     if (testConfig.noTests)
         return;
     const compiler = context.getCompiler();
-    const errors = (context.getError() || []).map(e => ({
+    const errors = (context.getError() || []).map((e) => ({
         message: e.message,
-        stack: e.stack
+        stack: e.stack,
     }));
     const warnings = [];
     const stats = compiler.getStats();
     const options = compiler.getOptions();
     if (stats) {
         if (testConfig.writeStatsOuptut) {
-            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                preset: "verbose",
-                colors: false
-            }), "utf-8");
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), 'stats.txt'), stats.toString({
+                preset: 'verbose',
+                colors: false,
+            }), 'utf-8');
         }
         if (testConfig.writeStatsJson) {
             const jsonStats = stats.toJson({
-                errorDetails: true
+                errorDetails: true,
             });
-            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
+            fs_extra_1.default.writeFileSync(path_1.default.join(context.getDist(), 'stats.json'), JSON.stringify(jsonStats, null, 2), 'utf-8');
         }
-        if (fs_extra_1.default.existsSync(context.getSource("errors.js")) ||
-            fs_extra_1.default.existsSync(context.getSource("warnings.js")) ||
+        if (fs_extra_1.default.existsSync(context.getSource('errors.js')) ||
+            fs_extra_1.default.existsSync(context.getSource('warnings.js')) ||
             stats.hasErrors() ||
             stats.hasWarnings()) {
             const statsJson = stats.toJson({
-                errorDetails: true
+                errorDetails: true,
             });
             if (statsJson.errors) {
                 errors.push(...statsJson.errors);
@@ -123,26 +123,26 @@ async function check(env, context, name) {
             }
         }
     }
-    await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error", options);
-    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, 'error', 'errors', 'Error', options);
+    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, 'warning', 'warnings', 'Warning', options);
     // clear error if checked
-    if (fs_extra_1.default.existsSync(context.getSource("errors.js"))) {
+    if (fs_extra_1.default.existsSync(context.getSource('errors.js'))) {
         context.clearError();
     }
 }
 async function checkSnapshot(env, context, name, snapshot, filter) {
-    if (path_1.default.extname(snapshot) === ".snap") {
-        throw new Error("Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead");
+    if (path_1.default.extname(snapshot) === '.snap') {
+        throw new Error('Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead');
     }
     const compilerManager = context.getCompiler();
     const stats = compilerManager.getStats();
     const compiler = compilerManager.getCompiler();
     if (!stats || !compiler)
         return;
-    const compilers = "compilers" in compiler
+    const compilers = 'compilers' in compiler
         ? compiler.compilers
         : [compiler];
-    const totalStats = "stats" in stats ? stats.stats : [stats];
+    const totalStats = 'stats' in stats ? stats.stats : [stats];
     const total = compilers.length;
     for (let i = 0; i < compilers.length; i++) {
         const c = compilers[i];
@@ -151,38 +151,38 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
             const errors = [];
             errors.push(...stats.compilation.errors);
             throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
-                ?.map(i => `${i.message}\n${i.stack}`)
-                .join("\n\n")}`);
+                ?.map((i) => `${i.message}\n${i.stack}`)
+                .join('\n\n')}`);
         }
         const compilation = c._lastCompilation ||
             c._lastCompilation;
         const snapshotFileFilter = filter ||
-            ((file) => (file.endsWith(".js") || file.endsWith(".mjs")) &&
-                !file.includes("runtime.js"));
+            ((file) => (file.endsWith('.js') || file.endsWith('.mjs')) &&
+                !file.includes('runtime.js'));
         const fileContents = Object.entries(compilation.assets)
             .filter(([file]) => snapshotFileFilter(file))
             .map(([file, source]) => {
-            const tag = path_1.default.extname(file).slice(1) || "txt";
+            const tag = path_1.default.extname(file).slice(1) || 'txt';
             let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
             const testConfig = context.getTestConfig();
             if (testConfig.snapshotContent) {
                 content = testConfig.snapshotContent(content);
             }
-            const filePath = file.replaceAll(path_1.default.sep, "/");
+            const filePath = file.replaceAll(path_1.default.sep, '/');
             return `\`\`\`${tag} title=${filePath}\n${content}\n\`\`\``;
         });
         fileContents.sort();
-        const content = fileContents.join("\n\n");
+        const content = fileContents.join('\n\n');
         const snapshotPath = path_1.default.isAbsolute(snapshot)
             ? snapshot
-            : path_1.default.resolve(context.getSource(), path_1.default.join("__snapshots__", `${snapshot}${total > 1 ? `-${i}` : ""}`));
+            : path_1.default.resolve(context.getSource(), path_1.default.join('__snapshots__', `${snapshot}${total > 1 ? `-${i}` : ''}`));
         env.expect(content).toMatchFileSnapshotSync(snapshotPath);
     }
 }
 async function afterExecute(context, name) {
     const compiler = context.getCompiler();
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.afterExecute === "function") {
+    if (typeof testConfig.afterExecute === 'function') {
         let options = compiler.getOptions();
         if (Array.isArray(options) && options.length === 1) {
             options = options[0];
@@ -191,13 +191,13 @@ async function afterExecute(context, name) {
     }
 }
 function findMultiCompilerBundle(context, name, multiFindBundle) {
-    if (typeof multiFindBundle !== "function") {
+    if (typeof multiFindBundle !== 'function') {
         return [];
     }
-    const multiCompilerOptions = (context.getValue("multiCompilerOptions") ||
+    const multiCompilerOptions = (context.getValue('multiCompilerOptions') ||
         []);
     const result = [];
-    const multiFileIndexMap = context.getValue("multiFileIndexMap") || {};
+    const multiFileIndexMap = context.getValue('multiFileIndexMap') || {};
     for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
         const curBundles = multiFindBundle(index, context, compilerOptions);
         const bundles = Array.isArray(curBundles)
@@ -215,18 +215,18 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
         }
         result.push(...bundles);
     }
-    context.setValue("multiFileIndexMap", multiFileIndexMap);
+    context.setValue('multiFileIndexMap', multiFileIndexMap);
     return result;
 }
 function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
     const multiCompilerOptions = [];
     const caseOptions = Array.isArray(configFiles)
-        ? (0, helper_1.readConfigFile)(configFiles.map(i => context.getSource(i)), context, {}, configs => {
-            return configs.flatMap(c => {
-                if (typeof c === "function") {
+        ? (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, {}, (configs) => {
+            return configs.flatMap((c) => {
+                if (typeof c === 'function') {
                     const options = {
                         testPath: context.getDist(),
-                        env: undefined
+                        env: undefined,
                     };
                     return c(options.env, options);
                 }
@@ -235,15 +235,15 @@ function configMultiCompiler(context, name, configFiles, defaultOptions, overrid
         })
         : [{}];
     for (const [index, options] of caseOptions.entries()) {
-        const compilerOptions = (0, webpack_merge_1.default)(typeof defaultOptions === "function"
+        const compilerOptions = (0, webpack_merge_1.default)(typeof defaultOptions === 'function'
             ? defaultOptions(index, context)
             : {}, options);
-        if (typeof overrideOptions === "function") {
+        if (typeof overrideOptions === 'function') {
             overrideOptions(index, context, compilerOptions);
         }
         multiCompilerOptions.push(compilerOptions);
     }
     const compiler = context.getCompiler();
     compiler.setOptions(multiCompilerOptions);
-    context.setValue("multiCompilerOptions", multiCompilerOptions);
+    context.setValue('multiCompilerOptions', multiCompilerOptions);
 }