@codingame/monaco-vscode-testing-service-override 3.2.3 → 4.1.0

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

@@ -1,970 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { $ } from 'vscode/vscode/vs/base/browser/dom';
-import { renderStringAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
-import { Action, Separator, SubmenuAction } from 'vscode/vscode/vs/base/common/actions';
-import { equals } from 'vscode/vscode/vs/base/common/arrays';
-import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
-import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Disposable, MutableDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { overviewRulerError, overviewRulerInfo } from 'vscode/vscode/vs/editor/common/core/editorColorRegistry';
-import { GlyphMarginLane, OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { themeColorFromId } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { GutterActionsRegistry, EditorLineNumberContextMenu } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/editorLineNumberMenu';
-import { getTestItemContextOverlay } from './explorerProjections/testItemContextOverlay.js';
-import { testingRunAllIcon, testingRunIcon, testingStatesToIcons } from './icons.js';
-import { getTestingConfiguration } from '../common/configuration.js';
-import { labelForTestInState } from '../common/constants.js';
-import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
-import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
-import { LiveTestResult } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResult';
-import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
-import { testsInFile, ITestService, getContextForTestItem } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
-import { TestDecorations, ITestingDecorationsService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingDecorations';
-import { ITestingPeekOpener } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingPeekOpener';
-import { isFailedState, maxPriority } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingStates';
-import { parseTestUri, buildTestUri } 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 = renderStringAsPlaintext(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 };