@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,968 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $ } from '../../../../base/browser/dom.js';
+import { Separator, Action, SubmenuAction } from '../../../../base/common/actions.js';
+import { equals } from '../../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { overviewRulerError, overviewRulerInfo } from '../../../../editor/common/core/editorColorRegistry.js';
+import { OverviewRulerLane, GlyphMarginLane } from '../../../../editor/common/model.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { createAndFillInContextMenuActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { GutterActionsRegistry, EditorLineNumberContextMenu } from '../../codeEditor/browser/editorLineNumberMenu.js';
+import { getTestItemContextOverlay } from './explorerProjections/testItemContextOverlay.js';
+import { testingRunAllIcon, testingRunIcon, testingStatesToIcons } from './icons.js';
+import { renderTestMessageAsText } from './testMessageColorizer.js';
+import { getTestingConfiguration } from '../common/configuration.js';
+import { labelForTestInState } from '../common/constants.js';
+import { TestId } from '../common/testId.js';
+import { ITestProfileService } from '../common/testProfileService.js';
+import { LiveTestResult } from '../common/testResult.js';
+import { ITestResultService } from '../common/testResultService.js';
+import { ITestService, testsInFile, getContextForTestItem } from '../common/testService.js';
+import { ITestingDecorationsService, TestDecorations } from '../common/testingDecorations.js';
+import { ITestingPeekOpener } from '../common/testingPeekOpener.js';
+import { isFailedState, maxPriority } from '../common/testingStates.js';
+import { buildTestUri, parseTestUri } from '../common/testingUri.js';
+var TestMessageDecoration_1;
+const MAX_INLINE_MESSAGE_LENGTH = 128;
+const MAX_TESTS_IN_SUBMENU = 30;
+const GLYPH_MARGIN_LANE = GlyphMarginLane.Center;
+function isOriginalInDiffEditor(codeEditorService, codeEditor) {
+    const diffEditors = codeEditorService.listDiffEditors();
+    for (const diffEditor of diffEditors) {
+        if (diffEditor.getOriginalEditor() === codeEditor) {
+            return true;
+        }
+    }
+    return false;
+}
+class CachedDecorations {
+    constructor() {
+        this.runByIdKey = ( new Map());
+        this.messages = ( new Map());
+    }
+    get size() {
+        return this.runByIdKey.size + this.messages.size;
+    }
+    getForExactTests(testIds) {
+        const key = testIds.sort().join('\0\0');
+        return this.runByIdKey.get(key);
+    }
+    getMessage(message) {
+        return this.messages.get(message);
+    }
+    removeMessage(message) {
+        this.messages.delete(message);
+    }
+    addMessage(d) {
+        this.messages.set(d.testMessage, d);
+    }
+    addTest(d) {
+        const key = d.testIds.sort().join('\0\0');
+        this.runByIdKey.set(key, d);
+    }
+    getById(decorationId) {
+        for (const d of ( this.runByIdKey.values())) {
+            if (d.id === decorationId) {
+                return d;
+            }
+        }
+        for (const d of ( this.messages.values())) {
+            if (d.id === decorationId) {
+                return d;
+            }
+        }
+        return undefined;
+    }
+    *[Symbol.iterator]() {
+        for (const d of ( this.runByIdKey.values())) {
+            yield d;
+        }
+        for (const d of ( this.messages.values())) {
+            yield d;
+        }
+    }
+}
+let TestingDecorationService = class TestingDecorationService extends Disposable {
+    constructor(codeEditorService, configurationService, testService, results, instantiationService, modelService) {
+        super();
+        this.configurationService = configurationService;
+        this.testService = testService;
+        this.results = results;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.generation = 0;
+        this.changeEmitter = ( new Emitter());
+        this.decorationCache = ( new ResourceMap());
+        this.invalidatedMessages = ( new WeakSet());
+        this.onDidChange = this.changeEmitter.event;
+        codeEditorService.registerDecorationType('test-message-decoration', TestMessageDecoration.decorationId, {}, undefined);
+        modelService.onModelRemoved(e => this.decorationCache.delete(e.uri));
+        const debounceInvalidate = this._register(( new RunOnceScheduler(() => this.invalidate(), 100)));
+        this._register(this.testService.onWillProcessDiff(diff => {
+            for (const entry of diff) {
+                if (entry.op !== 2 ) {
+                    continue;
+                }
+                const rec = this.decorationCache.get(entry.uri);
+                if (rec) {
+                    rec.rangeUpdateVersionId = entry.docv;
+                }
+            }
+            if (!debounceInvalidate.isScheduled()) {
+                debounceInvalidate.schedule();
+            }
+        }));
+        this._register(Event.any(this.results.onResultsChanged, this.results.onTestChanged, this.testService.excluded.onTestExclusionsChanged, this.testService.showInlineOutput.onDidChange, Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration("testing.gutterEnabled" )))(() => {
+            if (!debounceInvalidate.isScheduled()) {
+                debounceInvalidate.schedule();
+            }
+        }));
+        this._register(GutterActionsRegistry.registerGutterActionsGenerator((context, result) => {
+            const model = context.editor.getModel();
+            const testingDecorations = TestingDecorations.get(context.editor);
+            if (!model || !testingDecorations?.currentUri) {
+                return;
+            }
+            const currentDecorations = this.syncDecorations(testingDecorations.currentUri);
+            if (!currentDecorations.size) {
+                return;
+            }
+            const modelDecorations = model.getLinesDecorations(context.lineNumber, context.lineNumber);
+            for (const { id } of modelDecorations) {
+                const decoration = currentDecorations.getById(id);
+                if (decoration) {
+                    const { object: actions } = decoration.getContextMenuActions();
+                    for (const action of actions) {
+                        result.push(action, '1_testing');
+                    }
+                }
+            }
+        }));
+    }
+    invalidateResultMessage(message) {
+        this.invalidatedMessages.add(message);
+        this.invalidate();
+    }
+    syncDecorations(resource) {
+        const model = this.modelService.getModel(resource);
+        if (!model) {
+            return ( new CachedDecorations());
+        }
+        const cached = this.decorationCache.get(resource);
+        if (cached && cached.generation === this.generation && (cached.rangeUpdateVersionId === undefined || cached.rangeUpdateVersionId !== model.getVersionId())) {
+            return cached.value;
+        }
+        return this.applyDecorations(model);
+    }
+    getDecoratedTestPosition(resource, testId) {
+        const model = this.modelService.getModel(resource);
+        if (!model) {
+            return undefined;
+        }
+        const decoration = Iterable.find(this.syncDecorations(resource), v => v instanceof RunTestDecoration && v.isForTest(testId));
+        if (!decoration) {
+            return undefined;
+        }
+        return model.getDecorationRange(decoration.id)?.getStartPosition();
+    }
+    invalidate() {
+        this.generation++;
+        this.changeEmitter.fire();
+    }
+    applyDecorations(model) {
+        const gutterEnabled = getTestingConfiguration(this.configurationService, "testing.gutterEnabled" );
+        const uriStr = ( model.uri.toString());
+        const cached = this.decorationCache.get(model.uri);
+        const testRangesUpdated = cached?.rangeUpdateVersionId === model.getVersionId();
+        const lastDecorations = cached?.value ?? ( new CachedDecorations());
+        const newDecorations = model.changeDecorations(accessor => {
+            const newDecorations = ( new CachedDecorations());
+            const runDecorations = ( new TestDecorations());
+            for (const test of this.testService.collection.getNodeByUrl(model.uri)) {
+                if (!test.item.range) {
+                    continue;
+                }
+                const stateLookup = this.results.getStateById(test.item.extId);
+                const line = test.item.range.startLineNumber;
+                runDecorations.push({ line, id: '', test, resultItem: stateLookup?.[1] });
+            }
+            for (const [line, tests] of runDecorations.lines()) {
+                const multi = tests.length > 1;
+                let existing = lastDecorations.getForExactTests(( tests.map(t => t.test.item.extId)));
+                if (existing && testRangesUpdated && model.getDecorationRange(existing.id)?.startLineNumber !== line) {
+                    existing = undefined;
+                }
+                if (existing) {
+                    if (existing.replaceOptions(tests, gutterEnabled)) {
+                        accessor.changeDecorationOptions(existing.id, existing.editorDecoration.options);
+                    }
+                    newDecorations.addTest(existing);
+                }
+                else {
+                    newDecorations.addTest(multi
+                        ? this.instantiationService.createInstance(MultiRunTestDecoration, tests, gutterEnabled, model)
+                        : this.instantiationService.createInstance(RunSingleTestDecoration, tests[0].test, tests[0].resultItem, model, gutterEnabled));
+                }
+            }
+            const messageLines = ( new Set());
+            if (getTestingConfiguration(this.configurationService, "testing.showAllMessages" )) {
+                this.results.results.forEach(lastResult => this.applyDecorationsFromResult(lastResult, messageLines, uriStr, lastDecorations, model, newDecorations));
+            }
+            else {
+                this.applyDecorationsFromResult(this.results.results[0], messageLines, uriStr, lastDecorations, model, newDecorations);
+            }
+            const saveFromRemoval = ( new Set());
+            for (const decoration of newDecorations) {
+                if (decoration.id === '') {
+                    decoration.id = accessor.addDecoration(decoration.editorDecoration.range, decoration.editorDecoration.options);
+                }
+                else {
+                    saveFromRemoval.add(decoration.id);
+                }
+            }
+            for (const decoration of lastDecorations) {
+                if (!( saveFromRemoval.has(decoration.id))) {
+                    accessor.removeDecoration(decoration.id);
+                }
+            }
+            this.decorationCache.set(model.uri, {
+                generation: this.generation,
+                rangeUpdateVersionId: cached?.rangeUpdateVersionId,
+                value: newDecorations,
+            });
+            return newDecorations;
+        });
+        return newDecorations || lastDecorations;
+    }
+    applyDecorationsFromResult(lastResult, messageLines, uriStr, lastDecorations, model, newDecorations) {
+        if (this.testService.showInlineOutput.value && lastResult instanceof LiveTestResult) {
+            for (const task of lastResult.tasks) {
+                for (const m of task.otherMessages) {
+                    if (!( this.invalidatedMessages.has(m)) && m.location?.uri.toString() === uriStr) {
+                        const decoration = lastDecorations.getMessage(m) || this.instantiationService.createInstance(TestMessageDecoration, m, undefined, model);
+                        newDecorations.addMessage(decoration);
+                    }
+                }
+            }
+            for (const test of lastResult.tests) {
+                for (let taskId = 0; taskId < test.tasks.length; taskId++) {
+                    const state = test.tasks[taskId];
+                    for (const kind of [0 , 1 ]) {
+                        for (let i = 0; i < state.messages.length; i++) {
+                            const m = state.messages[i];
+                            if (m.type !== kind || ( this.invalidatedMessages.has(m)) || m.location?.uri.toString() !== uriStr) {
+                                continue;
+                            }
+                            const line = m.location.range.startLineNumber;
+                            if (!( messageLines.has(line))) {
+                                const decoration = lastDecorations.getMessage(m) || this.instantiationService.createInstance(TestMessageDecoration, m, buildTestUri({
+                                    type: 3 ,
+                                    messageIndex: i,
+                                    taskIndex: taskId,
+                                    resultId: lastResult.id,
+                                    testExtId: test.item.extId,
+                                }), model);
+                                newDecorations.addMessage(decoration);
+                                messageLines.add(line);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+TestingDecorationService = ( __decorate([
+    ( __param(0, ICodeEditorService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ITestService)),
+    ( __param(3, ITestResultService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IModelService))
+], TestingDecorationService));
+let TestingDecorations = class TestingDecorations extends Disposable {
+    static get(editor) {
+        return editor.getContribution("editor.contrib.testingDecorations" );
+    }
+    get currentUri() { return this._currentUri; }
+    constructor(editor, codeEditorService, testService, decorations, uriIdentityService) {
+        super();
+        this.editor = editor;
+        this.codeEditorService = codeEditorService;
+        this.testService = testService;
+        this.decorations = decorations;
+        this.uriIdentityService = uriIdentityService;
+        this.expectedWidget = ( new MutableDisposable());
+        this.actualWidget = ( new MutableDisposable());
+        codeEditorService.registerDecorationType('test-message-decoration', TestMessageDecoration.decorationId, {}, undefined, editor);
+        this.attachModel(editor.getModel()?.uri);
+        this._register(decorations.onDidChange(() => {
+            if (this._currentUri) {
+                decorations.syncDecorations(this._currentUri);
+            }
+        }));
+        this._register(this.editor.onDidChangeModel(e => this.attachModel(e.newModelUrl || undefined)));
+        this._register(this.editor.onMouseDown(e => {
+            if (e.target.position && this.currentUri) {
+                const modelDecorations = editor.getModel()?.getLineDecorations(e.target.position.lineNumber) ?? [];
+                if (!modelDecorations.length) {
+                    return;
+                }
+                const cache = decorations.syncDecorations(this.currentUri);
+                for (const { id } of modelDecorations) {
+                    if (cache.getById(id)?.click(e)) {
+                        e.event.stopPropagation();
+                        return;
+                    }
+                }
+            }
+        }));
+        this._register(Event.accumulate(this.editor.onDidChangeModelContent, 0, this._store)(evts => {
+            const model = editor.getModel();
+            if (!this._currentUri || !model) {
+                return;
+            }
+            const currentDecorations = decorations.syncDecorations(this._currentUri);
+            if (!currentDecorations.size) {
+                return;
+            }
+            for (const e of evts) {
+                for (const change of e.changes) {
+                    const modelDecorations = model.getLinesDecorations(change.range.startLineNumber, change.range.endLineNumber);
+                    for (const { id } of modelDecorations) {
+                        const decoration = currentDecorations.getById(id);
+                        if (decoration instanceof TestMessageDecoration) {
+                            decorations.invalidateResultMessage(decoration.testMessage);
+                        }
+                    }
+                }
+            }
+        }));
+        const updateFontFamilyVar = () => {
+            this.editor.getContainerDomNode().style.setProperty('--testMessageDecorationFontFamily', editor.getOption(49 ));
+            this.editor.getContainerDomNode().style.setProperty('--testMessageDecorationFontSize', `${editor.getOption(52 )}px`);
+        };
+        this._register(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(49 )) {
+                updateFontFamilyVar();
+            }
+        }));
+        updateFontFamilyVar();
+    }
+    attachModel(uri) {
+        switch (uri && parseTestUri(uri)?.type) {
+            case 4 :
+                this.expectedWidget.value = ( new ExpectedLensContentWidget(this.editor));
+                this.actualWidget.clear();
+                break;
+            case 3 :
+                this.expectedWidget.clear();
+                this.actualWidget.value = ( new ActualLensContentWidget(this.editor));
+                break;
+            default:
+                this.expectedWidget.clear();
+                this.actualWidget.clear();
+        }
+        if (isOriginalInDiffEditor(this.codeEditorService, this.editor)) {
+            uri = undefined;
+        }
+        this._currentUri = uri;
+        if (!uri) {
+            return;
+        }
+        this.decorations.syncDecorations(uri);
+        (async () => {
+            for await (const _test of testsInFile(this.testService, this.uriIdentityService, uri, false)) {
+                if (this._currentUri !== uri) {
+                    break;
+                }
+            }
+        })();
+    }
+};
+TestingDecorations = ( __decorate([
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, ITestService)),
+    ( __param(3, ITestingDecorationsService)),
+    ( __param(4, IUriIdentityService))
+], TestingDecorations));
+const collapseRange = (originalRange) => ({
+    startLineNumber: originalRange.startLineNumber,
+    endLineNumber: originalRange.startLineNumber,
+    startColumn: originalRange.startColumn,
+    endColumn: originalRange.startColumn,
+});
+const createRunTestDecoration = (tests, states, visible) => {
+    const range = tests[0]?.item.range;
+    if (!range) {
+        throw new Error('Test decorations can only be created for tests with a range');
+    }
+    if (!visible) {
+        return { range: collapseRange(range), options: { isWholeLine: true, description: 'run-test-decoration' } };
+    }
+    let computedState = 0 ;
+    const hoverMessageParts = [];
+    let testIdWithMessages;
+    let retired = false;
+    for (let i = 0; i < tests.length; i++) {
+        const test = tests[i];
+        const resultItem = states[i];
+        const state = resultItem?.computedState ?? 0 ;
+        if (hoverMessageParts.length < 10) {
+            hoverMessageParts.push(labelForTestInState(test.item.label, state));
+        }
+        computedState = maxPriority(computedState, state);
+        retired = retired || !!resultItem?.retired;
+        if (!testIdWithMessages && resultItem?.tasks.some(t => t.messages.length)) {
+            testIdWithMessages = test.item.extId;
+        }
+    }
+    const hasMultipleTests = tests.length > 1 || tests[0].children.size > 0;
+    const icon = computedState === 0
+        ? (hasMultipleTests ? testingRunAllIcon : testingRunIcon)
+        : testingStatesToIcons.get(computedState);
+    let hoverMessage;
+    let glyphMarginClassName = ThemeIcon.asClassName(icon) + ' testing-run-glyph';
+    if (retired) {
+        glyphMarginClassName += ' retired';
+    }
+    return {
+        range: collapseRange(range),
+        options: {
+            description: 'run-test-decoration',
+            showIfCollapsed: true,
+            get hoverMessage() {
+                if (!hoverMessage) {
+                    const building = hoverMessage = ( new MarkdownString('', true)).appendText(hoverMessageParts.join(', ') + '.');
+                    if (testIdWithMessages) {
+                        const args = encodeURIComponent(JSON.stringify([testIdWithMessages]));
+                        building.appendMarkdown(` [${( localizeWithPath(
+                            'vs/workbench/contrib/testing/browser/testingDecorations',
+                            'peekTestOutout',
+                            'Peek Test Output'
+                        ))}](command:vscode.peekTestError?${args})`);
+                    }
+                }
+                return hoverMessage;
+            },
+            glyphMargin: { position: GLYPH_MARGIN_LANE },
+            glyphMarginClassName,
+            stickiness: 1 ,
+            zIndex: 10000,
+        }
+    };
+};
+class TitleLensContentWidget {
+    constructor(editor) {
+        this.editor = editor;
+        this.allowEditorOverflow = false;
+        this.suppressMouseDown = true;
+        this._domNode = $('span');
+        queueMicrotask(() => {
+            this.applyStyling();
+            this.editor.addContentWidget(this);
+        });
+    }
+    applyStyling() {
+        let fontSize = this.editor.getOption(19 );
+        let height;
+        if (!fontSize || fontSize < 5) {
+            fontSize = (this.editor.getOption(52 ) * .9) | 0;
+            height = this.editor.getOption(67 );
+        }
+        else {
+            height = (fontSize * Math.max(1.3, this.editor.getOption(67 ) / this.editor.getOption(52 ))) | 0;
+        }
+        const editorFontInfo = this.editor.getOption(50 );
+        const node = this._domNode;
+        node.classList.add('testing-diff-lens-widget');
+        node.textContent = this.getText();
+        node.style.lineHeight = `${height}px`;
+        node.style.fontSize = `${fontSize}px`;
+        node.style.fontFamily = `var(--${"testingDiffLensFontFamily" })`;
+        node.style.fontFeatureSettings = `var(--${"testingDiffLensFontFeatures" })`;
+        const containerStyle = this.editor.getContainerDomNode().style;
+        containerStyle.setProperty("testingDiffLensFontFamily" , this.editor.getOption(18 ) ?? 'inherit');
+        containerStyle.setProperty("testingDiffLensFontFeatures" , editorFontInfo.fontFeatureSettings);
+        this.editor.changeViewZones(accessor => {
+            if (this.viewZoneId) {
+                accessor.removeZone(this.viewZoneId);
+            }
+            this.viewZoneId = accessor.addZone({
+                afterLineNumber: 0,
+                afterColumn: 1073741824 ,
+                domNode: document.createElement('div'),
+                heightInPx: 20,
+            });
+        });
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    dispose() {
+        this.editor.changeViewZones(accessor => {
+            if (this.viewZoneId) {
+                accessor.removeZone(this.viewZoneId);
+            }
+        });
+        this.editor.removeContentWidget(this);
+    }
+    getPosition() {
+        return {
+            position: { column: 0, lineNumber: 0 },
+            preference: [1 ],
+        };
+    }
+}
+class ExpectedLensContentWidget extends TitleLensContentWidget {
+    getId() {
+        return 'expectedTestingLens';
+    }
+    getText() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingDecorations',
+            'expected.title',
+            'Expected'
+        ));
+    }
+}
+class ActualLensContentWidget extends TitleLensContentWidget {
+    getId() {
+        return 'actualTestingLens';
+    }
+    getText() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingDecorations',
+            'actual.title',
+            'Actual'
+        ));
+    }
+}
+let RunTestDecoration = class RunTestDecoration {
+    get line() {
+        return this.editorDecoration.range.startLineNumber;
+    }
+    get testIds() {
+        return ( this.tests.map(t => t.test.item.extId));
+    }
+    constructor(tests, visible, model, codeEditorService, testService, contextMenuService, commandService, configurationService, testProfileService, contextKeyService, menuService) {
+        this.tests = tests;
+        this.visible = visible;
+        this.model = model;
+        this.codeEditorService = codeEditorService;
+        this.testService = testService;
+        this.contextMenuService = contextMenuService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.testProfileService = testProfileService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.id = '';
+        this.displayedStates = ( tests.map(t => t.resultItem?.computedState));
+        this.editorDecoration = createRunTestDecoration(( tests.map(t => t.test)), ( tests.map(t => t.resultItem)), visible);
+        this.editorDecoration.options.glyphMarginHoverMessage = ( new MarkdownString()).appendText(this.getGutterLabel());
+    }
+    click(e) {
+        if (e.target.type !== 2
+            || e.target.detail.glyphMarginLane !== GLYPH_MARGIN_LANE
+            || e.event.rightButton
+            || isMacintosh && e.event.leftButton && e.event.ctrlKey) {
+            return false;
+        }
+        const alternateAction = e.event.altKey;
+        switch (getTestingConfiguration(this.configurationService, "testing.defaultGutterClickAction" )) {
+            case "contextMenu" :
+                this.showContextMenu(e);
+                break;
+            case "debug" :
+                this.runWith(alternateAction ? 2  : 4 );
+                break;
+            case "runWithCoverage" :
+                this.runWith(alternateAction ? 4  : 8 );
+                break;
+            case "run" :
+            default:
+                this.runWith(alternateAction ? 4  : 2 );
+                break;
+        }
+        return true;
+    }
+    replaceOptions(newTests, visible) {
+        const displayedStates = ( newTests.map(t => t.resultItem?.computedState));
+        if (visible === this.visible && equals(this.displayedStates, displayedStates)) {
+            return false;
+        }
+        this.tests = newTests;
+        this.displayedStates = displayedStates;
+        this.visible = visible;
+        this.editorDecoration.options = createRunTestDecoration(( newTests.map(t => t.test)), ( newTests.map(t => t.resultItem)), visible).options;
+        this.editorDecoration.options.glyphMarginHoverMessage = ( new MarkdownString()).appendText(this.getGutterLabel());
+        return true;
+    }
+    isForTest(testId) {
+        return ( this.tests.some(t => t.test.item.extId === testId));
+    }
+    runWith(profile) {
+        return this.testService.runTests({
+            tests: ( this.tests.map(({ test }) => test)),
+            group: profile,
+        });
+    }
+    showContextMenu(e) {
+        const editor = this.codeEditorService.listCodeEditors().find(e => e.getModel() === this.model);
+        editor?.getContribution(EditorLineNumberContextMenu.ID)?.show(e);
+    }
+    getGutterLabel() {
+        switch (getTestingConfiguration(this.configurationService, "testing.defaultGutterClickAction" )) {
+            case "contextMenu" :
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingDecorations',
+                    'testing.gutterMsg.contextMenu',
+                    'Click for test options'
+                ));
+            case "debug" :
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingDecorations',
+                    'testing.gutterMsg.debug',
+                    'Click to debug tests, right click for more options'
+                ));
+            case "runWithCoverage" :
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingDecorations',
+                    'testing.gutterMsg.coverage',
+                    'Click to run tests with coverage, right click for more options'
+                ));
+            case "run" :
+            default:
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingDecorations',
+                    'testing.gutterMsg.run',
+                    'Click to run tests, right click for more options'
+                ));
+        }
+    }
+    getTestContextMenuActions(test, resultItem) {
+        const testActions = [];
+        const capabilities = this.testProfileService.capabilitiesForTest(test);
+        [
+            { bitset: 2 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'run test',
+                'Run Test'
+            )) },
+            { bitset: 4 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'debug test',
+                'Debug Test'
+            )) },
+            { bitset: 8 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'coverage test',
+                'Run with Coverage'
+            )) },
+        ].forEach(({ bitset, label }) => {
+            if (capabilities & bitset) {
+                testActions.push(( new Action(
+                    `testing.gutter.${bitset}`,
+                    label,
+                    undefined,
+                    undefined,
+                    () => this.testService.runTests({ group: bitset, tests: [test] })
+                )));
+            }
+        });
+        if (capabilities & 16 ) {
+            testActions.push(( new Action('testing.runUsing', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'testing.runUsing',
+                'Execute Using Profile...'
+            )), undefined, undefined, async () => {
+                const profile = await this.commandService.executeCommand('vscode.pickTestProfile', { onlyForTest: test });
+                if (!profile) {
+                    return;
+                }
+                this.testService.runResolvedTests({
+                    targets: [{
+                            profileGroup: profile.group,
+                            profileId: profile.profileId,
+                            controllerId: profile.controllerId,
+                            testIds: [test.item.extId]
+                        }]
+                });
+            })));
+        }
+        if (resultItem && isFailedState(resultItem.computedState)) {
+            testActions.push(( new Action('testing.gutter.peekFailure', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'peek failure',
+                'Peek Error'
+            )), undefined, undefined, () => this.commandService.executeCommand('vscode.peekTestError', test.item.extId))));
+        }
+        testActions.push(( new Action('testing.gutter.reveal', ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingDecorations',
+            'reveal test',
+            'Reveal in Test Explorer'
+        )), undefined, undefined, () => this.commandService.executeCommand('_revealTestInExplorer', test.item.extId))));
+        const contributed = this.getContributedTestActions(test, capabilities);
+        return { object: Separator.join(testActions, contributed), dispose() { } };
+    }
+    getContributedTestActions(test, capabilities) {
+        const contextOverlay = this.contextKeyService.createOverlay(getTestItemContextOverlay(test, capabilities));
+        const menu = this.menuService.createMenu(MenuId.TestItemGutter, contextOverlay);
+        try {
+            const target = [];
+            const arg = getContextForTestItem(this.testService.collection, test.item.extId);
+            createAndFillInContextMenuActions(menu, { shouldForwardArgs: true, arg }, target);
+            return target;
+        }
+        finally {
+            menu.dispose();
+        }
+    }
+};
+RunTestDecoration = ( __decorate([
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, ITestService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, ITestProfileService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IMenuService))
+], RunTestDecoration));
+let MultiRunTestDecoration = class MultiRunTestDecoration extends RunTestDecoration {
+    constructor(tests, visible, model, codeEditorService, testService, contextMenuService, commandService, configurationService, testProfileService, contextKeyService, menuService, quickInputService) {
+        super(tests, visible, model, codeEditorService, testService, contextMenuService, commandService, configurationService, testProfileService, contextKeyService, menuService);
+        this.quickInputService = quickInputService;
+    }
+    getContextMenuActions() {
+        const allActions = [];
+        [
+            { bitset: 2 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'run all test',
+                'Run All Tests'
+            )) },
+            { bitset: 8 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'run all test with coverage',
+                'Run All Tests with Coverage'
+            )) },
+            { bitset: 4 , label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'debug all test',
+                'Debug All Tests'
+            )) },
+        ].forEach(({ bitset, label }, i) => {
+            const canRun = ( this.tests.some(({ test }) => this.testProfileService.capabilitiesForTest(test) & bitset));
+            if (canRun) {
+                allActions.push(( new Action(
+                    `testing.gutter.run${i}`,
+                    label,
+                    undefined,
+                    undefined,
+                    () => this.runWith(bitset)
+                )));
+            }
+        });
+        const testItems = ( this.tests.map((testItem) => ({
+            currentLabel: testItem.test.item.label,
+            testItem,
+            parent: TestId.fromString(testItem.test.item.extId).parentId,
+        })));
+        const getLabelConflicts = (tests) => {
+            const labelCount = ( new Map());
+            for (const test of tests) {
+                labelCount.set(test.currentLabel, (labelCount.get(test.currentLabel) || 0) + 1);
+            }
+            return tests.filter(e => labelCount.get(e.currentLabel) > 1);
+        };
+        let conflicts, hasParent = true;
+        while ((conflicts = getLabelConflicts(testItems)).length && hasParent) {
+            for (const conflict of conflicts) {
+                if (conflict.parent) {
+                    const parent = this.testService.collection.getNodeById(( conflict.parent.toString()));
+                    conflict.currentLabel = parent?.item.label + ' > ' + conflict.currentLabel;
+                    conflict.parent = conflict.parent.parentId;
+                }
+                else {
+                    hasParent = false;
+                }
+            }
+        }
+        testItems.sort((a, b) => {
+            const ai = a.testItem.test.item;
+            const bi = b.testItem.test.item;
+            return (ai.sortText || ai.label).localeCompare(bi.sortText || bi.label);
+        });
+        const disposable = ( new DisposableStore());
+        let testSubmenus = ( testItems.map(({ currentLabel, testItem }) => {
+            const actions = this.getTestContextMenuActions(testItem.test, testItem.resultItem);
+            disposable.add(actions);
+            return ( new SubmenuAction(testItem.test.item.extId, stripIcons(currentLabel), actions.object));
+        }));
+        const overflow = testSubmenus.length - MAX_TESTS_IN_SUBMENU;
+        if (overflow > 0) {
+            testSubmenus = testSubmenus.slice(0, MAX_TESTS_IN_SUBMENU);
+            testSubmenus.push(( new Action('testing.gutter.overflow', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingDecorations',
+                'testOverflowItems',
+                '{0} more tests...',
+                overflow
+            )), undefined, undefined, () => this.pickAndRun(testItems))));
+        }
+        return { object: Separator.join(allActions, testSubmenus), dispose: () => disposable.dispose() };
+    }
+    async pickAndRun(testItems) {
+        const doPick = (items, title) => ( new Promise(resolve => {
+            const pick = this.quickInputService.createQuickPick();
+            pick.placeholder = title;
+            pick.items = items;
+            pick.onDidHide(() => {
+                resolve(undefined);
+                pick.dispose();
+            });
+            pick.onDidAccept(() => {
+                resolve(pick.selectedItems[0]);
+                pick.dispose();
+            });
+            pick.show();
+        }));
+        const item = await doPick(( testItems.map(
+            ({ currentLabel, testItem }) => ({ label: currentLabel, test: testItem.test, result: testItem.resultItem })
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingDecorations',
+            'selectTestToRun',
+            'Select a test to run'
+        )));
+        if (!item) {
+            return;
+        }
+        const actions = this.getTestContextMenuActions(item.test, item.result);
+        try {
+            (await doPick(actions.object, item.label))?.run();
+        }
+        finally {
+            actions.dispose();
+        }
+    }
+};
+MultiRunTestDecoration = ( __decorate([
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, ITestService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, ITestProfileService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IMenuService)),
+    ( __param(11, IQuickInputService))
+], MultiRunTestDecoration));
+let RunSingleTestDecoration = class RunSingleTestDecoration extends RunTestDecoration {
+    constructor(test, resultItem, model, visible, codeEditorService, testService, commandService, contextMenuService, configurationService, testProfiles, contextKeyService, menuService) {
+        super([{ test, resultItem }], visible, model, codeEditorService, testService, contextMenuService, commandService, configurationService, testProfiles, contextKeyService, menuService);
+    }
+    getContextMenuActions() {
+        return this.getTestContextMenuActions(this.tests[0].test, this.tests[0].resultItem);
+    }
+};
+RunSingleTestDecoration = ( __decorate([
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, ITestService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, ITestProfileService)),
+    ( __param(10, IContextKeyService)),
+    ( __param(11, IMenuService))
+], RunSingleTestDecoration));
+const lineBreakRe = /\r?\n\s*/g;
+let TestMessageDecoration = class TestMessageDecoration {
+    static { TestMessageDecoration_1 = this; }
+    static { this.inlineClassName = 'test-message-inline-content'; }
+    static { this.decorationId = `testmessage-${generateUuid()}`; }
+    constructor(testMessage, messageUri, textModel, peekOpener, editorService) {
+        this.testMessage = testMessage;
+        this.messageUri = messageUri;
+        this.peekOpener = peekOpener;
+        this.id = '';
+        this.contentIdClass = `test-message-inline-content-id${generateUuid()}`;
+        this.location = testMessage.location;
+        this.line = this.location.range.startLineNumber;
+        const severity = testMessage.type;
+        const message = testMessage.message;
+        const options = editorService.resolveDecorationOptions(TestMessageDecoration_1.decorationId, true);
+        options.hoverMessage = typeof message === 'string' ? ( new MarkdownString()).appendText(message) : message;
+        options.zIndex = 10;
+        options.className = `testing-inline-message-severity-${severity}`;
+        options.isWholeLine = true;
+        options.stickiness = 1 ;
+        options.collapseOnReplaceEdit = true;
+        let inlineText = renderTestMessageAsText(message).replace(lineBreakRe, ' ');
+        if (inlineText.length > MAX_INLINE_MESSAGE_LENGTH) {
+            inlineText = inlineText.slice(0, MAX_INLINE_MESSAGE_LENGTH - 1) + '…';
+        }
+        options.after = {
+            content: ' '.repeat(4) + inlineText,
+            inlineClassName: `test-message-inline-content test-message-inline-content-s${severity} ${this.contentIdClass} ${messageUri ? 'test-message-inline-content-clickable' : ''}`
+        };
+        options.showIfCollapsed = true;
+        const rulerColor = severity === 0
+            ? overviewRulerError
+            : overviewRulerInfo;
+        if (rulerColor) {
+            options.overviewRuler = { color: themeColorFromId(rulerColor), position: OverviewRulerLane.Right };
+        }
+        const lineLength = textModel.getLineLength(this.location.range.startLineNumber);
+        const column = lineLength ? (lineLength + 1) : this.location.range.endColumn;
+        this.editorDecoration = {
+            options,
+            range: {
+                startLineNumber: this.location.range.startLineNumber,
+                startColumn: column,
+                endColumn: column,
+                endLineNumber: this.location.range.startLineNumber,
+            }
+        };
+    }
+    click(e) {
+        if (e.event.rightButton) {
+            return false;
+        }
+        if (!this.messageUri) {
+            return false;
+        }
+        if (e.target.element?.className.includes(this.contentIdClass)) {
+            this.peekOpener.peekUri(this.messageUri);
+        }
+        return false;
+    }
+    getContextMenuActions() {
+        return { object: [], dispose: () => { } };
+    }
+};
+TestMessageDecoration = TestMessageDecoration_1 = ( __decorate([
+    ( __param(3, ITestingPeekOpener)),
+    ( __param(4, ICodeEditorService))
+], TestMessageDecoration));
+export { TestingDecorationService, TestingDecorations };