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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-testing-service-override",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,13 +18,13 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.0.3",
-    "@xterm/addon-canvas": "0.6.0-beta.14",
-    "@xterm/addon-image": "0.7.0-beta.12",
-    "@xterm/addon-search": "0.14.0-beta.14",
-    "@xterm/addon-serialize": "0.12.0-beta.14",
-    "@xterm/addon-unicode11": "0.7.0-beta.14",
-    "@xterm/addon-webgl": "0.17.0-beta.14",
+    "vscode": "npm:@codingame/monaco-vscode-api@2.1.0",
+    "@xterm/addon-canvas": "0.6.0-beta.20",
+    "@xterm/addon-image": "0.7.0-beta.18",
+    "@xterm/addon-search": "0.14.0-beta.20",
+    "@xterm/addon-serialize": "0.12.0-beta.20",
+    "@xterm/addon-unicode11": "0.7.0-beta.20",
+    "@xterm/addon-webgl": "0.17.0-beta.20",
     "vscode-marked": "npm:marked@=3.0.2"
   }
 }

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

@@ -0,0 +1,567 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $, append, clearNode } from 'vscode/vscode/vs/base/browser/dom';
+import { HoverWidget } from 'vscode/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { mapFindFirst } from 'vscode/vscode/vs/base/common/arraysFind';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
+import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
+import { HoverOperation } from 'vscode/vscode/vs/editor/contrib/hover/browser/hoverOperation';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { testingCoverageMissingBranch } from './icons.js';
+import { ITestCoverageService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverageService';
+import { TestingContextKeys } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContextKeys';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+
+var CodeCoverageDecorations_1, LineHoverWidget_1;
+const MAX_HOVERED_LINES = 30;
+const CLASS_HIT = 'coverage-deco-hit';
+const CLASS_MISS = 'coverage-deco-miss';
+const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+    'testing.toggleInlineCoverage',
+    'Toggle Inline Coverage'
+));
+const TOGGLE_INLINE_COMMAND_ID = 'testing.toggleInlineCoverage';
+const BRANCH_MISS_INDICATOR_CHARS = 4;
+let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
+    static { CodeCoverageDecorations_1 = this; }
+    static { this.showInline = observableValue('inlineCoverage', false); }
+    static { this.fileCoverageDecorations = ( new WeakMap()); }
+    constructor(editor, instantiationService, coverage, log) {
+        super();
+        this.editor = editor;
+        this.log = log;
+        this.displayedStore = this._register(( new DisposableStore()));
+        this.hoveredStore = this._register(( new DisposableStore()));
+        this.decorationIds = ( new Map());
+        this.lineHoverWidget = ( new Lazy(
+            () => this._register(instantiationService.createInstance(LineHoverWidget, this.editor))
+        ));
+        const modelObs = observableFromEvent(editor.onDidChangeModel, () => editor.getModel());
+        const configObs = observableFromEvent(editor.onDidChangeConfiguration, i => i);
+        const fileCoverage = derived(reader => {
+            const report = coverage.selected.read(reader);
+            if (!report) {
+                return;
+            }
+            const model = modelObs.read(reader);
+            if (!model) {
+                return;
+            }
+            return report.getUri(model.uri);
+        });
+        this._register(autorun(reader => {
+            const c = fileCoverage.read(reader);
+            if (c) {
+                this.apply(editor.getModel(), c, CodeCoverageDecorations_1.showInline.read(reader));
+            }
+            else {
+                this.clear();
+            }
+        }));
+        this._register(autorun(reader => {
+            const c = fileCoverage.read(reader);
+            if (c) {
+                const evt = configObs.read(reader);
+                if (evt?.hasChanged(66 ) !== false) {
+                    this.updateEditorStyles();
+                }
+            }
+        }));
+        this._register(editor.onMouseMove(e => {
+            const model = editor.getModel();
+            if (e.target.type === 3  && model) {
+                this.hoverLineNumber(editor.getModel(), e.target.position.lineNumber);
+            }
+            else if (this.lineHoverWidget.hasValue && this.lineHoverWidget.value.getDomNode().contains(e.target.element)) ;
+            else if (CodeCoverageDecorations_1.showInline.get() && e.target.type === 6  && model) {
+                this.hoverInlineDecoration(model, e.target.position);
+            }
+            else {
+                this.hoveredStore.clear();
+            }
+        }));
+        this._register(editor.onWillChangeModel(() => {
+            const model = editor.getModel();
+            if (!this.details || !model) {
+                return;
+            }
+            for (const decoration of model.getAllDecorations()) {
+                const own = this.decorationIds.get(decoration.id);
+                if (own) {
+                    own.detail.range = decoration.range;
+                }
+            }
+        }));
+    }
+    updateEditorStyles() {
+        const lineHeight = this.editor.getOption(66 );
+        const { style } = this.editor.getContainerDomNode();
+        style.setProperty('--vscode-testing-coverage-lineHeight', `${lineHeight}px`);
+    }
+    hoverInlineDecoration(model, position) {
+        const allDecorations = model.getDecorationsInRange(Range.fromPositions(position));
+        const decoration = mapFindFirst(allDecorations, ({ id }) => ( this.decorationIds.has(id)) ? { id, deco: this.decorationIds.get(id) } : undefined);
+        if (decoration === this.hoveredSubject) {
+            return;
+        }
+        this.hoveredStore.clear();
+        this.hoveredSubject = decoration;
+        if (!decoration) {
+            return;
+        }
+        model.changeDecorations(e => {
+            e.changeDecorationOptions(decoration.id, {
+                ...decoration.deco.options,
+                className: `${decoration.deco.options.className} coverage-deco-hovered`,
+            });
+        });
+        this.hoveredStore.add(toDisposable(() => {
+            this.hoveredSubject = undefined;
+            model.changeDecorations(e => {
+                e.changeDecorationOptions(decoration.id, decoration.deco.options);
+            });
+        }));
+    }
+    hoverLineNumber(model, lineNumber) {
+        if (lineNumber === this.hoveredSubject || !this.details) {
+            return;
+        }
+        this.hoveredStore.clear();
+        this.hoveredSubject = lineNumber;
+        const todo = [{ line: lineNumber, dir: 0 }];
+        const toEnable = ( new Set());
+        const inlineEnabled = CodeCoverageDecorations_1.showInline.get();
+        if (!CodeCoverageDecorations_1.showInline.get()) {
+            for (let i = 0; i < todo.length && i < MAX_HOVERED_LINES; i++) {
+                const { line, dir } = todo[i];
+                let found = false;
+                for (const decoration of model.getLineDecorations(line)) {
+                    if (( this.decorationIds.has(decoration.id))) {
+                        toEnable.add(decoration.id);
+                        found = true;
+                    }
+                }
+                if (found) {
+                    if (dir <= 0) {
+                        todo.push({ line: line - 1, dir: -1 });
+                    }
+                    if (dir >= 0) {
+                        todo.push({ line: line + 1, dir: 1 });
+                    }
+                }
+            }
+            model.changeDecorations(e => {
+                for (const id of toEnable) {
+                    const { applyHoverOptions, options } = this.decorationIds.get(id);
+                    const dup = { ...options };
+                    applyHoverOptions(dup);
+                    e.changeDecorationOptions(id, dup);
+                }
+            });
+        }
+        if (toEnable.size || inlineEnabled) {
+            this.lineHoverWidget.value.startShowingAt(lineNumber);
+        }
+        this.hoveredStore.add(this.editor.onMouseLeave(() => {
+            this.hoveredStore.clear();
+        }));
+        this.hoveredStore.add(toDisposable(() => {
+            this.lineHoverWidget.value.hide();
+            this.hoveredSubject = undefined;
+            model.changeDecorations(e => {
+                for (const id of toEnable) {
+                    const deco = this.decorationIds.get(id);
+                    if (deco) {
+                        e.changeDecorationOptions(id, deco.options);
+                    }
+                }
+            });
+        }));
+    }
+    async apply(model, coverage, showInlineByDefault) {
+        const details = this.details = await this.loadDetails(coverage, model);
+        if (!details) {
+            return this.clear();
+        }
+        this.displayedStore.clear();
+        model.changeDecorations(e => {
+            for (const detailRange of details.ranges) {
+                const { metadata: { detail, description }, range, primary } = detailRange;
+                if (detail.type === 2 ) {
+                    const hits = detail.detail.branches[detail.branch].count;
+                    const cls = hits ? CLASS_HIT : CLASS_MISS;
+                    const showMissIndicator = !hits && range.isEmpty() && ( detail.detail.branches.some(b => b.count));
+                    const options = {
+                        showIfCollapsed: showMissIndicator,
+                        description: 'coverage-gutter',
+                        lineNumberClassName: `coverage-deco-gutter ${cls}`,
+                    };
+                    const applyHoverOptions = (target) => {
+                        target.hoverMessage = description;
+                        if (showMissIndicator) {
+                            target.after = {
+                                content: '\xa0'.repeat(BRANCH_MISS_INDICATOR_CHARS),
+                                inlineClassName: `coverage-deco-branch-miss-indicator ${ThemeIcon.asClassName(testingCoverageMissingBranch)}`,
+                                inlineClassNameAffectsLetterSpacing: true,
+                                cursorStops: InjectedTextCursorStops.None,
+                            };
+                        }
+                        else {
+                            target.className = `coverage-deco-inline ${cls}`;
+                            if (primary) {
+                                target.before = countBadge(hits);
+                            }
+                        }
+                    };
+                    if (showInlineByDefault) {
+                        applyHoverOptions(options);
+                    }
+                    this.decorationIds.set(e.addDecoration(range, options), { options, applyHoverOptions, detail: detailRange });
+                }
+                else if (detail.type === 1 ) {
+                    const cls = detail.count ? CLASS_HIT : CLASS_MISS;
+                    const options = {
+                        showIfCollapsed: false,
+                        description: 'coverage-inline',
+                        lineNumberClassName: `coverage-deco-gutter ${cls}`,
+                    };
+                    const applyHoverOptions = (target) => {
+                        target.className = `coverage-deco-inline ${cls}`;
+                        target.hoverMessage = description;
+                        if (primary) {
+                            target.before = countBadge(detail.count);
+                        }
+                    };
+                    if (showInlineByDefault) {
+                        applyHoverOptions(options);
+                    }
+                    this.decorationIds.set(e.addDecoration(range, options), { options, applyHoverOptions, detail: detailRange });
+                }
+            }
+        });
+        this.displayedStore.add(toDisposable(() => {
+            model.changeDecorations(e => {
+                for (const decoration of ( this.decorationIds.keys())) {
+                    e.removeDecoration(decoration);
+                }
+                this.decorationIds.clear();
+            });
+        }));
+    }
+    clear() {
+        this.loadingCancellation?.cancel();
+        this.loadingCancellation = undefined;
+        this.displayedStore.clear();
+        this.hoveredStore.clear();
+    }
+    async loadDetails(coverage, textModel) {
+        const existing = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage);
+        if (existing) {
+            return existing;
+        }
+        const cts = this.loadingCancellation = ( new CancellationTokenSource());
+        this.displayedStore.add(this.loadingCancellation);
+        try {
+            const details = await coverage.details(this.loadingCancellation.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            const model = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage)
+                || ( new CoverageDetailsModel(details, textModel));
+            CodeCoverageDecorations_1.fileCoverageDecorations.set(coverage, model);
+            return model;
+        }
+        catch (e) {
+            this.log.error('Error loading coverage details', e);
+        }
+        return undefined;
+    }
+};
+CodeCoverageDecorations = CodeCoverageDecorations_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITestCoverageService)),
+    ( __param(3, ILogService))
+], CodeCoverageDecorations));
+const countBadge = (count) => {
+    if (count === 0) {
+        return undefined;
+    }
+    return {
+        content: `${count > 99 ? '99+' : count}x`,
+        cursorStops: InjectedTextCursorStops.None,
+        inlineClassName: `coverage-deco-inline-count`,
+        inlineClassNameAffectsLetterSpacing: true,
+    };
+};
+class CoverageDetailsModel {
+    constructor(details, textModel) {
+        this.details = details;
+        this.ranges = [];
+        const detailRanges = ( details.map(detail => ({
+            range: tidyLocation(detail.location),
+            primary: true,
+            metadata: { detail, description: this.describe(detail, textModel) }
+        })));
+        for (const { range, metadata: { detail } } of detailRanges) {
+            if (detail.type === 1  && detail.branches) {
+                for (let i = 0; i < detail.branches.length; i++) {
+                    const branch = { type: 2 , branch: i, detail };
+                    detailRanges.push({
+                        range: tidyLocation(detail.branches[i].location || Range.fromPositions(range.getEndPosition())),
+                        primary: true,
+                        metadata: {
+                            detail: branch,
+                            description: this.describe(branch, textModel),
+                        },
+                    });
+                }
+            }
+        }
+        detailRanges.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range) || a.metadata.detail.type - b.metadata.detail.type);
+        const stack = [];
+        const result = this.ranges = [];
+        const pop = () => {
+            const next = stack.pop();
+            const prev = stack[stack.length - 1];
+            if (prev) {
+                prev.range = prev.range.setStartPosition(next.range.endLineNumber, next.range.endColumn);
+            }
+            result.push(next);
+        };
+        for (const item of detailRanges) {
+            const start = item.range.getStartPosition();
+            while (stack[stack.length - 1]?.range.containsPosition(start) === false) {
+                pop();
+            }
+            if (item.range.isEmpty()) {
+                result.push(item);
+                continue;
+            }
+            const prev = stack[stack.length - 1];
+            if (prev) {
+                const primary = prev.primary;
+                const si = prev.range.setEndPosition(start.lineNumber, start.column);
+                prev.range = prev.range.setStartPosition(item.range.endLineNumber, item.range.endColumn);
+                prev.primary = false;
+                if (prev.range.isEmpty()) {
+                    stack.pop();
+                }
+                result.push({ range: si, primary, metadata: prev.metadata });
+            }
+            stack.push(item);
+        }
+        while (stack.length) {
+            pop();
+        }
+    }
+    describe(detail, model) {
+        if (detail.type === 0 ) {
+            return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                'coverage.fnExecutedCount',
+                'Function `{0}` was executed {1} time(s).',
+                detail.name,
+                detail.count
+            )));
+        }
+        else if (detail.type === 1 ) {
+            const text = wrapName(model.getValueInRange(tidyLocation(detail.location)).trim() || `<empty statement>`);
+            const str = ( new MarkdownString());
+            if (detail.branches?.length) {
+                const covered = detail.branches.filter(b => b.count > 0).length;
+                str.appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                    'coverage.branches',
+                    '{0} of {1} of branches in {2} were covered.',
+                    covered,
+                    detail.branches.length,
+                    text
+                )));
+            }
+            else {
+                str.appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                    'coverage.codeExecutedCount',
+                    '{0} was executed {1} time(s).',
+                    text,
+                    detail.count
+                )));
+            }
+            return str;
+        }
+        else if (detail.type === 2 ) {
+            const text = wrapName(model.getValueInRange(tidyLocation(detail.detail.location)).trim() || `<empty statement>`);
+            const { count, label } = detail.detail.branches[detail.branch];
+            const label2 = label ? wrapInBackticks(label) : `#${detail.branch + 1}`;
+            if (count === 0) {
+                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                    'coverage.branchNotCovered',
+                    'Branch {0} in {1} was not covered.',
+                    label2,
+                    text
+                )));
+            }
+            else {
+                return ( new MarkdownString()).appendMarkdown(( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                    'coverage.branchCovered',
+                    'Branch {0} in {1} was executed {2} time(s).',
+                    label2,
+                    text,
+                    count
+                )));
+            }
+        }
+        return undefined;
+    }
+}
+function tidyLocation(location) {
+    if (location instanceof Position) {
+        return Range.fromPositions(location, ( new Position(location.lineNumber, 0x7FFFFFFF)));
+    }
+    return location;
+}
+let LineHoverComputer = class LineHoverComputer {
+    constructor(keybindingService) {
+        this.keybindingService = keybindingService;
+        this.line = -1;
+    }
+    computeSync() {
+        const strs = [];
+        const s = ( new MarkdownString()).appendMarkdown(`[${TOGGLE_INLINE_COMMAND_TEXT}](command:${TOGGLE_INLINE_COMMAND_ID})`);
+        s.isTrusted = true;
+        const binding = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
+        if (binding) {
+            s.appendText(` (${binding.getLabel()})`);
+        }
+        strs.push(s);
+        return strs;
+    }
+};
+LineHoverComputer = ( __decorate([
+    ( __param(0, IKeybindingService))
+], LineHoverComputer));
+function wrapInBackticks(str) {
+    return '`' + str.replace(/[\n\r`]/g, '') + '`';
+}
+function wrapName(functionNameOrCode) {
+    if (functionNameOrCode.length > 50) {
+        functionNameOrCode = functionNameOrCode.slice(0, 40) + '...';
+    }
+    return wrapInBackticks(functionNameOrCode);
+}
+let LineHoverWidget = class LineHoverWidget extends Disposable {
+    static { LineHoverWidget_1 = this; }
+    static { this.ID = 'editor.contrib.testingCoverageLineHoverWidget'; }
+    constructor(editor, instantiationService) {
+        super();
+        this.editor = editor;
+        this.hover = this._register(( new HoverWidget()));
+        this.renderDisposables = this._register(( new DisposableStore()));
+        this.computer = instantiationService.createInstance(LineHoverComputer);
+        this.markdownRenderer = this._register(instantiationService.createInstance(MarkdownRenderer, { editor: this.editor }));
+        this.hoverOperation = this._register(( new HoverOperation(this.editor, this.computer)));
+        this.hover.containerDomNode.classList.add('hidden');
+        this.hoverOperation.onResult(result => {
+            if (result.value.length) {
+                this.render(result.value);
+            }
+            else {
+                this.hide();
+            }
+        });
+        this.editor.addOverlayWidget(this);
+    }
+    getId() {
+        return LineHoverWidget_1.ID;
+    }
+    getDomNode() {
+        return this.hover.containerDomNode;
+    }
+    getPosition() {
+        return null;
+    }
+    dispose() {
+        this.editor.removeOverlayWidget(this);
+        super.dispose();
+    }
+    startShowingAt(lineNumber) {
+        this.hide();
+        const textModel = this.editor.getModel();
+        if (!textModel) {
+            return;
+        }
+        this.computer.line = lineNumber;
+        this.hoverOperation.start(0 );
+    }
+    hide() {
+        this.hoverOperation.cancel();
+        this.hover.containerDomNode.classList.add('hidden');
+    }
+    render(elements) {
+        const { hover: h, editor: editor } = this;
+        const fragment = document.createDocumentFragment();
+        for (const msg of elements) {
+            const markdownHoverElement = $('div.hover-row.markdown-hover');
+            const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
+            const renderedContents = this.renderDisposables.add(this.markdownRenderer.render(msg));
+            hoverContentsElement.appendChild(renderedContents.element);
+            fragment.appendChild(markdownHoverElement);
+        }
+        clearNode(h.contentsDomNode);
+        h.contentsDomNode.appendChild(fragment);
+        h.containerDomNode.classList.remove('hidden');
+        const editorLayout = editor.getLayoutInfo();
+        const topForLineNumber = editor.getTopForLineNumber(this.computer.line);
+        const editorScrollTop = editor.getScrollTop();
+        const lineHeight = editor.getOption(66 );
+        const nodeHeight = h.containerDomNode.clientHeight;
+        const top = topForLineNumber - editorScrollTop - ((nodeHeight - lineHeight) / 2);
+        const left = editorLayout.lineNumbersLeft + editorLayout.lineNumbersWidth;
+        h.containerDomNode.style.left = `${left}px`;
+        h.containerDomNode.style.top = `${Math.max(Math.round(top), 0)}px`;
+    }
+};
+LineHoverWidget = LineHoverWidget_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], LineHoverWidget));
+registerAction2(class ToggleInlineCoverage extends Action2 {
+    constructor() {
+        super({
+            id: TOGGLE_INLINE_COMMAND_ID,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/codeCoverageDecorations',
+                'coverage.toggleInline',
+                "Toggle Inline Coverage"
+            )), original: 'Toggle Inline Coverage' },
+            category: Categories.Test,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 1024  | 39 ),
+            },
+            precondition: TestingContextKeys.isTestCoverageOpen,
+        });
+    }
+    run() {
+        CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined);
+    }
+});
+
+export { CodeCoverageDecorations, CoverageDetailsModel };

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

@@ -40,6 +40,16 @@ const testingDebugIcon = registerIcon('testing-debug-icon', Codicon.debugAltSmal
     'testingDebugIcon',
     'Icon of the "debug test" action.'
 )));
+const testingCoverageIcon = registerIcon('testing-coverage-icon', Codicon.heartFilled, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/icons',
+    'testingCoverageIcon',
+    'Icon of the "run test with coverage" action.'
+)));
+const testingCoverageAllIcon = registerIcon('testing-coverage-all-icon', Codicon.heartFilled, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/icons',
+    'testingRunAllWithCoverageIcon',
+    'Icon of the "run all tests with coverage" action.'
+)));
 const testingCancelIcon = registerIcon('testing-cancel-icon', Codicon.debugStop, ( localizeWithPath(
     'vs/workbench/contrib/testing/browser/icons',
     'testingCancelIcon',
@@ -95,11 +105,21 @@ const testingCancelRefreshTests = registerIcon('testing-cancel-refresh-tests', C
     'testingCancelRefreshTests',
     'Icon on the button to cancel refreshing tests.'
 )));
-const testingCoverage = registerIcon('testing-coverage', Codicon.lightBulb, ( localizeWithPath(
+const testingCoverageReport = registerIcon('testing-coverage', Codicon.lightBulb, ( localizeWithPath(
     'vs/workbench/contrib/testing/browser/icons',
     'testingCoverage',
     'Icon representing test coverage'
 )));
+const testingWasCovered = registerIcon('testing-was-covered', Codicon.check, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/icons',
+    'testingWasCovered',
+    'Icon representing that an element was covered'
+)));
+const testingCoverageMissingBranch = registerIcon('testing-missing-branch', Codicon.question, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/icons',
+    'testingMissingBranch',
+    'Icon representing a uncovered block without a range'
+)));
 const testingStatesToIcons = ( new Map([
     [6 , registerIcon('testing-error-icon', Codicon.issues, ( localizeWithPath(
         'vs/workbench/contrib/testing/browser/icons',
@@ -151,4 +171,4 @@ registerThemingParticipant((theme, collector) => {
 	`);
 });
 
-export { testingCancelIcon, testingCancelRefreshTests, testingContinuousIsOn, testingCoverage, testingDebugAllIcon, testingDebugIcon, testingFilterIcon, testingHiddenIcon, testingRefreshTests, testingRerunIcon, testingResultsIcon, testingRunAllIcon, testingRunIcon, testingStatesToIcons, testingTurnContinuousRunOff, testingTurnContinuousRunOn, testingUpdateProfiles, testingViewIcon };
+export { testingCancelIcon, testingCancelRefreshTests, testingContinuousIsOn, testingCoverageAllIcon, testingCoverageIcon, testingCoverageMissingBranch, testingCoverageReport, testingDebugAllIcon, testingDebugIcon, testingFilterIcon, testingHiddenIcon, testingRefreshTests, testingRerunIcon, testingResultsIcon, testingRunAllIcon, testingRunIcon, testingStatesToIcons, testingTurnContinuousRunOff, testingTurnContinuousRunOn, testingUpdateProfiles, testingViewIcon, testingWasCovered };