feat: route real test program output to Test Results

The debuggee's stdout/stderr are delivered by java-debug as standard DAP
`output` events, which by default only surface in the Debug Console. This
splits program output (Debug Console) from test results (Test Results view)
across two separate surfaces, and the runner previously echoed the raw
JUnit/TestNG control protocol frames to Test Results as noise.

- Attach a DebugAdapterTracker to the test's own debug session and forward
  its DAP `output` events into the Test Results view (BaseRunner).
- Stop echoing the socket control protocol to Test Results: JUnit no longer
  appends every raw line, and TestNG no longer echoes its JSON frames.
- Attribute forwarded output to the running test when exactly one test is
  executing; fall back to run-level output when idle or when several tests
  run in parallel (attribution would only be a guess).

Author: wenytang-ms

src/runners/baseRunner/BaseRunner.ts

@@ -4,7 +4,7 @@
 import * as iconv from 'iconv-lite';
 import { AddressInfo, createServer, Server, Socket } from 'net';
 import * as os from 'os';
-import { CancellationToken, debug, DebugConfiguration, DebugSession, Disposable } from 'vscode';
+import { CancellationToken, debug, DebugAdapterTracker, DebugConfiguration, DebugSession, Disposable, ProviderResult } from 'vscode';
 import { sendError } from 'vscode-extension-telemetry-wrapper';
 import { Configurations } from '../../constants';
 import { IProgressReporter } from '../../debugger.api';
@@ -56,6 +56,34 @@ export abstract class BaseRunner implements ITestRunnerInternal {
         // So we force to use internal console here to make sure the session is still under debugger's control.
         launchConfiguration.console = 'internalConsole';
 
+        // The debuggee's stdout/stderr are delivered by java-debug as standard DAP `output` events,
+        // which by default only surface in the Debug Console. Attach a tracker to the test's own debug
+        // session and forward those output events into the Test Results view, so the program output shows
+        // up next to the test results instead of being split across two separate surfaces.
+        this.disposables.push(debug.registerDebugAdapterTrackerFactory('java', {
+            createDebugAdapterTracker: (session: DebugSession): ProviderResult<DebugAdapterTracker> => {
+                if (session.name !== launchConfiguration.name) {
+                    return undefined;
+                }
+                return {
+                    onDidSendMessage: (message: any): void => {
+                        if (message?.type === 'event' && message.event === 'output') {
+                            const category: string | undefined = message.body?.category;
+                            // `telemetry` output events are not meant for the user.
+                            if (category === 'telemetry') {
+                                return;
+                            }
+                            const output: string | undefined = message.body?.output;
+                            if (output) {
+                                // Let the analyzer attribute the output to the running test when possible.
+                                this.runnerResultAnalyzer.appendProgramOutput(output);
+                            }
+                        }
+                    },
+                };
+            },
+        }));
+
         let debugSession: DebugSession | undefined;
         this.disposables.push(debug.onDidStartDebugSession((session: DebugSession) => {
             if (session.name === launchConfiguration.name) {

src/runners/baseRunner/RunnerResultAnalyzer.ts

@@ -10,12 +10,45 @@ export abstract class RunnerResultAnalyzer {
     // Track parent test item states to update them when all children complete
     protected parentStates: Map<TestItem, ParentItemState> = new Map();
 
+    // Test items that are currently executing. Used to attribute program output
+    // (captured from the debug session) to the running test when it is unambiguous.
+    private runningItems: Set<TestItem> = new Set();
+
     constructor(protected testContext: IRunTestContext) { }
 
     public abstract analyzeData(data: string): void;
     public abstract processData(data: string): void;
     protected testMessageLocation: Location | undefined;
 
+    /**
+     * Record that a test item has started executing.
+     */
+    protected markItemStarted(item: TestItem): void {
+        this.runningItems.add(item);
+    }
+
+    /**
+     * Record that a test item has finished executing.
+     */
+    protected markItemFinished(item: TestItem): void {
+        this.runningItems.delete(item);
+    }
+
+    /**
+     * Forward program output (captured from the test's debug session as DAP `output`
+     * events) into the Test Results view. When exactly one test is currently running,
+     * the output is attributed to that test item so it shows up under the test in the
+     * explorer; otherwise (idle, or several tests running in parallel where attribution
+     * would only be a guess) it is appended to the run as a whole.
+     */
+    public appendProgramOutput(output: string): void {
+        const normalized: string = output.replace(/\r?\n/g, '\r\n');
+        const item: TestItem | undefined = this.runningItems.size === 1
+            ? this.runningItems.values().next().value
+            : undefined;
+        this.testContext.testRun.appendOutput(normalized, undefined, item);
+    }
+
     /**
      * Return a string array which contains the stacktraces that need to be filtered.
      * All the stacktraces which include the element in the return array will be removed.

src/runners/junitRunner/JUnitRunnerResultAnalyzer.ts

@@ -52,8 +52,14 @@ export class JUnitRunnerResultAnalyzer extends RunnerResultAnalyzer {
     public analyzeData(data: string): void {
         const lines: string[] = data.split(/\r?\n/);
         for (const line of lines) {
+            // The socket stream carries only the JUnit runner's control protocol
+            // (`%`-prefixed frames plus stack-trace / expected-actual payloads).
+            // The control frames are noise, and the failure payloads are already
+            // surfaced structurally as TestMessages on the failed items, so nothing
+            // here is echoed to the Test Results output. The user-facing program
+            // output is instead forwarded from the debug session's DAP `output`
+            // events (see BaseRunner).
             this.processData(line);
-            this.testContext.testRun.appendOutput(line + '\r\n');
         }
     }
 
@@ -70,6 +76,7 @@ export class JUnitRunnerResultAnalyzer extends RunnerResultAnalyzer {
             this.setDurationAtStart(this.getCurrentState(item));
             setTestState(this.testContext.testRun, item, this.getCurrentState(item).resultState);
             this.updateParentOnChildStart(item);
+            this.markItemStarted(item);
         } else if (data.startsWith(MessageId.TestEnd)) {
             const item: TestItem | undefined = this.getTestItem(data.substr(MessageId.TestEnd.length));
             if (!item) {
@@ -79,6 +86,7 @@ export class JUnitRunnerResultAnalyzer extends RunnerResultAnalyzer {
             this.calcDurationAtEnd(currentState);
             this.determineResultStateAtEnd(data, currentState);
             setTestState(this.testContext.testRun, item, currentState.resultState, undefined, currentState.duration);
+            this.markItemFinished(item);
             const itemData: ITestItemData | undefined = dataCache.get(item);
             if (itemData?.testLevel === TestLevel.Method) {
                 this.updateParentOnChildComplete(item, currentState.resultState);

src/runners/testngRunner/TestNGRunnerResultAnalyzer.ts

@@ -55,8 +55,6 @@ export class TestNGRunnerResultAnalyzer extends RunnerResultAnalyzer {
     public processData(data: string): void {
         const outputData: ITestNGOutputData = JSON.parse(data) as ITestNGOutputData;
 
-        this.testContext.testRun.appendOutput(this.unescape(data).replace(/\r?\n/g, '\r\n'));
-
         const id: string = `${this.projectName}@${outputData.attributes.name}`;
         if (outputData.name === TEST_START) {
             this.initializeCache();
@@ -68,6 +66,7 @@ export class TestNGRunnerResultAnalyzer extends RunnerResultAnalyzer {
             this.currentTestState = TestResultState.Running;
             this.testContext.testRun.started(item);
             this.updateParentOnChildStart(item);
+            this.markItemStarted(item);
         } else if (outputData.name === TEST_FAIL) {
             const item: TestItem | undefined = this.getTestItem(id);
             if (!item) {
@@ -105,6 +104,7 @@ export class TestNGRunnerResultAnalyzer extends RunnerResultAnalyzer {
             }
             const duration: number = Number.parseInt(outputData.attributes.duration, 10);
             setTestState(this.testContext.testRun, item, this.currentTestState, undefined, duration);
+            this.markItemFinished(item);
             const itemData: ITestItemData | undefined = dataCache.get(item);
             if (itemData?.testLevel === TestLevel.Method) {
                 this.updateParentOnChildComplete(item, this.currentTestState);
@@ -121,15 +121,6 @@ export class TestNGRunnerResultAnalyzer extends RunnerResultAnalyzer {
         return this.currentItem;
     }
 
-    protected unescape(content: string): string {
-        return content.replace(/\\r/gm, '\r')
-            .replace(/\\f/gm, '\f')
-            .replace(/\\n/gm, '\n')
-            .replace(/\\t/gm, '\t')
-            .replace(/\\b/gm, '\b')
-            .replace(/\\"/gm, '"');
-    }
-
     protected initializeCache(): void {
         this.currentTestState = TestResultState.Queued;
         this.currentItem = undefined;