Support debug test delegation

extension/jdtls.ext/com.microsoft.gradle.bs.importer/src/com/microsoft/gradle/bs/importer/handler/GradleDelegateCommandHandler.java

@@ -76,7 +76,7 @@ public Object executeCommand(String commandId, List<Object> arguments, IProgress
                     getEnvVarPairs(arguments)
                 );
                 testParams.setData(scalaTestSuites);
-                buildServerConnection.buildTargetTest(testParams).join();
+                buildServerConnection.buildTargetTest(testParams);
                 return null;
             default:
                 break;

extension/src/Extension.ts

@@ -247,10 +247,15 @@
     private async activate(): Promise<void> {
         const testExtension = vscode.extensions.getExtension("vscjava.vscode-java-test");
         if (testExtension) {
             testExtension.activate().then((api: any) => {
                 if (api) {
                     const testRunner: GradleTestRunner = this.buildServerController.getGradleTestRunner(api);
                     api.registerTestProfile("Delegate Test to Gradle", vscode.TestRunProfileKind.Run, testRunner);
+                    api.registerTestProfile(
+                        "Delegate Test to Gradle (Debug)",
+                        vscode.TestRunProfileKind.Debug,
+                        testRunner
+                    );
                 }
             });
         }

extension/src/bs/GradleTestRunner.ts

@@ -6,18 +6,24 @@
     IRunTestContext,
     TestIdParts,
 } from "../java-test-runner.api";
+import * as getPort from "get-port";
+import { waitOnTcp } from "../util";
+import * as os from "os";
+import * as path from "path";
 
 export class GradleTestRunner implements TestRunner {
     private readonly _onDidChangeTestItemStatus = new vscode.EventEmitter<TestItemStatusChangeEvent>();
     private readonly _onDidFinishTestRun = new vscode.EventEmitter<TestFinishEvent>();
     private context: IRunTestContext;
     private testRunnerApi: any;
+    private testInitScriptPath: string;
 
     public onDidChangeTestItemStatus: vscode.Event<TestItemStatusChangeEvent> = this._onDidChangeTestItemStatus.event;
     public onDidFinishTestRun: vscode.Event<TestFinishEvent> = this._onDidFinishTestRun.event;
 
     constructor(testRunnerApi: any) {
         this.testRunnerApi = testRunnerApi;
+        this.testInitScriptPath = path.join(os.tmpdir(), "testInitScript.gradle");
     }
 
     public async launch(context: IRunTestContext): Promise<void> {
@@ -40,8 +46,34 @@
             tests.set(parts.class, testMethods);
         });
 
-        const agrs = context.testConfig?.args;
+        const agrs = context.testConfig?.args ?? [];
         const vmArgs = context.testConfig?.vmArgs;
+        const isDebug = context.isDebug && !!vscode.extensions.getExtension("vscjava.vscode-java-debug");
+        let debugPort = -1;
+        if (isDebug) {
+            debugPort = await getPort();
+            // See: https://docs.gradle.org/current/javadoc/org/gradle/tooling/TestLauncher.html#debugTestsOn(int)
+            // since the gradle tooling api does not support debug tests in server=y mode, so we use the init script
+            // as a workaround
+            const initScriptContent = `allprojects {
+    afterEvaluate {
+        tasks.withType(Test) {
+            debugOptions {
+                enabled = true
+                host = 'localhost'
+                port = ${debugPort}
+                server = true
+                suspend = true
+            }
+        }
+    }
+}`;
+            await vscode.workspace.fs.writeFile(
+                vscode.Uri.file(this.testInitScriptPath),
+                Buffer.from(initScriptContent)
+            );
+            agrs.unshift("--init-script", this.testInitScriptPath);
+        }
         const env = context.testConfig?.env;
         try {
             await vscode.commands.executeCommand(
@@ -53,6 +85,9 @@
                 vmArgs,
                 env
             );
+            if (isDebug) {
+                this.startJavaDebug(debugPort);
+            }
         } catch (error) {
             this.finishTestRun(-1, error.message);
         }
@@ -125,4 +160,24 @@
             "worker.org.gradle.process.internal.",
         ];
     }
+
+    private async startJavaDebug(javaDebugPort: number): Promise<void> {
+        if (javaDebugPort < 0) {
+            return;
+        }
+
+        await waitOnTcp("localhost", javaDebugPort);
+        const debugConfig = {
+            type: "java",
+            name: "Debug (Attach) via Gradle",
+            request: "attach",
+            hostName: "localhost",
+            port: javaDebugPort,
+            projectName: this.context.projectName,
+        };
+        const startedDebugging = await vscode.debug.startDebugging(this.context.workspaceFolder, debugConfig);
+        if (!startedDebugging) {
+            throw new Error("The debugger was not started");
+        }
+    }
 }