const filename = path.join(__dirname, "..", relativePath);

const { outputText } = ts.transpileModule(fs.readFileSync(filename, "utf8"), {

compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2016, esModuleInterop: true, jsx: ts.JsxEmit.ReactJSX },

fileName: filename,

});

const module = { exports: {} };

vm.runInNewContext(outputText, {

module, exports: module.exports, process, performance,

require: name => Object.prototype.hasOwnProperty.call(mocks, name) ? mocks[name] : resolve(name),

console: { warn: warning => warnings.push(warning), error: error => warnings.push(error) },

...globals,

}, { filename });

return module.exports;

const { renderToStaticMarkup } = require("react-dom/server");

const cache = new Map();

const messages = [];

let receive;

let html;

const globals = {

acquireVsCodeApi: () => ({ postMessage: message => messages.push(message) }),

document: { getElementById: id => id === "java-pack-l10n" ? null : ({}) },

window: { addEventListener: (_, listener) => { receive = listener; } },

};

const mocks = {

"react-dom/client": { createRoot: () => ({ render: element => { html = renderToStaticMarkup(element); } }) },

};

function load(relativePath) {

if (!cache.has(relativePath)) {

cache.set(relativePath, loadSource(relativePath, mocks, [], globals, name => {

if (name.endsWith(".scss") || name.startsWith("@vscode-elements/")) {

return {};

}

if (!name.startsWith(".")) {

return require(name);

}

const source = path.resolve(__dirname, "..", path.dirname(relativePath), name);

const filename = fs.existsSync(source + ".tsx") ? source + ".tsx" : source + ".ts";

return load(path.relative(path.join(__dirname, ".."), filename));

}));

}

return cache.get(relativePath);

}

return {

load, messages,

show: args => {

receive({ data: { command: "showJavaRuntimeEntries", args } });

return html;

},

};

const extension = { packageJSON: { version }, isActive: false, exports: {} };

const projectManager = { isActive: false };

const preferences = {};

const discovered = [];

const writes = [];

const warnings = [];

const messages = [];

const calls = { discovery: 0, inspection: 0, activation: 0 };

const runtimes = new Map();

let receiveMessage;

extension.activate = async () => { calls.activation++; return extension.exports; };

const jdkUtils = {

findRuntimes: async () => { calls.discovery++; return [...discovered]; },

getRuntime: async home => { calls.inspection++; return runtimes.get(home); },

};

const panel = {

webview: {

cspSource: "test", asWebviewUri: uri => uri.fsPath,

onDidReceiveMessage: callback => { receiveMessage = callback; return { dispose() {} }; },

postMessage: async message => { messages.push(message); return true; },

},

onDidDispose: () => ({ dispose() {} }),

};

const vscode = {

l10n: require("./helpers/l10n").createL10n(),

extensions: {

getExtension: id => id === "redhat.java" ? extension :

id === "vscjava.vscode-java-dependency" ? projectManager : undefined,

},

Uri: { file: fsPath => ({ fsPath }), parse: uri => ({ fsPath: new URL(uri).pathname }) },

ViewColumn: { One: 1 }, ConfigurationTarget: { Global: 1 },

window: {

createWebviewPanel: () => panel, showOpenDialog: async () => undefined,

showWarningMessage: async message => warnings.push(message),

showErrorMessage: async message => warnings.push(message),

},

workspace: {

getConfiguration: section => ({

get: key => preferences[section ? `${section}.${key}` : key],

update: async (key, value) => {

const setting = section ? `${section}.${key}` : key;

writes.push({ setting, value });

preferences[setting] = value;

},

}),

},

commands: { executeCommand: async () => [] },

};

const mocks = {

vscode, "jdk-utils": jdkUtils, "expand-home-dir": home => home,

"../l10n/host": { escapeHtml: text => text, webviewLanguage: () => "en", localizationBootstrap: () => "" },

};

const api = loadSource(path.join("src", "java-runtime", "utils", "upstreamApi.ts"), mocks, warnings);

const webviewUtils = loadSource(path.join("src", "utils", "webview.ts"), {}, warnings);

const jdt = loadSource(path.join("src", "utils", "jdt.ts"), {

vscode, "./webview": webviewUtils,

}, warnings);

const loadView = () => loadSource(path.join("src", "java-runtime", "index.ts"), {

...mocks, "../utils": { getNonce: () => "nonce" }, "../utils/jdt": jdt, "../utils/webview": webviewUtils,

"./utils/misc": {}, "./utils/upstreamApi": api,

}, warnings);

const addJdk = (major, hasJavac = true) => {

const homedir = path.join(path.parse(__dirname).root, "jdks", `jdk-${major}-${runtimes.size}`);

const runtime = { homedir, hasJavac, version: { major } };

runtimes.set(homedir, runtime);

return runtime;

};

const report = (tooling, project = tooling) => {

extension.isActive = true;

extension.exports.javaRequirement = {

tooling_jre: tooling.homedir, tooling_jre_version: tooling.version.major,

java_home: project.homedir, java_version: project.version.major,

};

};

const openView = async () => {

const view = loadView();

await view.javaRuntimeCmdHandler({

extensionPath: __dirname, asAbsolutePath: relativePath => path.join(__dirname, relativePath),

subscriptions: [],

}, "unit-test");

return view;

};

return {

api, extension, projectManager, preferences, discovered, writes, warnings, messages, calls, jdkUtils, vscode,

addJdk, report, loadView, openView,

send: (command, payload = {}) => receiveMessage({ command, ...payload }),

};

s.projectManager.isActive = source === "PM";

s.vscode.workspace.workspaceFolders = [{ uri: { toString: () => "file:///workspace" } }];

s.vscode.commands.executeCommand = async (_, command) =>

command === "java.project.list" ?

projects.map(uri => ({ uri, name: path.basename(new URL(uri).pathname) })) : projects;

s.extension.exports.getProjectSettings = async () => ({

"org.eclipse.jdt.ls.core.natureIds": ["org.eclipse.m2e.core.maven2Nature"],

"org.eclipse.jdt.core.compiler.source": "17",

"org.eclipse.jdt.ls.core.vm.location": "project-jdk",

});

if (uri === "file:///failed") {

throw new Error("Settings request failed");

}

const settings = await getSettings();

if (uri === "file:///missing-type") {

delete settings["org.eclipse.jdt.ls.core.natureIds"];

} else if (uri === "file:///invalid-type") {

settings["org.eclipse.jdt.ls.core.natureIds"] = [null];

} else if (uri === "file:///after") {

settings["org.eclipse.jdt.ls.core.natureIds"] = [];

}

return settings;

if (args[1] === "java.project.list") {

throw new Error("PM list failed");

}

return executeCommand(...args);

assert.equal(args[1], "java.project.list");

if (args[2] === "file:///failed-workspace") {

throw new Error("Workspace list failed");

}

return executeCommand(...args);