perf: shorten commetn

Author: wenytang-ms

java-extension/com.microsoft.java.test.plugin/src/main/java/com/microsoft/java/test/plugin/launchers/JUnitLaunchConfigurationDelegate.java

@@ -146,16 +146,9 @@ private void addTestItemArgs(List<String> arguments) throws CoreException {
         } else if (this.args.testLevel == TestLevel.METHOD) {
             if (this.args.testNames.length > 1) {
                 if (!JUnitLaunchUtils.supportsMultiMethodLaunch()) {
-                    // The Class:method protocol is parsed by RemoteTestRunner inside
-                    // org.eclipse.jdt.junit.runtime, which ships with the Eclipse Java
-                    // Language Server (Language Support for Java(TM) by Red Hat). When
-                    // that bundle predates eclipse.jdt.ui#2975, batching multiple
-                    // methods into a single JVM would surface as a ClassNotFoundException
-                    // at test time. Fail fast here with a marker the TypeScript side
-                    // recognises so it can transparently fall back to launching each
-                    // method in its own JVM (the legacy per-method path). The actionable
-                    // text after the marker is preserved as a defensive fallback in case
-                    // the fallback path itself also fails for an unrelated reason.
+                    // Bundled org.eclipse.jdt.junit.runtime predates eclipse.jdt.ui#2975.
+                    // Fail fast with a marker so the TypeScript side can fall back to
+                    // per-method launches transparently.
                     throw new CoreException(new Status(IStatus.ERROR, JUnitPlugin.PLUGIN_ID, IStatus.ERROR,
                             JUnitLaunchUtils.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX
                                     + "Running multiple test methods together in a single JVM requires a newer "
@@ -164,11 +157,9 @@ private void addTestItemArgs(List<String> arguments) throws CoreException {
                                     + "extension and retry, or run the selected methods one at a time.",
                             null));
                 }
-                // Multi-method launch: hand the full selection to RemoteTestRunner via
-                // -testNameFile using the new "Class:method" line format. The runner
-                // will then load every selected method inside a single test JVM, so
-                // per-class @BeforeAll/@AfterAll and any cached Spring
-                // ApplicationContext are reused across the selection.
+                // Multi-method launch via "Class:method" lines: all selected methods share
+                // one JVM so per-class @BeforeAll/@AfterAll and cached fixtures (e.g.
+                // Spring ApplicationContext) are reused. See issue #1836.
                 final String fileName = createMethodTestNamesFile(this.args.testNames);
                 arguments.add("-testNameFile");
                 arguments.add(fileName);

java-extension/com.microsoft.java.test.plugin/src/main/java/com/microsoft/java/test/plugin/launchers/JUnitLaunchUtils.java

@@ -55,30 +55,24 @@ public class JUnitLaunchUtils {
     private static final String JUNIT4_LOADER = "org.eclipse.jdt.junit.loader.junit4";
 
     /**
-     * Bundle that hosts {@code RemoteTestRunner}, the consumer of the
-     * {@code -testNameFile} content. This jar is shipped by the Eclipse Java
-     * Language Server (i.e. the "Language Support for Java(TM) by Red Hat"
-     * extension), not by vscode-java-test itself.
+     * Bundle that hosts {@code RemoteTestRunner}, the consumer of {@code -testNameFile}.
+     * Shipped by the Eclipse Java Language Server, not by vscode-java-test itself.
      */
     private static final String JUNIT_RUNTIME_BUNDLE = "org.eclipse.jdt.junit.runtime";
 
     /**
-     * Stable prefix prepended to the {@link CoreException} thrown when the
-     * resolved {@code org.eclipse.jdt.junit.runtime} bundle is too old to
-     * understand the {@code Class:method} multi-method launch protocol. The
-     * TypeScript side detects this prefix and silently falls back to launching
-     * every selected method in its own JVM (the legacy per-method path),
-     * keeping the user experience identical to the pre-batching behaviour on
-     * older Eclipse Java Language Server releases. Do NOT change the value
-     * without updating the corresponding constant on the client side.
+     * Marker prepended to the launch-resolution error when the bundled
+     * {@code org.eclipse.jdt.junit.runtime} is too old for the
+     * {@code Class:method} multi-method launch protocol. Detected by the
+     * TypeScript side to fall back to per-method launches. Keep in sync with
+     * the constant on the client side.
      */
     public static final String MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX =
             "MULTI_METHOD_LAUNCH_UNSUPPORTED: ";
 
     /**
-     * Minimum {@code org.eclipse.jdt.junit.runtime} version that recognises the
-     * {@code Class:method} multi-method launch protocol introduced by
-     * <a href="https://github.com/eclipse-jdt/eclipse.jdt.ui/pull/2975">eclipse.jdt.ui#2975</a>.
+     * Minimum {@code org.eclipse.jdt.junit.runtime} version that supports the
+     * {@code Class:method} multi-method launch protocol (eclipse.jdt.ui#2975).
      */
     private static final Version MIN_JDT_JUNIT_RUNTIME_VERSION_FOR_MULTI_METHOD =
             Version.parseVersion("3.8.100");
@@ -87,11 +81,7 @@ private JUnitLaunchUtils() {}
 
     /**
      * @return {@code true} when the resolved {@code org.eclipse.jdt.junit.runtime}
-     * bundle is new enough to parse the {@code Class:method} multi-method launch
-     * protocol; {@code false} otherwise. When this returns {@code false}, callers
-     * must not batch multiple methods into a single JVM via the
-     * {@code -testNameFile} mechanism — the legacy per-method launch path should
-     * be used instead.
+     * supports batching multiple methods into a single JVM via {@code -testNameFile}.
      */
     public static boolean supportsMultiMethodLaunch() {
         final Bundle bundle = Platform.getBundle(JUNIT_RUNTIME_BUNDLE);

src/constants.ts

@@ -68,16 +68,11 @@ export namespace Context {
 
 export namespace JUnitLaunchProtocol {
     /**
-     * Stable prefix prepended to the launch-resolution error thrown by the
-     * Java plugin when the bundled {@code org.eclipse.jdt.junit.runtime}
+     * Marker prepended to the launch-resolution error when the bundled JDT-LS
      * predates the {@code Class:method} multi-method launch protocol
-     * introduced by eclipse.jdt.ui#2975. The TypeScript runner detects this
-     * prefix and silently re-launches every selected method in its own JVM
-     * (the legacy per-method path), keeping the user experience identical to
-     * the pre-batching behaviour on older Eclipse Java Language Server
-     * releases. Keep in sync with
-     * {@code JUnitLaunchUtils.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX} on the
-     * Java side.
+     * (eclipse.jdt.ui#2975). Detected by the runner to fall back silently to
+     * per-method launches. Must match
+     * {@code JUnitLaunchUtils.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX} on the Java side.
      */
     export const MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX: string = 'MULTI_METHOD_LAUNCH_UNSUPPORTED: ';
 }

src/controller/testController.ts

@@ -265,22 +265,17 @@ export const runTests: (request: TestRunRequest, option: IRunOption) => any = in
                             if (typeof error?.message === 'string'
                                 && error.message.startsWith(JUnitLaunchProtocol.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX)
                                 && testContext.testItems.length > 1) {
-                                // Silent fallback for older Eclipse Java Language Server
-                                // releases (predating eclipse.jdt.ui#2975): re-launch every
-                                // selected method in its own JVM. From here on the cancel
-                                // handler must defer to the per-item debug sessions, just
-                                // as it would for a normal multi-group run.
+                                // Silent fallback for legacy JDT-LS (pre eclipse.jdt.ui#2975):
+                                // re-launch every selected method in its own JVM.
                                 delegatedToDebugger = true;
                                 const itemsToRetry: TestItem[] = [...testContext.testItems];
                                 for (const item of itemsToRetry) {
                                     if (token.isCancellationRequested) {
                                         break;
                                     }
-                                    // Each per-item launch hands its progress to the debugger
-                                    // via __progressId, and the debugger calls done() when the
-                                    // session ends. The next iteration must therefore obtain a
-                                    // fresh progress reporter — mirroring the same isCancelled
-                                    // reset that the outer per-kind loop performs at line ~240.
+                                    // Each per-item launch hands progress to the debugger via
+                                    // __progressId; the debugger dones the reporter on session
+                                    // end. Reset like the outer per-kind loop does (~line 240).
                                     if (option.progressReporter?.isCancelled()) {
                                         option.progressReporter = progressProvider?.createProgressReporter(option.isDebug ? 'Debug Tests' : 'Run Tests');
                                     }
@@ -682,11 +677,10 @@ export function mergeTestMethods(testItems: TestItem[]): TestItem[][] { // expor
             && !([...methods].some((m: TestItem) => dataCache.get(m)?.uniqueId))) {
             classMapping.set(clazz.id, clazz);
         } else {
-            // Methods restricted to a single invocation (uniqueId) must still run in their
-            // own launch since the underlying protocol carries at most one uniqueId per JVM.
-            // Every other method of the same class can share one launch so that
-            // @BeforeAll / @AfterAll and any cached fixture (e.g. Spring ApplicationContext)
-            // are reused across the selection. See issue #1836.
+            // uniqueId methods must run alone (the protocol carries at most one
+            // uniqueId per JVM); the rest can share a JVM so @BeforeAll/@AfterAll
+            // and cached fixtures (e.g. Spring ApplicationContext) are reused.
+            // See issue #1836.
             const groupable: TestItem[] = [];
             for (const method of methods.values()) {
                 if (dataCache.get(method)?.uniqueId) {
@@ -753,14 +747,9 @@ function getRunnerByContext(testContext: IRunTestContext): BaseRunner | undefine
 }
 
 /**
- * Run a single test item through its own setup → resolve → run → tearDown
- * cycle. Used as a silent fallback when the bundled JDT-LS does not yet
- * understand the {@code Class:method} multi-method launch protocol
- * (eclipse.jdt.ui#2975) — every selected method is re-launched in its own JVM,
- * matching the pre-batching behaviour. Errors during the fallback are
- * surfaced per-item so unrelated failures (e.g. compilation errors) are still
- * reported to the user; the multi-method marker itself is filtered out so the
- * scary "requires a newer..." text never reaches the popup.
+ * Run a single test item through its own setup → resolve → run → tearDown cycle.
+ * Used as the silent fallback when the bundled JDT-LS lacks the
+ * {@code Class:method} multi-method protocol (eclipse.jdt.ui#2975).
  */
 async function runItemInIsolatedLaunch(
     item: TestItem,
@@ -787,9 +776,7 @@ async function runItemInIsolatedLaunch(
         await runner.run(resolvedConfiguration, token, option.progressReporter);
     } catch (error) {
         const rawMessage: string = error?.message || 'Failed to run tests.';
-        // Strip the internal marker if it ever bubbles up here (e.g. the user
-        // somehow ends up with a single-method batch that still hits the
-        // capability gate) so the popup stays user-readable.
+        // Strip the internal marker if it ever bubbles up here so the popup stays user-readable.
         const message: string = rawMessage.startsWith(JUnitLaunchProtocol.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX)
             ? rawMessage.substring(JUnitLaunchProtocol.MULTI_METHOD_LAUNCH_UNSUPPORTED_PREFIX.length)
             : rawMessage;