@codingame/monaco-vscode-testing-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/contrib/testing/browser/testingOutputPeek.js

@@ -14,7 +14,7 @@ import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
-import { DisposableStore, Disposable, MutableDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore, Disposable, MutableDisposable, toDisposable, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { count } from 'vscode/vscode/vs/base/common/strings';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
@@ -28,9 +28,9 @@ import { EmbeddedCodeEditorWidget, EmbeddedDiffEditorWidget } from 'vscode/vscod
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { MarkdownRenderer } from 'vscode/vscode/vs/editor/contrib/markdownRenderer/browser/markdownRenderer';
+import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
 import { PeekViewWidget, peekViewTitleForeground, peekViewTitleInfoForeground, IPeekViewService, peekViewResultsBackground } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { FloatingClickMenu } from 'vscode/vscode/vs/platform/actions/browser/floatingMenu';
 import { MenuEntryActionViewItem, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
@@ -50,20 +50,22 @@ import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storag
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { TerminalCapabilityStore } from 'vscode/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore';
 import { formatMessageForTerminal } from 'vscode/vscode/vs/platform/terminal/common/terminalStrings';
+import { editorBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
 import { widgetClose } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { EditorModel } from 'vscode/vscode/vs/workbench/common/editor/editorModel';
 import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
-import { IViewsService, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { DetachedProcessInfo } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/detachedTerminal';
 import { ITerminalService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
 import { getXtermScaledDimensions } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal';
 import { TERMINAL_BACKGROUND_COLOR } from 'vscode/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
 import { getTestItemContextOverlay } from './explorerProjections/testItemContextOverlay.js';
-import { testingStatesToIcons, testingRunIcon, testingDebugIcon, testingCoverage } from './icons.js';
-import { testingPeekBorder, testingPeekHeaderBackground } from './theme.js';
+import { testingStatesToIcons, testingRunIcon, testingDebugIcon, testingCoverageReport } from './icons.js';
+import { testingPeekBorder, testingMessagePeekBorder, testingPeekHeaderBackground, testingPeekMessageHeaderBackground } from './theme.js';
 import { getTestingConfiguration } from '../common/configuration.js';
 import { MutableObservableValue, staticObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
 import { StoredValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/storedValue';
@@ -119,12 +121,12 @@ class TaskSubject {
     }
 }
 class TestOutputSubject {
-    constructor(result, taskIndex, task, test) {
+    constructor(result, taskIndex, test) {
         this.result = result;
         this.taskIndex = taskIndex;
-        this.task = task;
         this.test = test;
         this.outputUri = buildTestUri({ resultId: this.result.id, taskIndex: this.taskIndex, testExtId: this.test.item.extId, type: 1  });
+        this.task = result.tasks[this.taskIndex];
     }
 }
 const equalsSubject = (a, b) => ((a instanceof MessageSubject && b instanceof MessageSubject && a.message === b.message) ||
@@ -185,15 +187,14 @@ let TestingPeekOpener = class TestingPeekOpener extends Disposable {
         if (!candidate) {
             return false;
         }
-        const message = candidate.message;
         this.showPeekFromUri({
             type: 2 ,
-            documentUri: message.location.uri,
+            documentUri: candidate.location.uri,
             taskIndex: candidate.taskId,
             messageIndex: candidate.index,
             resultId: result.id,
             testExtId: test.item.extId,
-        }, undefined, { selection: message.location.range, ...options });
+        }, undefined, { selection: candidate.location.range, selectionRevealType: 3 , ...options });
         return true;
     }
     peekUri(uri, options = {}) {
@@ -368,15 +369,19 @@ let TestingPeekOpener = class TestingPeekOpener extends Disposable {
         return undefined;
     }
     getFailedCandidateMessage(test) {
+        const fallbackLocation = test.item.uri && test.item.range
+            ? { uri: test.item.uri, range: test.item.range }
+            : undefined;
         let best;
         mapFindTestMessage(test, (task, message, messageIndex, taskId) => {
-            if (!isFailedState(task.state) || !message.location) {
+            const location = message.location || fallbackLocation;
+            if (!isFailedState(task.state) || !location) {
                 return;
             }
             if (best && message.type !== 0 ) {
                 return;
             }
-            best = { taskId, index: messageIndex, message };
+            best = { taskId, index: messageIndex, message, location };
         });
         return best;
     }
@@ -568,11 +573,10 @@ let TestingOutputPeekController = TestingOutputPeekController_1 = class TestingO
         }
         if (parts.type === 1 ) {
             const test = result.getStateById(parts.testExtId);
-            const task = result.tasks[parts.taskIndex];
-            if (!test || !task) {
+            if (!test) {
                 return;
             }
-            return ( new TestOutputSubject(result, parts.taskIndex, task, test));
+            return ( new TestOutputSubject(result, parts.taskIndex, test));
         }
         const { testExtId, taskIndex, messageIndex } = parts;
         const test = result?.getStateById(testExtId);
@@ -710,6 +714,7 @@ let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
     static { TestResultsPeek_1 = this; }
     constructor(editor, themeService, peekViewService, testingPeek, contextKeyService, menuService, instantiationService, modelService) {
         super(editor, { showFrame: true, frameWidth: 1, showArrow: true, isResizeable: true, isAccessible: true, className: 'test-output-peek' }, instantiationService);
+        this.themeService = themeService;
         this.testingPeek = testingPeek;
         this.contextKeyService = contextKeyService;
         this.menuService = menuService;
@@ -717,16 +722,18 @@ let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
         this.visibilityChange = this._disposables.add(( new Emitter()));
         this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme, this));
         this._disposables.add(this.onDidClose(() => this.visibilityChange.fire(false)));
-        this.applyTheme(themeService.getColorTheme());
         peekViewService.addExclusiveWidget(editor, this);
     }
-    applyTheme(theme) {
-        const borderColor = theme.getColor(testingPeekBorder) || Color.transparent;
-        const headerBg = theme.getColor(testingPeekHeaderBackground) || Color.transparent;
+    applyTheme() {
+        const theme = this.themeService.getColorTheme();
+        const isError = this.current instanceof MessageSubject && this.current.message.type === 0 ;
+        const borderColor = (isError ? theme.getColor(testingPeekBorder) : theme.getColor(testingMessagePeekBorder)) || Color.transparent;
+        const headerBg = (isError ? theme.getColor(testingPeekHeaderBackground) : theme.getColor(testingPeekMessageHeaderBackground)) || Color.transparent;
+        const editorBg = theme.getColor(editorBackground);
         this.style({
             arrowColor: borderColor,
             frameColor: borderColor,
-            headerBackgroundColor: headerBg,
+            headerBackgroundColor: editorBg && headerBg ? headerBg.makeOpaque(editorBg) : headerBg,
             primaryHeadingColor: theme.getColor(peekViewTitleForeground),
             secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
         });
@@ -771,7 +778,8 @@ let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
             return this.showInPlace(subject);
         }
         this.show(subject.revealLocation.range, TestResultsPeek_1.lastHeightInLines || hintMessagePeekHeight(message));
-        this.editor.revealPositionNearTop(subject.revealLocation.range.getStartPosition(), 0 );
+        const startPosition = subject.revealLocation.range.getStartPosition();
+        this.editor.revealRangeNearTopIfOutsideViewport(Range.fromPositions(startPosition), 0 );
         return this.showInPlace(subject);
     }
     async showInPlace(subject) {
@@ -786,6 +794,7 @@ let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
                 'Test Output'
             )));
         }
+        this.applyTheme();
         await this.content.reveal({ subject: subject, preserveFocus: false });
     }
     _relayout(newHeightInLines) {
@@ -833,6 +842,9 @@ let TestResultsView = class TestResultsView extends ViewPane {
         }
         this.content.reveal({ preserveFocus, subject: ( new TaskSubject(result, 0)) });
     }
+    showMessage(result, test, taskIndex, messageIndex) {
+        this.content.reveal({ preserveFocus: false, subject: ( new MessageSubject(result, test, taskIndex, messageIndex)) });
+    }
     renderBody(container) {
         super.renderBody(container);
         this.content.fillBody(container);
@@ -1113,6 +1125,11 @@ let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
         const testItem = subject instanceof TestOutputSubject ? subject.test.item : subject.test;
         const terminal = await this.updateGenerically({
             subject,
+            noOutputMessage: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'caseNoOutput',
+                'The test case did not report any output.'
+            )),
             getTarget: result => result?.tasks[subject.taskIndex].output,
             *doInitialWrite(output, results) {
                 that.updateCwd(testItem.uri);
@@ -1126,10 +1143,10 @@ let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
                     }
                 }
             },
-            doListenForMoreData: (output, result, { xterm }) => result.onChange(e => {
+            doListenForMoreData: (output, result, write) => result.onChange(e => {
                 if (e.reason === 2  && e.item.item.extId === testItem.extId && e.message.type === 1 ) {
                     for (const chunk of output.getRangeIter(e.message.offset, e.message.length)) {
-                        xterm.write(chunk.buffer);
+                        write(chunk.buffer);
                     }
                 }
             }),
@@ -1141,12 +1158,17 @@ let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
     updateForTaskSubject(subject) {
         return this.updateGenerically({
             subject,
+            noOutputMessage: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'runNoOutput',
+                'The test run did not record any output.'
+            )),
             getTarget: result => result?.tasks[subject.taskIndex],
             doInitialWrite: (task, result) => {
                 this.updateCwd(Iterable.find(result.tests, t => !!t.item.uri)?.item.uri);
                 return task.output.buffers;
             },
-            doListenForMoreData: (task, _result, { xterm }) => task.output.onDidWriteData(e => xterm.write(e.buffer)),
+            doListenForMoreData: (task, _result, write) => task.output.onDidWriteData(e => write(e.buffer)),
         });
     }
     async updateGenerically(opts) {
@@ -1174,13 +1196,21 @@ let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
             )));
         }
         this.attachTerminalToDom(terminal);
-        this.outputDataListener.value = result instanceof LiveTestResult ? opts.doListenForMoreData(target, result, terminal) : undefined;
+        this.outputDataListener.clear();
+        if (result instanceof LiveTestResult && !result.completedAt) {
+            const l1 = result.onComplete(() => {
+                if (!didWriteData) {
+                    this.writeNotice(terminal, opts.noOutputMessage);
+                }
+            });
+            const l2 = opts.doListenForMoreData(target, result, data => {
+                terminal.xterm.write(data);
+                didWriteData ||= data.byteLength > 0;
+            });
+            this.outputDataListener.value = combinedDisposable(l1, l2);
+        }
         if (!this.outputDataListener.value && !didWriteData) {
-            this.writeNotice(terminal, ( localizeWithPath(
-                'vs/workbench/contrib/testing/browser/testingOutputPeek',
-                'runNoOutput',
-                'The test run did not record any output.'
-            )));
+            this.writeNotice(terminal, opts.noOutputMessage);
         }
         if (pendingWrites.value > 0) {
             await ( new Promise(resolve => {
@@ -1320,7 +1350,7 @@ class CoverageElement {
         return this.isOpen ? closeCoverageLabel : openCoverageLabel;
     }
     get icon() {
-        return this.isOpen ? widgetClose : testingCoverage;
+        return this.isOpen ? widgetClose : testingCoverageReport;
     }
     get isOpen() {
         return this.coverageService.selected.get()?.fromTaskId === this.task.id;
@@ -1354,11 +1384,10 @@ class TestCaseElement {
         return testingStatesToIcons.get(this.state);
     }
     get outputSubject() {
-        return ( new TestOutputSubject(this.results, this.taskIndex, this.task, this.test));
+        return ( new TestOutputSubject(this.results, this.taskIndex, this.test));
     }
-    constructor(results, task, test, taskIndex) {
+    constructor(results, test, taskIndex) {
         this.results = results;
-        this.task = task;
         this.test = test;
         this.taskIndex = taskIndex;
         this.type = 'test';
@@ -1484,7 +1513,7 @@ let OutputPeekTree = class OutputPeekTree extends Disposable {
             const { results, index, itemsCache, task } = taskElem;
             const tests = Iterable.filter(results.tests, test => test.tasks[index].state >= 2  || test.tasks[index].messages.length > 0);
             let result = ( Iterable.map(tests, test => ({
-                element: itemsCache.getOrCreate(test, () => ( new TestCaseElement(results, task, test, index))),
+                element: itemsCache.getOrCreate(test, () => ( new TestCaseElement(results, test, index))),
                 incompressible: true,
                 children: getTestChildren(results, test, index),
             })));
@@ -1643,6 +1672,11 @@ let OutputPeekTree = class OutputPeekTree extends Disposable {
                     e.element.messageIndex
                 )));
             }
+            else if (e.element instanceof TestCaseElement) {
+                const t = e.element;
+                const message = mapFindTestMessage(e.element.test, (_t, _m, mesasgeIndex, taskIndex) => ( new MessageSubject(t.results, t.test, taskIndex, mesasgeIndex)));
+                this.requestReveal.fire(message || ( new TestOutputSubject(t.results, 0, t.test)));
+            }
             else if (e.element instanceof CoverageElement) {
                 const task = e.element.task;
                 if (e.element.isOpen) {
@@ -1914,11 +1948,11 @@ class GoToNextMessageAction extends Action2 {
         super({
             id: GoToNextMessageAction.ID,
             f1: true,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/testing/browser/testingOutputPeek',
                 'testing.goToNextMessage',
-                "Go to Next Test Failure"
-            )), original: 'Go to Next Test Failure' },
+                'Go to Next Test Failure'
+            )),
             icon: Codicon.arrowDown,
             category: Categories.Test,
             keybinding: {
@@ -1949,11 +1983,11 @@ class GoToPreviousMessageAction extends Action2 {
         super({
             id: GoToPreviousMessageAction.ID,
             f1: true,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/testing/browser/testingOutputPeek',
                 'testing.goToPreviousMessage',
-                "Go to Previous Test Failure"
-            )), original: 'Go to Previous Test Failure' },
+                'Go to Previous Test Failure'
+            )),
             icon: Codicon.arrowUp,
             category: Categories.Test,
             keybinding: {
@@ -1984,11 +2018,11 @@ class OpenMessageInEditorAction extends Action2 {
         super({
             id: OpenMessageInEditorAction.ID,
             f1: false,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/testing/browser/testingOutputPeek',
                 'testing.openMessageInEditor',
-                "Open in Editor"
-            )), original: 'Open in Editor' },
+                'Open in Editor'
+            )),
             icon: Codicon.goToFile,
             category: Categories.Test,
             menu: [{ id: MenuId.TestPeekTitle }],
@@ -2004,11 +2038,11 @@ class ToggleTestingPeekHistory extends Action2 {
         super({
             id: ToggleTestingPeekHistory.ID,
             f1: true,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/testing/browser/testingOutputPeek',
                 'testing.toggleTestingPeekHistory',
-                "Toggle Test History in Peek"
-            )), original: 'Toggle Test History in Peek' },
+                'Toggle Test History in Peek'
+            )),
             icon: Codicon.history,
             category: Categories.Test,
             menu: [{

package/vscode/src/vs/workbench/contrib/testing/browser/testingProgressUiService.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { getTestingConfiguration } from '../common/configuration.js';
 import { isFailedState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingStates';
 import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';

package/vscode/src/vs/workbench/contrib/testing/browser/theme.js

@@ -1,6 +1,7 @@
 import { Color, RGBA } from 'vscode/vscode/vs/base/common/color';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerColor, editorErrorForeground, contrastBorder, transparent, editorForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import { registerColor, editorErrorForeground, contrastBorder, editorInfoForeground, transparent, diffInserted, chartsGreen, opaque, diffRemoved, editorBackground, chartsRed, badgeBackground, badgeForeground, editorForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import { registerThemingParticipant } from 'vscode/vscode/vs/platform/theme/common/themeService';
 
 const testingColorIconFailed = registerColor('testing.iconFailed', {
     dark: '#f14c4c',
@@ -82,6 +83,16 @@ const testingPeekBorder = registerColor('testing.peekBorder', {
     'testing.peekBorder',
     'Color of the peek view borders and arrow.'
 )));
+const testingMessagePeekBorder = registerColor('testing.messagePeekBorder', {
+    dark: editorInfoForeground,
+    light: editorInfoForeground,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.messagePeekBorder',
+    'Color of the peek view borders and arrow when peeking a logged message.'
+)));
 const testingPeekHeaderBackground = registerColor('testing.peekHeaderBackground', {
     dark: ( transparent(editorErrorForeground, 0.1)),
     light: ( transparent(editorErrorForeground, 0.1)),
@@ -92,6 +103,106 @@ const testingPeekHeaderBackground = registerColor('testing.peekHeaderBackground'
     'testing.peekBorder',
     'Color of the peek view borders and arrow.'
 )));
+const testingPeekMessageHeaderBackground = registerColor('testing.messagePeekHeaderBackground', {
+    dark: ( transparent(editorInfoForeground, 0.1)),
+    light: ( transparent(editorInfoForeground, 0.1)),
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.messagePeekHeaderBackground',
+    'Color of the peek view borders and arrow when peeking a logged message.'
+)));
+const testingCoveredBackground = registerColor('testing.coveredBackground', {
+    dark: diffInserted,
+    light: diffInserted,
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.coveredBackground',
+    'Background color of text that was covered.'
+)));
+const testingCoveredBorder = registerColor('testing.coveredBorder', {
+    dark: ( transparent(testingCoveredBackground, 0.75)),
+    light: ( transparent(testingCoveredBackground, 0.75)),
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.coveredBorder',
+    'Border color of text that was covered.'
+)));
+registerColor('testing.coveredGutterBackground', {
+    dark: ( transparent(diffInserted, 0.6)),
+    light: ( transparent(diffInserted, 0.6)),
+    hcDark: chartsGreen,
+    hcLight: chartsGreen
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.coveredGutterBackground',
+    'Gutter color of regions where code was covered.'
+)));
+registerColor('testing.uncoveredBranchBackground', {
+    dark: opaque(( transparent(diffRemoved, 2)), editorBackground),
+    light: opaque(( transparent(diffRemoved, 2)), editorBackground),
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.uncoveredBranchBackground',
+    'Background of the widget shown for an uncovered branch.'
+)));
+const testingUncoveredBackground = registerColor('testing.uncoveredBackground', {
+    dark: diffRemoved,
+    light: diffRemoved,
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.uncoveredBackground',
+    'Background color of text that was not covered.'
+)));
+const testingUncoveredBorder = registerColor('testing.uncoveredBorder', {
+    dark: ( transparent(testingUncoveredBackground, 0.75)),
+    light: ( transparent(testingUncoveredBackground, 0.75)),
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.uncoveredBorder',
+    'Border color of text that was not covered.'
+)));
+registerColor('testing.uncoveredGutterBackground', {
+    dark: ( transparent(diffRemoved, 1.5)),
+    light: ( transparent(diffRemoved, 1.5)),
+    hcDark: chartsRed,
+    hcLight: chartsRed
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.uncoveredGutterBackground',
+    'Gutter color of regions where code not covered.'
+)));
+registerColor('testing.coverCountBadgeBackground', {
+    dark: badgeBackground,
+    light: badgeBackground,
+    hcDark: badgeBackground,
+    hcLight: badgeBackground
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.coverCountBadgeBackground',
+    'Background for the badge indicating execution count'
+)));
+registerColor('testing.coverCountBadgeForeground', {
+    dark: badgeForeground,
+    light: badgeForeground,
+    hcDark: badgeForeground,
+    hcLight: badgeForeground
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.coverCountBadgeForeground',
+    'Foreground for the badge indicating execution count'
+)));
 ({
     [0 ]: {
         decorationForeground: registerColor('testing.message.error.decorationForeground', { dark: editorErrorForeground, light: editorErrorForeground, hcDark: editorForeground, hcLight: editorForeground }, ( localizeWithPath(
@@ -126,5 +237,23 @@ const testStatesToIconColors = {
     [0 ]: testingColorIconUnset,
     [5 ]: testingColorIconSkipped,
 };
+registerThemingParticipant((theme, collector) => {
+    const editorBg = theme.getColor(editorBackground);
+    const missBadgeBackground = editorBg && theme.getColor(testingUncoveredBackground)?.transparent(2).makeOpaque(editorBg);
+    collector.addRule(`
+	.coverage-deco-inline.coverage-deco-hit.coverage-deco-hovered {
+		background: ${theme.getColor(testingCoveredBackground)?.transparent(1.3)};
+		outline-color: ${theme.getColor(testingCoveredBorder)?.transparent(2)};
+	}
+	.coverage-deco-inline.coverage-deco-miss.coverage-deco-hovered {
+		background: ${theme.getColor(testingUncoveredBackground)?.transparent(1.3)};
+		outline-color: ${theme.getColor(testingUncoveredBorder)?.transparent(2)};
+	}
+	.coverage-deco-branch-miss-indicator::before {
+		border-color: ${missBadgeBackground?.transparent(1.3)};
+		background-color: ${missBadgeBackground};
+	}
+	`);
+});
 
-export { testStatesToIconColors, testingColorIconErrored, testingColorIconFailed, testingColorIconPassed, testingColorIconQueued, testingColorIconSkipped, testingColorIconUnset, testingColorRunAction, testingPeekBorder, testingPeekHeaderBackground };
+export { testStatesToIconColors, testingColorIconErrored, testingColorIconFailed, testingColorIconPassed, testingColorIconQueued, testingColorIconSkipped, testingColorIconUnset, testingColorRunAction, testingCoveredBackground, testingCoveredBorder, testingMessagePeekBorder, testingPeekBorder, testingPeekHeaderBackground, testingPeekMessageHeaderBackground, testingUncoveredBackground, testingUncoveredBorder };

package/vscode/src/vs/workbench/contrib/testing/common/configuration.js

@@ -1,4 +1,5 @@
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
 
 const testingConfiguration = {
     id: 'testing',
@@ -122,6 +123,7 @@ const testingConfiguration = {
             enum: [
                 "run" ,
                 "debug" ,
+                "runWithCoverage" ,
                 "contextMenu" ,
             ],
             enumDescriptions: [
@@ -135,6 +137,11 @@ const testingConfiguration = {
                     'testing.defaultGutterClickAction.debug',
                     'Debug the test.'
                 )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.defaultGutterClickAction.coverage',
+                    'Run the test with coverage.'
+                )),
                 ( localizeWithPath(
                     'vs/workbench/contrib/testing/common/configuration',
                     'testing.defaultGutterClickAction.contextMenu',
@@ -245,8 +252,22 @@ const testingConfiguration = {
                 )),
             ],
         },
+        ["testing.coverageBarThresholds" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.coverageBarThresholds',
+                "Configures the colors used for percentages in test coverage bars."
+            )),
+            default: { red: 0, yellow: 60, green: 90 },
+            properties: {
+                red: { type: 'number', minimum: 0, maximum: 100, default: 0 },
+                yellow: { type: 'number', minimum: 0, maximum: 100, default: 60 },
+                green: { type: 'number', minimum: 0, maximum: 100, default: 90 },
+            },
+        },
     }
 };
 const getTestingConfiguration = (config, key) => config.getValue(key);
+const observeTestingConfiguration = (config, key) => observableFromEvent(config.onDidChangeConfiguration, () => getTestingConfiguration(config, key));
 
-export { getTestingConfiguration, testingConfiguration };
+export { getTestingConfiguration, observeTestingConfiguration, testingConfiguration };

package/vscode/src/vs/workbench/contrib/testing/common/mainThreadTestCollection.js

@@ -1,7 +1,7 @@
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { AbstractIncrementalTestCollection } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { AbstractIncrementalTestCollection } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 
 class MainThreadTestCollection extends AbstractIncrementalTestCollection {
     get busyProviders() {
@@ -16,8 +16,8 @@ class MainThreadTestCollection extends AbstractIncrementalTestCollection {
     get rootIds() {
         return ( Iterable.map(( this.roots.values()), r => r.item.extId));
     }
-    constructor(expandActual) {
-        super();
+    constructor(uriIdentityService, expandActual) {
+        super(uriIdentityService);
         this.expandActual = expandActual;
         this.testsByUrl = ( new ResourceMap());
         this.busyProvidersChangeEmitter = ( new Emitter());

package/vscode/src/vs/workbench/contrib/testing/common/testServiceImpl.js

@@ -22,10 +22,12 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { getTestingConfiguration } from './configuration.js';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
 
 let TestService = class TestService extends Disposable {
-    constructor(contextKeyService, instantiationService, storage, editorService, testProfiles, notificationService, configurationService, testResults, workspaceTrustRequestService) {
+    constructor(contextKeyService, instantiationService, uriIdentityService, storage, editorService, testProfiles, notificationService, configurationService, testResults, workspaceTrustRequestService) {
         super();
+        this.uriIdentityService = uriIdentityService;
         this.storage = storage;
         this.editorService = editorService;
         this.testProfiles = testProfiles;
@@ -42,7 +44,7 @@ let TestService = class TestService extends Disposable {
         this.onWillProcessDiff = this.willProcessDiffEmitter.event;
         this.onDidProcessDiff = this.didProcessDiffEmitter.event;
         this.onDidCancelTestRun = this.cancelExtensionTestRunEmitter.event;
-        this.collection = ( new MainThreadTestCollection(this.expandTest.bind(this)));
+        this.collection = ( new MainThreadTestCollection(this.uriIdentityService, this.expandTest.bind(this)));
         this.showInlineOutput = MutableObservableValue.stored(this._register(( new StoredValue({
             key: 'inlineTestOutputVisible',
             scope: 1 ,
@@ -281,13 +283,14 @@ let TestService = class TestService extends Disposable {
 TestService = ( __decorate([
     ( __param(0, IContextKeyService)),
     ( __param(1, IInstantiationService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, ITestProfileService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, ITestResultService)),
-    ( __param(8, IWorkspaceTrustRequestService))
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, ITestProfileService)),
+    ( __param(6, INotificationService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, ITestResultService)),
+    ( __param(9, IWorkspaceTrustRequestService))
 ], TestService));
 
 export { TestService };