@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,2108 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, reset, Dimension, scheduleAtNextAnimationFrame, getWindow } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { renderLabelWithIcons } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { DomScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { SplitView, Sizing } from '../../../../base/browser/ui/splitview/splitview.js';
+import { Separator, Action } from '../../../../base/common/actions.js';
+import { Limiter, Delayer, RunOnceScheduler } from '../../../../base/common/async.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Color } from '../../../../base/common/color.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { stripIcons } from '../../../../base/common/iconLabels.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { Lazy } from '../../../../base/common/lazy.js';
+import { Disposable, MutableDisposable, DisposableStore, toDisposable, combinedDisposable } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/utils.js';
+import '../../../../base/common/cancellation.js';
+import { count } from '../../../../base/common/strings.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { isDefined } from '../../../../base/common/types.js';
+import './testingOutputPeek.css.js';
+import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { EditorAction2 } from '../../../../editor/browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { EmbeddedCodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { DiffEditorWidget } from '../../../../editor/browser/widget/diffEditor/diffEditorWidget.js';
+import { EmbeddedDiffEditorWidget } from '../../../../editor/browser/widget/diffEditor/embeddedDiffEditorWidget.js';
+import { MarkdownRenderer } from '../../../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { PeekViewWidget, peekViewTitleForeground, peekViewTitleInfoForeground, IPeekViewService, peekViewResultsBackground } from '../../../../editor/contrib/peekView/browser/peekView.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { FloatingClickMenu } from '../../../../platform/actions/browser/floatingMenu.js';
+import { createAndFillInActionBarActions, MenuEntryActionViewItem } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { Action2, MenuId, MenuItemAction, 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, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { WorkbenchCompressibleObjectTree } from '../../../../platform/list/browser/listService.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { TerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/terminalCapabilityStore.js';
+import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { widgetClose } from '../../../../platform/theme/common/iconRegistry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { DetachedProcessInfo } from '../../terminal/browser/detachedTerminal.js';
+import { ITerminalService } from '../../terminal/browser/terminal.js';
+import { getXtermScaledDimensions } from '../../terminal/browser/xterm/xtermTerminal.js';
+import { TERMINAL_BACKGROUND_COLOR } from '../../terminal/common/terminalColorRegistry.js';
+import { getTestItemContextOverlay } from './explorerProjections/testItemContextOverlay.js';
+import { testingStatesToIcons, testingRunIcon, testingDebugIcon, testingCoverageReport } from './icons.js';
+import { renderTestMessageAsText, colorizeTestMessageInEditor } from './testMessageColorizer.js';
+import { testingPeekBorder, testingMessagePeekBorder, testingPeekHeaderBackground, testingPeekMessageHeaderBackground } from './theme.js';
+import { getTestingConfiguration } from '../common/configuration.js';
+import { MutableObservableValue, staticObservableValue } from '../common/observableValue.js';
+import { StoredValue } from '../common/storedValue.js';
+import { ITestCoverageService } from '../common/testCoverageService.js';
+import { ITestExplorerFilterState } from '../common/testExplorerFilterState.js';
+import { ITestProfileService } from '../common/testProfileService.js';
+import { resultItemParents, LiveTestResult, maxCountPriority } from '../common/testResult.js';
+import { ITestResultService } from '../common/testResultService.js';
+import { ITestService } from '../common/testService.js';
+import { InternalTestItem, ITestMessage, getMarkId, testResultStateToContextValues } from '../common/testTypes.js';
+import { TestingContextKeys } from '../common/testingContextKeys.js';
+import { ITestingPeekOpener } from '../common/testingPeekOpener.js';
+import { isFailedState, cmpPriority } from '../common/testingStates.js';
+import { parseTestUri, buildTestUri } from '../common/testingUri.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+var TestingOutputPeekController_1, TestResultsViewContent_1, TestResultsPeek_1, TestRunElementRenderer_1;
+const getMessageArgs = (test, message) => ({
+    $mid: 18 ,
+    test: InternalTestItem.serialize(test),
+    message: ITestMessage.serialize(message),
+});
+class MessageSubject {
+    get isDiffable() {
+        return this.message.type === 0  && isDiffable(this.message);
+    }
+    get contextValue() {
+        return this.message.type === 0  ? this.message.contextValue : undefined;
+    }
+    constructor(result, test, taskIndex, messageIndex) {
+        this.result = result;
+        this.taskIndex = taskIndex;
+        this.messageIndex = messageIndex;
+        this.test = test.item;
+        const messages = test.tasks[taskIndex].messages;
+        this.messageIndex = messageIndex;
+        const parts = { messageIndex, resultId: result.id, taskIndex, testExtId: test.item.extId };
+        this.expectedUri = buildTestUri({ ...parts, type: 4  });
+        this.actualUri = buildTestUri({ ...parts, type: 3  });
+        this.messageUri = buildTestUri({ ...parts, type: 2  });
+        const message = this.message = messages[this.messageIndex];
+        this.context = getMessageArgs(test, message);
+        this.revealLocation = message.location ?? (test.item.uri && test.item.range ? { uri: test.item.uri, range: Range.lift(test.item.range) } : undefined);
+    }
+}
+class TaskSubject {
+    constructor(result, taskIndex) {
+        this.result = result;
+        this.taskIndex = taskIndex;
+        this.outputUri = buildTestUri({ resultId: result.id, taskIndex, type: 0  });
+    }
+}
+class TestOutputSubject {
+    constructor(result, taskIndex, test) {
+        this.result = result;
+        this.taskIndex = taskIndex;
+        this.test = test;
+        this.outputUri = buildTestUri({ resultId: this.result.id, taskIndex: this.taskIndex, testExtId: this.test.item.extId, type: 1  });
+        this.task = result.tasks[this.taskIndex];
+    }
+}
+const equalsSubject = (a, b) => ((a instanceof MessageSubject && b instanceof MessageSubject && a.message === b.message) ||
+    (a instanceof TaskSubject && b instanceof TaskSubject && a.result === b.result && a.taskIndex === b.taskIndex) ||
+    (a instanceof TestOutputSubject && b instanceof TestOutputSubject && a.test === b.test && a.taskIndex === b.taskIndex));
+function* allMessages(results) {
+    for (const result of results) {
+        for (const test of result.tests) {
+            for (let taskIndex = 0; taskIndex < test.tasks.length; taskIndex++) {
+                for (let messageIndex = 0; messageIndex < test.tasks[taskIndex].messages.length; messageIndex++) {
+                    yield { result, test, taskIndex, messageIndex };
+                }
+            }
+        }
+    }
+}
+let TestingPeekOpener = class TestingPeekOpener extends Disposable {
+    constructor(configuration, editorService, codeEditorService, testResults, testService, storageService, viewsService, commandService, notificationService) {
+        super();
+        this.configuration = configuration;
+        this.editorService = editorService;
+        this.codeEditorService = codeEditorService;
+        this.testResults = testResults;
+        this.testService = testService;
+        this.storageService = storageService;
+        this.viewsService = viewsService;
+        this.commandService = commandService;
+        this.notificationService = notificationService;
+        this.historyVisible = MutableObservableValue.stored(this._register(( new StoredValue({
+            key: 'testHistoryVisibleInPeek',
+            scope: 0 ,
+            target: 0 ,
+        }, this.storageService))), false);
+        this._register(testResults.onTestChanged(this.openPeekOnFailure, this));
+    }
+    async open() {
+        let uri;
+        const active = this.editorService.activeTextEditorControl;
+        if (isCodeEditor(active) && active.getModel()?.uri) {
+            const modelUri = active.getModel()?.uri;
+            if (modelUri) {
+                uri = await this.getFileCandidateMessage(modelUri, active.getPosition());
+            }
+        }
+        if (!uri) {
+            uri = this.lastUri;
+        }
+        if (!uri) {
+            uri = this.getAnyCandidateMessage();
+        }
+        if (!uri) {
+            return false;
+        }
+        return this.showPeekFromUri(uri);
+    }
+    tryPeekFirstError(result, test, options) {
+        const candidate = this.getFailedCandidateMessage(test);
+        if (!candidate) {
+            return false;
+        }
+        this.showPeekFromUri({
+            type: 2 ,
+            documentUri: candidate.location.uri,
+            taskIndex: candidate.taskId,
+            messageIndex: candidate.index,
+            resultId: result.id,
+            testExtId: test.item.extId,
+        }, undefined, { selection: candidate.location.range, selectionRevealType: 3 , ...options });
+        return true;
+    }
+    peekUri(uri, options = {}) {
+        const parsed = parseTestUri(uri);
+        const result = parsed && this.testResults.getResult(parsed.resultId);
+        if (!parsed || !result || !('testExtId' in parsed)) {
+            return false;
+        }
+        if (!('messageIndex' in parsed)) {
+            return false;
+        }
+        const message = result.getStateById(parsed.testExtId)?.tasks[parsed.taskIndex].messages[parsed.messageIndex];
+        if (!message?.location) {
+            return false;
+        }
+        this.showPeekFromUri({
+            type: 2 ,
+            documentUri: message.location.uri,
+            taskIndex: parsed.taskIndex,
+            messageIndex: parsed.messageIndex,
+            resultId: result.id,
+            testExtId: parsed.testExtId,
+        }, options.inEditor, { selection: message.location.range, ...options.options });
+        return true;
+    }
+    closeAllPeeks() {
+        for (const editor of this.codeEditorService.listCodeEditors()) {
+            TestingOutputPeekController.get(editor)?.removePeek();
+        }
+    }
+    openCurrentInEditor() {
+        const current = this.getActiveControl();
+        if (!current) {
+            return;
+        }
+        const options = { pinned: false, revealIfOpened: true };
+        if (current instanceof TaskSubject || current instanceof TestOutputSubject) {
+            this.editorService.openEditor({ resource: current.outputUri, options });
+            return;
+        }
+        if (current instanceof TestOutputSubject) {
+            this.editorService.openEditor({ resource: current.outputUri, options });
+            return;
+        }
+        const message = current.message;
+        if (current.isDiffable) {
+            this.editorService.openEditor({
+                original: { resource: current.expectedUri },
+                modified: { resource: current.actualUri },
+                options,
+            });
+        }
+        else if (typeof message.message === 'string') {
+            this.editorService.openEditor({ resource: current.messageUri, options });
+        }
+        else {
+            this.commandService.executeCommand('markdown.showPreview', current.messageUri).catch(err => {
+                this.notificationService.error(( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'testing.markdownPeekError',
+                    'Could not open markdown preview: {0}.\n\nPlease make sure the markdown extension is enabled.',
+                    err.message
+                )));
+            });
+        }
+    }
+    getActiveControl() {
+        const editor = getPeekedEditorFromFocus(this.codeEditorService);
+        const controller = editor && TestingOutputPeekController.get(editor);
+        return controller?.subject ?? this.viewsService.getActiveViewWithId("workbench.panel.testResults.view" )?.subject;
+    }
+    async showPeekFromUri(uri, editor, options) {
+        if (isCodeEditor(editor)) {
+            this.lastUri = uri;
+            TestingOutputPeekController.get(editor)?.show(buildTestUri(this.lastUri));
+            return true;
+        }
+        const pane = await this.editorService.openEditor({
+            resource: uri.documentUri,
+            options: { revealIfOpened: true, ...options }
+        });
+        const control = pane?.getControl();
+        if (!isCodeEditor(control)) {
+            return false;
+        }
+        this.lastUri = uri;
+        TestingOutputPeekController.get(control)?.show(buildTestUri(this.lastUri));
+        return true;
+    }
+    openPeekOnFailure(evt) {
+        if (evt.reason !== 1 ) {
+            return;
+        }
+        const candidate = this.getFailedCandidateMessage(evt.item);
+        if (!candidate) {
+            return;
+        }
+        if (evt.result.request.continuous && !getTestingConfiguration(this.configuration, "testing.automaticallyOpenPeekViewDuringAutoRun" )) {
+            return;
+        }
+        const editors = this.codeEditorService.listCodeEditors();
+        const cfg = getTestingConfiguration(this.configuration, "testing.automaticallyOpenPeekView" );
+        switch (cfg) {
+            case "failureInVisibleDocument" : {
+                const editorUris = ( new Set(( editors.map(e => e.getModel()?.uri.toString()))));
+                if (!( Iterable.some(resultItemParents(evt.result, evt.item), i => i.item.uri && ( editorUris.has(( i.item.uri.toString())))))) {
+                    return;
+                }
+                break;
+            }
+            case "failureAnywhere" :
+                break;
+            default:
+                return;
+        }
+        const controllers = ( editors.map(TestingOutputPeekController.get));
+        if (( controllers.some(c => c?.subject))) {
+            return;
+        }
+        this.tryPeekFirstError(evt.result, evt.item);
+    }
+    async getFileCandidateMessage(uri, position) {
+        let best;
+        let bestDistance = Infinity;
+        const demandedUriStr = ( uri.toString());
+        for (const test of this.testService.collection.all) {
+            const result = this.testResults.getStateById(test.item.extId);
+            if (!result) {
+                continue;
+            }
+            mapFindTestMessage(result[1], (_task, message, messageIndex, taskIndex) => {
+                if (message.type !== 0  || !message.location || ( message.location.uri.toString()) !== demandedUriStr) {
+                    return;
+                }
+                const distance = position ? Math.abs(position.lineNumber - message.location.range.startLineNumber) : 0;
+                if (!best || distance <= bestDistance) {
+                    bestDistance = distance;
+                    best = {
+                        type: 2 ,
+                        testExtId: result[1].item.extId,
+                        resultId: result[0].id,
+                        taskIndex,
+                        messageIndex,
+                        documentUri: uri,
+                    };
+                }
+            });
+        }
+        return best;
+    }
+    getAnyCandidateMessage() {
+        const seen = ( new Set());
+        for (const result of this.testResults.results) {
+            for (const test of result.tests) {
+                if (( seen.has(test.item.extId))) {
+                    continue;
+                }
+                seen.add(test.item.extId);
+                const found = mapFindTestMessage(test, (task, message, messageIndex, taskIndex) => (message.location && {
+                    type: 2 ,
+                    testExtId: test.item.extId,
+                    resultId: result.id,
+                    taskIndex,
+                    messageIndex,
+                    documentUri: message.location.uri,
+                }));
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    getFailedCandidateMessage(test) {
+        const fallbackLocation = test.item.uri && test.item.range
+            ? { uri: test.item.uri, range: test.item.range }
+            : undefined;
+        let best;
+        mapFindTestMessage(test, (task, message, messageIndex, taskId) => {
+            const location = message.location || fallbackLocation;
+            if (!isFailedState(task.state) || !location) {
+                return;
+            }
+            if (best && message.type !== 0 ) {
+                return;
+            }
+            best = { taskId, index: messageIndex, message, location };
+        });
+        return best;
+    }
+};
+TestingPeekOpener = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, ITestResultService)),
+    ( __param(4, ITestService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IViewsService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, INotificationService))
+], TestingPeekOpener));
+const mapFindTestMessage = (test, fn) => {
+    for (let taskIndex = 0; taskIndex < test.tasks.length; taskIndex++) {
+        const task = test.tasks[taskIndex];
+        for (let messageIndex = 0; messageIndex < task.messages.length; messageIndex++) {
+            const r = fn(task, task.messages[messageIndex], messageIndex, taskIndex);
+            if (r !== undefined) {
+                return r;
+            }
+        }
+    }
+    return undefined;
+};
+let TestingOutputPeekController = TestingOutputPeekController_1 = class TestingOutputPeekController extends Disposable {
+    static get(editor) {
+        return editor.getContribution("editor.contrib.testingOutputPeek" );
+    }
+    get subject() {
+        return this.peek.value?.current;
+    }
+    constructor(editor, codeEditorService, instantiationService, testResults, contextKeyService) {
+        super();
+        this.editor = editor;
+        this.codeEditorService = codeEditorService;
+        this.instantiationService = instantiationService;
+        this.testResults = testResults;
+        this.peek = this._register(( new MutableDisposable()));
+        this.visible = TestingContextKeys.isPeekVisible.bindTo(contextKeyService);
+        this._register(editor.onDidChangeModel(() => this.peek.clear()));
+        this._register(testResults.onResultsChanged(this.closePeekOnCertainResultEvents, this));
+        this._register(testResults.onTestChanged(this.closePeekOnTestChange, this));
+    }
+    toggle(uri) {
+        if (this.currentPeekUri?.toString() === ( uri.toString())) {
+            this.peek.clear();
+        }
+        else {
+            this.show(uri);
+        }
+    }
+    async show(uri) {
+        const subject = this.retrieveTest(uri);
+        if (!subject) {
+            return;
+        }
+        if (!this.peek.value) {
+            this.peek.value = this.instantiationService.createInstance(TestResultsPeek, this.editor);
+            this.peek.value.onDidClose(() => {
+                this.visible.set(false);
+                this.currentPeekUri = undefined;
+                this.peek.value = undefined;
+            });
+            this.visible.set(true);
+            this.peek.value.create();
+        }
+        if (subject instanceof MessageSubject) {
+            alert(renderTestMessageAsText(subject.message.message));
+        }
+        this.peek.value.setModel(subject);
+        this.currentPeekUri = uri;
+    }
+    async openAndShow(uri) {
+        const subject = this.retrieveTest(uri);
+        if (!subject) {
+            return;
+        }
+        if (!subject.revealLocation || ( subject.revealLocation.uri.toString()) === this.editor.getModel()?.uri.toString()) {
+            return this.show(uri);
+        }
+        const otherEditor = await this.codeEditorService.openCodeEditor({
+            resource: subject.revealLocation.uri,
+            options: { pinned: false, revealIfOpened: true }
+        }, this.editor);
+        if (otherEditor) {
+            TestingOutputPeekController_1.get(otherEditor)?.removePeek();
+            return TestingOutputPeekController_1.get(otherEditor)?.show(uri);
+        }
+    }
+    removePeek() {
+        this.peek.clear();
+    }
+    next() {
+        const subject = this.peek.value?.current;
+        if (!subject) {
+            return;
+        }
+        let found = false;
+        for (const { messageIndex, taskIndex, result, test } of allMessages(this.testResults.results)) {
+            if (subject instanceof TaskSubject && result.id === subject.result.id) {
+                found = true;
+            }
+            if (found) {
+                this.openAndShow(buildTestUri({
+                    type: 2 ,
+                    messageIndex,
+                    taskIndex,
+                    resultId: result.id,
+                    testExtId: test.item.extId
+                }));
+                return;
+            }
+            if (subject instanceof TestOutputSubject && subject.test.item.extId === test.item.extId && subject.taskIndex === taskIndex && subject.result.id === result.id) {
+                found = true;
+            }
+            if (subject instanceof MessageSubject && subject.test.extId === test.item.extId && subject.messageIndex === messageIndex && subject.taskIndex === taskIndex && subject.result.id === result.id) {
+                found = true;
+            }
+        }
+    }
+    previous() {
+        const subject = this.peek.value?.current;
+        if (!subject) {
+            return;
+        }
+        let previous;
+        for (const m of allMessages(this.testResults.results)) {
+            if (subject instanceof TaskSubject) {
+                if (m.result.id === subject.result.id) {
+                    break;
+                }
+                continue;
+            }
+            if (subject instanceof TestOutputSubject) {
+                if (m.test.item.extId === subject.test.item.extId && m.result.id === subject.result.id && m.taskIndex === subject.taskIndex) {
+                    break;
+                }
+                continue;
+            }
+            if (subject.test.extId === m.test.item.extId && subject.messageIndex === m.messageIndex && subject.taskIndex === m.taskIndex && subject.result.id === m.result.id) {
+                break;
+            }
+            previous = m;
+        }
+        if (previous) {
+            this.openAndShow(buildTestUri({
+                type: 2 ,
+                messageIndex: previous.messageIndex,
+                taskIndex: previous.taskIndex,
+                resultId: previous.result.id,
+                testExtId: previous.test.item.extId
+            }));
+        }
+    }
+    removeIfPeekingForTest(testId) {
+        const c = this.peek.value?.current;
+        if (c && c instanceof MessageSubject && c.test.extId === testId) {
+            this.peek.clear();
+        }
+    }
+    closePeekOnTestChange(evt) {
+        if (evt.reason !== 1  || evt.previousState === evt.item.ownComputedState) {
+            return;
+        }
+        this.removeIfPeekingForTest(evt.item.item.extId);
+    }
+    closePeekOnCertainResultEvents(evt) {
+        if ('started' in evt) {
+            this.peek.clear();
+        }
+        if ('removed' in evt && this.testResults.results.length === 0) {
+            this.peek.clear();
+        }
+    }
+    retrieveTest(uri) {
+        const parts = parseTestUri(uri);
+        if (!parts) {
+            return undefined;
+        }
+        const result = this.testResults.results.find(r => r.id === parts.resultId);
+        if (!result) {
+            return;
+        }
+        if (parts.type === 0 ) {
+            return ( new TaskSubject(result, parts.taskIndex));
+        }
+        if (parts.type === 1 ) {
+            const test = result.getStateById(parts.testExtId);
+            if (!test) {
+                return;
+            }
+            return ( new TestOutputSubject(result, parts.taskIndex, test));
+        }
+        const { testExtId, taskIndex, messageIndex } = parts;
+        const test = result?.getStateById(testExtId);
+        if (!test || !test.tasks[parts.taskIndex]) {
+            return;
+        }
+        return ( new MessageSubject(result, test, taskIndex, messageIndex));
+    }
+};
+TestingOutputPeekController = TestingOutputPeekController_1 = ( __decorate([
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITestResultService)),
+    ( __param(4, IContextKeyService))
+], TestingOutputPeekController));
+let TestResultsViewContent = class TestResultsViewContent extends Disposable {
+    static { TestResultsViewContent_1 = this; }
+    constructor(editor, options, instantiationService, modelService, contextKeyService) {
+        super();
+        this.editor = editor;
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.contextKeyService = contextKeyService;
+        this.didReveal = this._register(( new Emitter()));
+        this.currentSubjectStore = this._register(( new DisposableStore()));
+        this.contentProvidersUpdateLimiter = this._register(( new Limiter(1)));
+    }
+    fillBody(containerElement) {
+        const initialSpitWidth = TestResultsViewContent_1.lastSplitWidth;
+        this.splitView = ( new SplitView(containerElement, { orientation: 1  }));
+        const { historyVisible, showRevealLocationOnMessages } = this.options;
+        const isInPeekView = this.editor !== undefined;
+        const messageContainer = this.messageContainer = append(containerElement, $('.test-output-peek-message-container'));
+        this.contentProviders = [
+            this._register(this.instantiationService.createInstance(DiffContentProvider, this.editor, messageContainer)),
+            this._register(this.instantiationService.createInstance(MarkdownTestMessagePeek, messageContainer)),
+            this._register(this.instantiationService.createInstance(TerminalMessagePeek, messageContainer, isInPeekView)),
+            this._register(this.instantiationService.createInstance(PlainTextMessagePeek, this.editor, messageContainer)),
+        ];
+        this.messageContextKeyService = this._register(this.contextKeyService.createScoped(this.messageContainer));
+        this.contextKeyTestMessage = TestingContextKeys.testMessageContext.bindTo(this.messageContextKeyService);
+        this.contextKeyResultOutdated = TestingContextKeys.testResultOutdated.bindTo(this.messageContextKeyService);
+        const treeContainer = append(containerElement, $('.test-output-peek-tree'));
+        const tree = this._register(this.instantiationService.createInstance(OutputPeekTree, treeContainer, this.didReveal.event, { showRevealLocationOnMessages, locationForProgress: this.options.locationForProgress }));
+        this.onDidRequestReveal = tree.onDidRequestReview;
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: messageContainer,
+            minimumSize: 200,
+            maximumSize: Number.MAX_VALUE,
+            layout: width => {
+                TestResultsViewContent_1.lastSplitWidth = width;
+                if (this.dimension) {
+                    for (const provider of this.contentProviders) {
+                        provider.layout({ height: this.dimension.height, width });
+                    }
+                }
+            },
+        }, Sizing.Distribute);
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: treeContainer,
+            minimumSize: 100,
+            maximumSize: Number.MAX_VALUE,
+            layout: width => {
+                if (this.dimension) {
+                    tree.layout(this.dimension.height, width);
+                }
+            },
+        }, Sizing.Distribute);
+        const historyViewIndex = 1;
+        this.splitView.setViewVisible(historyViewIndex, historyVisible.value);
+        this._register(historyVisible.onDidChange(visible => {
+            this.splitView.setViewVisible(historyViewIndex, visible);
+        }));
+        if (initialSpitWidth) {
+            queueMicrotask(() => this.splitView.resizeView(0, initialSpitWidth));
+        }
+    }
+    reveal(opts) {
+        this.didReveal.fire(opts);
+        if (this.current && equalsSubject(this.current, opts.subject)) {
+            return Promise.resolve();
+        }
+        this.current = opts.subject;
+        return this.contentProvidersUpdateLimiter.queue(async () => {
+            await Promise.all(( this.contentProviders.map(p => p.update(opts.subject))));
+            this.currentSubjectStore.clear();
+            this.populateFloatingClick(opts.subject);
+        });
+    }
+    populateFloatingClick(subject) {
+        if (!(subject instanceof MessageSubject)) {
+            return;
+        }
+        this.currentSubjectStore.add(toDisposable(() => {
+            this.contextKeyResultOutdated.reset();
+            this.contextKeyTestMessage.reset();
+        }));
+        this.contextKeyTestMessage.set(subject.contextValue || '');
+        if (subject.result instanceof LiveTestResult) {
+            this.contextKeyResultOutdated.set(subject.result.getStateById(subject.test.extId)?.retired ?? false);
+            this.currentSubjectStore.add(subject.result.onChange(ev => {
+                if (ev.item.item.extId === subject.test.extId) {
+                    this.contextKeyResultOutdated.set(ev.item.retired ?? false);
+                }
+            }));
+        }
+        else {
+            this.contextKeyResultOutdated.set(true);
+        }
+        this.currentSubjectStore.add(this.instantiationService
+            .createChild(( new ServiceCollection([IContextKeyService, this.messageContextKeyService])))
+            .createInstance(FloatingClickMenu, {
+            container: this.messageContainer,
+            menuId: MenuId.TestMessageContent,
+            getActionArg: () => subject.context,
+        }));
+    }
+    onLayoutBody(height, width) {
+        this.dimension = new Dimension(width, height);
+        this.splitView.layout(width);
+    }
+    onWidth(width) {
+        this.splitView.layout(width);
+    }
+};
+TestResultsViewContent = TestResultsViewContent_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextModelService)),
+    ( __param(4, IContextKeyService))
+], TestResultsViewContent));
+let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
+    static { TestResultsPeek_1 = this; }
+    constructor(editor, themeService, peekViewService, testingPeek, contextKeyService, menuService, instantiationService, modelService) {
+        super(editor, { showFrame: true, frameWidth: 1, showArrow: true, isResizeable: true, isAccessible: true, className: 'test-output-peek' }, instantiationService);
+        this.themeService = themeService;
+        this.testingPeek = testingPeek;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.modelService = modelService;
+        this.visibilityChange = this._disposables.add(( new Emitter()));
+        this._disposables.add(themeService.onDidColorThemeChange(this.applyTheme, this));
+        this._disposables.add(this.onDidClose(() => this.visibilityChange.fire(false)));
+        peekViewService.addExclusiveWidget(editor, this);
+    }
+    applyTheme() {
+        const theme = this.themeService.getColorTheme();
+        const isError = this.current instanceof MessageSubject && this.current.message.type === 0 ;
+        const borderColor = (isError ? theme.getColor(testingPeekBorder) : theme.getColor(testingMessagePeekBorder)) || Color.transparent;
+        const headerBg = (isError ? theme.getColor(testingPeekHeaderBackground) : theme.getColor(testingPeekMessageHeaderBackground)) || Color.transparent;
+        const editorBg = theme.getColor(editorBackground);
+        this.style({
+            arrowColor: borderColor,
+            frameColor: borderColor,
+            headerBackgroundColor: editorBg && headerBg ? headerBg.makeOpaque(editorBg) : headerBg,
+            primaryHeadingColor: theme.getColor(peekViewTitleForeground),
+            secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
+        });
+    }
+    _fillContainer(container) {
+        if (!this.scopedContextKeyService) {
+            this.scopedContextKeyService = this._disposables.add(this.contextKeyService.createScoped(container));
+            TestingContextKeys.isInPeek.bindTo(this.scopedContextKeyService).set(true);
+            const instaService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+            this.content = this._disposables.add(instaService.createInstance(TestResultsViewContent, this.editor, { historyVisible: this.testingPeek.historyVisible, showRevealLocationOnMessages: false, locationForProgress: "workbench.panel.testResults.view"  }));
+        }
+        super._fillContainer(container);
+    }
+    _fillHead(container) {
+        super._fillHead(container);
+        const actions = [];
+        const menu = this.menuService.createMenu(MenuId.TestPeekTitle, this.contextKeyService);
+        createAndFillInActionBarActions(menu, undefined, actions);
+        this._actionbarWidget.push(actions, { label: false, icon: true, index: 0 });
+        menu.dispose();
+    }
+    _fillBody(containerElement) {
+        this.content.fillBody(containerElement);
+        this.content.onDidRequestReveal(sub => {
+            TestingOutputPeekController.get(this.editor)?.show(sub instanceof MessageSubject
+                ? sub.messageUri
+                : sub.outputUri);
+        });
+    }
+    setModel(subject) {
+        if (subject instanceof TaskSubject || subject instanceof TestOutputSubject) {
+            this.current = subject;
+            return this.showInPlace(subject);
+        }
+        const message = subject.message;
+        const previous = this.current;
+        if (!subject.revealLocation && !previous) {
+            return Promise.resolve();
+        }
+        this.current = subject;
+        if (!subject.revealLocation) {
+            return this.showInPlace(subject);
+        }
+        this.show(subject.revealLocation.range, TestResultsPeek_1.lastHeightInLines || hintMessagePeekHeight(message));
+        const startPosition = subject.revealLocation.range.getStartPosition();
+        this.editor.revealRangeNearTopIfOutsideViewport(Range.fromPositions(startPosition), 0 );
+        return this.showInPlace(subject);
+    }
+    async showInPlace(subject) {
+        if (subject instanceof MessageSubject) {
+            const message = subject.message;
+            this.setTitle(firstLine(renderTestMessageAsText(message.message)), stripIcons(subject.test.label));
+        }
+        else {
+            this.setTitle(( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testOutputTitle',
+                'Test Output'
+            )));
+        }
+        this.applyTheme();
+        await this.content.reveal({ subject: subject, preserveFocus: false });
+    }
+    _relayout(newHeightInLines) {
+        super._relayout(newHeightInLines);
+        TestResultsPeek_1.lastHeightInLines = newHeightInLines;
+    }
+    _doLayoutBody(height, width) {
+        super._doLayoutBody(height, width);
+        this.content.onLayoutBody(height, width);
+    }
+    _onWidth(width) {
+        super._onWidth(width);
+        if (this.dimension) {
+            this.dimension = new Dimension(width, this.dimension.height);
+        }
+        this.content.onWidth(width);
+    }
+};
+TestResultsPeek = TestResultsPeek_1 = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IPeekViewService)),
+    ( __param(3, ITestingPeekOpener)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IMenuService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ITextModelService))
+], TestResultsPeek));
+let TestResultsView = class TestResultsView extends ViewPane {
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, resultService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.resultService = resultService;
+        this.content = ( new Lazy(
+            () => this._register(this.instantiationService.createInstance(TestResultsViewContent, undefined, {
+                historyVisible: staticObservableValue(true),
+                showRevealLocationOnMessages: true,
+                locationForProgress: "workbench.view.testing" ,
+            }))
+        ));
+    }
+    get subject() {
+        return this.content.rawValue?.current;
+    }
+    showLatestRun(preserveFocus = false) {
+        const result = this.resultService.results.find(r => r.tasks.length);
+        if (!result) {
+            return;
+        }
+        this.content.rawValue?.reveal({ preserveFocus, subject: ( new TaskSubject(result, 0)) });
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        if (this.isBodyVisible()) {
+            this.renderContent(container);
+        }
+        else {
+            this._register(Event.once(Event.filter(this.onDidChangeBodyVisibility, Boolean))(() => this.renderContent(container)));
+        }
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.content.rawValue?.onLayoutBody(height, width);
+    }
+    renderContent(container) {
+        const content = this.content.value;
+        content.fillBody(container);
+        content.onDidRequestReveal(subject => content.reveal({ preserveFocus: true, subject }));
+        const [lastResult] = this.resultService.results;
+        if (lastResult && lastResult.tasks.length) {
+            content.reveal({ preserveFocus: true, subject: ( new TaskSubject(lastResult, 0)) });
+        }
+    }
+};
+TestResultsView = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, ITestResultService))
+], TestResultsView));
+const commonEditorOptions = {
+    scrollBeyondLastLine: false,
+    links: true,
+    lineNumbers: 'off',
+    scrollbar: {
+        verticalScrollbarSize: 14,
+        horizontal: 'auto',
+        useShadows: true,
+        verticalHasArrows: false,
+        horizontalHasArrows: false,
+        alwaysConsumeMouseWheel: false
+    },
+    fixedOverflowWidgets: true,
+    readOnly: true,
+    minimap: {
+        enabled: false
+    },
+    wordWrap: 'on',
+};
+const diffEditorOptions = {
+    ...commonEditorOptions,
+    enableSplitViewResizing: true,
+    isInEmbeddedEditor: true,
+    renderOverviewRuler: false,
+    ignoreTrimWhitespace: false,
+    renderSideBySide: true,
+    useInlineViewWhenSpaceIsLimited: false,
+    originalAriaLabel: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingOutputPeek',
+        'testingOutputExpected',
+        'Expected result'
+    )),
+    modifiedAriaLabel: ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testingOutputPeek',
+        'testingOutputActual',
+        'Actual result'
+    )),
+    diffAlgorithm: 'advanced',
+};
+const isDiffable = (message) => message.type === 0  && message.actual !== undefined && message.expected !== undefined;
+let DiffContentProvider = class DiffContentProvider extends Disposable {
+    constructor(editor, container, instantiationService, modelService) {
+        super();
+        this.editor = editor;
+        this.container = container;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.widget = this._register(( new MutableDisposable()));
+        this.model = this._register(( new MutableDisposable()));
+    }
+    async update(subject) {
+        if (!(subject instanceof MessageSubject)) {
+            return this.clear();
+        }
+        const message = subject.message;
+        if (!isDiffable(message)) {
+            return this.clear();
+        }
+        const [original, modified] = await Promise.all([
+            this.modelService.createModelReference(subject.expectedUri),
+            this.modelService.createModelReference(subject.actualUri),
+        ]);
+        const model = this.model.value = ( new SimpleDiffEditorModel(original, modified));
+        if (!this.widget.value) {
+            this.widget.value = this.editor ? this.instantiationService.createInstance(EmbeddedDiffEditorWidget, this.container, diffEditorOptions, {}, this.editor) : this.instantiationService.createInstance(DiffEditorWidget, this.container, diffEditorOptions, {});
+            if (this.dimension) {
+                this.widget.value.layout(this.dimension);
+            }
+        }
+        this.widget.value.setModel(model);
+        this.widget.value.updateOptions(this.getOptions(isMultiline(message.expected) || isMultiline(message.actual)));
+    }
+    clear() {
+        this.model.clear();
+        this.widget.clear();
+    }
+    layout(dimensions) {
+        this.dimension = dimensions;
+        this.widget.value?.layout(dimensions);
+    }
+    getOptions(isMultiline) {
+        return isMultiline
+            ? { ...diffEditorOptions, lineNumbers: 'on' }
+            : { ...diffEditorOptions, lineNumbers: 'off' };
+    }
+};
+DiffContentProvider = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextModelService))
+], DiffContentProvider));
+class ScrollableMarkdownMessage extends Disposable {
+    constructor(container, markdown, message) {
+        super();
+        const rendered = this._register(markdown.render(message, {}));
+        rendered.element.style.height = '100%';
+        rendered.element.style.userSelect = 'text';
+        container.appendChild(rendered.element);
+        this.element = rendered.element;
+        this.scrollable = this._register(( new DomScrollableElement(rendered.element, {
+            className: 'preview-text',
+        })));
+        container.appendChild(this.scrollable.getDomNode());
+        this._register(toDisposable(() => {
+            container.removeChild(this.scrollable.getDomNode());
+        }));
+        this.scrollable.scanDomNode();
+    }
+    layout(height, width) {
+        this.scrollable.setScrollDimensions({
+            width: width - 32,
+            height: height - 16,
+            scrollWidth: this.element.scrollWidth,
+            scrollHeight: this.element.scrollHeight
+        });
+    }
+}
+let MarkdownTestMessagePeek = class MarkdownTestMessagePeek extends Disposable {
+    constructor(container, instantiationService) {
+        super();
+        this.container = container;
+        this.instantiationService = instantiationService;
+        this.markdown = ( new Lazy(
+            () => this._register(this.instantiationService.createInstance(MarkdownRenderer, {}))
+        ));
+        this.textPreview = this._register(( new MutableDisposable()));
+    }
+    update(subject) {
+        if (!(subject instanceof MessageSubject)) {
+            return this.textPreview.clear();
+        }
+        const message = subject.message;
+        if (isDiffable(message) || typeof message.message === 'string') {
+            return this.textPreview.clear();
+        }
+        this.textPreview.value = ( new ScrollableMarkdownMessage(this.container, this.markdown.value, message.message));
+    }
+    layout(dimension) {
+        this.textPreview.value?.layout(dimension.height, dimension.width);
+    }
+};
+MarkdownTestMessagePeek = ( __decorate([
+    ( __param(1, IInstantiationService))
+], MarkdownTestMessagePeek));
+let PlainTextMessagePeek = class PlainTextMessagePeek extends Disposable {
+    constructor(editor, container, instantiationService, modelService) {
+        super();
+        this.editor = editor;
+        this.container = container;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.widgetDecorations = this._register(( new MutableDisposable()));
+        this.widget = this._register(( new MutableDisposable()));
+        this.model = this._register(( new MutableDisposable()));
+    }
+    async update(subject) {
+        if (!(subject instanceof MessageSubject)) {
+            return this.clear();
+        }
+        const message = subject.message;
+        if (isDiffable(message) || message.type === 1  || typeof message.message !== 'string') {
+            return this.clear();
+        }
+        const modelRef = this.model.value = await this.modelService.createModelReference(subject.messageUri);
+        if (!this.widget.value) {
+            this.widget.value = this.editor ? this.instantiationService.createInstance(EmbeddedCodeEditorWidget, this.container, commonEditorOptions, {}, this.editor) : this.instantiationService.createInstance(CodeEditorWidget, this.container, commonEditorOptions, { isSimpleWidget: true });
+            if (this.dimension) {
+                this.widget.value.layout(this.dimension);
+            }
+        }
+        this.widget.value.setModel(modelRef.object.textEditorModel);
+        this.widget.value.updateOptions(commonEditorOptions);
+        this.widgetDecorations.value = colorizeTestMessageInEditor(message.message, this.widget.value);
+    }
+    clear() {
+        this.widgetDecorations.clear();
+        this.widget.clear();
+        this.model.clear();
+    }
+    layout(dimensions) {
+        this.dimension = dimensions;
+        this.widget.value?.layout(dimensions);
+    }
+};
+PlainTextMessagePeek = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextModelService))
+], PlainTextMessagePeek));
+let TerminalMessagePeek = class TerminalMessagePeek extends Disposable {
+    constructor(container, isInPeekView, terminalService, viewDescriptorService, workspaceContext) {
+        super();
+        this.container = container;
+        this.isInPeekView = isInPeekView;
+        this.terminalService = terminalService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.workspaceContext = workspaceContext;
+        this.terminalCwd = this._register(( new MutableObservableValue('')));
+        this.xtermLayoutDelayer = this._register(( new Delayer(50)));
+        this.terminal = this._register(( new MutableDisposable()));
+        this.outputDataListener = this._register(( new MutableDisposable()));
+    }
+    async makeTerminal() {
+        const prev = this.terminal.value;
+        if (prev) {
+            prev.xterm.clearBuffer();
+            prev.xterm.clearSearchDecorations();
+            prev.xterm.write(`\x1b[2J\x1b[0;0H`);
+            return prev;
+        }
+        const capabilities = ( new TerminalCapabilityStore());
+        const cwd = this.terminalCwd;
+        capabilities.add(0 , {
+            type: 0 ,
+            get cwds() { return [cwd.value]; },
+            onDidChangeCwd: cwd.onDidChange,
+            getCwd: () => cwd.value,
+            updateCwd: () => { },
+        });
+        return this.terminal.value = await this.terminalService.createDetachedTerminal({
+            rows: 10,
+            cols: 80,
+            readonly: true,
+            capabilities,
+            processInfo: ( new DetachedProcessInfo({ initialCwd: cwd.value })),
+            colorProvider: {
+                getBackgroundColor: theme => {
+                    const terminalBackground = theme.getColor(TERMINAL_BACKGROUND_COLOR);
+                    if (terminalBackground) {
+                        return terminalBackground;
+                    }
+                    if (this.isInPeekView) {
+                        return theme.getColor(peekViewResultsBackground);
+                    }
+                    const location = this.viewDescriptorService.getViewLocationById("workbench.panel.testResults.view" );
+                    return location === 1
+                        ? theme.getColor(PANEL_BACKGROUND)
+                        : theme.getColor(SIDE_BAR_BACKGROUND);
+                },
+            }
+        });
+    }
+    async update(subject) {
+        this.outputDataListener.clear();
+        if (subject instanceof TaskSubject) {
+            await this.updateForTaskSubject(subject);
+        }
+        else if (subject instanceof TestOutputSubject || ((subject instanceof MessageSubject && subject.message.type === 1) )) {
+            await this.updateForTestSubject(subject);
+        }
+        else {
+            this.clear();
+        }
+    }
+    async updateForTestSubject(subject) {
+        const that = this;
+        const testItem = subject instanceof TestOutputSubject ? subject.test.item : subject.test;
+        const terminal = await this.updateGenerically({
+            subject,
+            noOutputMessage: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'caseNoOutput',
+                'The test case did not report any output.'
+            )),
+            getTarget: result => result?.tasks[subject.taskIndex].output,
+            *doInitialWrite(output, results) {
+                that.updateCwd(testItem.uri);
+                const state = subject instanceof TestOutputSubject ? subject.test : results.getStateById(testItem.extId);
+                if (!state) {
+                    return;
+                }
+                for (const message of state.tasks[subject.taskIndex].messages) {
+                    if (message.type === 1 ) {
+                        yield* output.getRangeIter(message.offset, message.length);
+                    }
+                }
+            },
+            doListenForMoreData: (output, result, write) => result.onChange(e => {
+                if (e.reason === 2  && e.item.item.extId === testItem.extId && e.message.type === 1 ) {
+                    for (const chunk of output.getRangeIter(e.message.offset, e.message.length)) {
+                        write(chunk.buffer);
+                    }
+                }
+            }),
+        });
+        if (subject instanceof MessageSubject && subject.message.type === 1  && subject.message.marker !== undefined) {
+            terminal?.xterm.selectMarkedRange(getMarkId(subject.message.marker, true), getMarkId(subject.message.marker, false),  true);
+        }
+    }
+    updateForTaskSubject(subject) {
+        return this.updateGenerically({
+            subject,
+            noOutputMessage: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'runNoOutput',
+                'The test run did not record any output.'
+            )),
+            getTarget: result => result?.tasks[subject.taskIndex],
+            doInitialWrite: (task, result) => {
+                this.updateCwd(Iterable.find(result.tests, t => !!t.item.uri)?.item.uri);
+                return task.output.buffers;
+            },
+            doListenForMoreData: (task, _result, write) => task.output.onDidWriteData(e => write(e.buffer)),
+        });
+    }
+    async updateGenerically(opts) {
+        const result = opts.subject.result;
+        const target = opts.getTarget(result);
+        if (!target) {
+            return this.clear();
+        }
+        const terminal = await this.makeTerminal();
+        let didWriteData = false;
+        const pendingWrites = ( new MutableObservableValue(0));
+        if (result instanceof LiveTestResult) {
+            for (const chunk of opts.doInitialWrite(target, result)) {
+                didWriteData ||= chunk.byteLength > 0;
+                pendingWrites.value++;
+                terminal.xterm.write(chunk.buffer, () => pendingWrites.value--);
+            }
+        }
+        else {
+            didWriteData = true;
+            this.writeNotice(terminal, ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'runNoOutputForPast',
+                'Test output is only available for new test runs.'
+            )));
+        }
+        this.attachTerminalToDom(terminal);
+        this.outputDataListener.clear();
+        if (result instanceof LiveTestResult && !result.completedAt) {
+            const l1 = result.onComplete(() => {
+                if (!didWriteData) {
+                    this.writeNotice(terminal, opts.noOutputMessage);
+                }
+            });
+            const l2 = opts.doListenForMoreData(target, result, data => {
+                terminal.xterm.write(data);
+                didWriteData ||= data.byteLength > 0;
+            });
+            this.outputDataListener.value = combinedDisposable(l1, l2);
+        }
+        if (!this.outputDataListener.value && !didWriteData) {
+            this.writeNotice(terminal, opts.noOutputMessage);
+        }
+        if (pendingWrites.value > 0) {
+            await ( new Promise(resolve => {
+                const l = pendingWrites.onDidChange(() => {
+                    if (pendingWrites.value === 0) {
+                        l.dispose();
+                        resolve();
+                    }
+                });
+            }));
+        }
+        return terminal;
+    }
+    updateCwd(testUri) {
+        const wf = (testUri && this.workspaceContext.getWorkspaceFolder(testUri))
+            || this.workspaceContext.getWorkspace().folders[0];
+        if (wf) {
+            this.terminalCwd.value = wf.uri.fsPath;
+        }
+    }
+    writeNotice(terminal, str) {
+        terminal.xterm.write(formatMessageForTerminal(str));
+    }
+    attachTerminalToDom(terminal) {
+        terminal.xterm.write('\x1b[?25l');
+        scheduleAtNextAnimationFrame(getWindow(this.container), () => this.layoutTerminal(terminal));
+        terminal.attachToElement(this.container, { enableGpu: false });
+    }
+    clear() {
+        this.outputDataListener.clear();
+        this.xtermLayoutDelayer.cancel();
+        this.terminal.clear();
+    }
+    layout(dimensions) {
+        this.dimensions = dimensions;
+        if (this.terminal.value) {
+            this.layoutTerminal(this.terminal.value, dimensions.width, dimensions.height);
+        }
+    }
+    layoutTerminal({ xterm }, width = this.dimensions?.width ?? this.container.clientWidth, height = this.dimensions?.height ?? this.container.clientHeight) {
+        width -= 10 + 20;
+        this.xtermLayoutDelayer.trigger(() => {
+            const scaled = getXtermScaledDimensions(getWindow(this.container), xterm.getFont(), width, height);
+            if (scaled) {
+                xterm.resize(scaled.cols, scaled.rows);
+            }
+        });
+    }
+};
+TerminalMessagePeek = ( __decorate([
+    ( __param(2, ITerminalService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, IWorkspaceContextService))
+], TerminalMessagePeek));
+const hintMessagePeekHeight = (msg) => {
+    const msgHeight = isDiffable(msg)
+        ? Math.max(hintPeekStrHeight(msg.actual), hintPeekStrHeight(msg.expected))
+        : hintPeekStrHeight(typeof msg.message === 'string' ? msg.message : msg.message.value);
+    return msgHeight + 8;
+};
+const firstLine = (str) => {
+    const index = str.indexOf('\n');
+    return index === -1 ? str : str.slice(0, index);
+};
+const isMultiline = (str) => !!str && str.includes('\n');
+const hintPeekStrHeight = (str) => Math.min(count(str, '\n'), 24);
+class SimpleDiffEditorModel extends EditorModel {
+    constructor(_original, _modified) {
+        super();
+        this._original = _original;
+        this._modified = _modified;
+        this.original = this._original.object.textEditorModel;
+        this.modified = this._modified.object.textEditorModel;
+    }
+    dispose() {
+        super.dispose();
+        this._original.dispose();
+        this._modified.dispose();
+    }
+}
+function getOuterEditorFromDiffEditor(codeEditorService) {
+    const diffEditors = codeEditorService.listDiffEditors();
+    for (const diffEditor of diffEditors) {
+        if (diffEditor.hasTextFocus() && diffEditor instanceof EmbeddedDiffEditorWidget) {
+            return diffEditor.getParentEditor();
+        }
+    }
+    return null;
+}
+class CloseTestPeek extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.closeTestPeek',
+            title: ( localizeWithPath('vs/workbench/contrib/testing/browser/testingOutputPeek', 'close', 'Close')),
+            icon: Codicon.close,
+            precondition: ( ContextKeyExpr.or(TestingContextKeys.isInPeek, TestingContextKeys.isPeekVisible)),
+            keybinding: {
+                weight: 100  - 101,
+                primary: 9 ,
+                when: ContextKeyExpr.not('config.editor.stablePeek')
+            }
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        const parent = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
+        TestingOutputPeekController.get(parent ?? editor)?.removePeek();
+    }
+}
+class TestResultElement {
+    get icon() {
+        return testingStatesToIcons.get(this.value.completedAt === undefined
+            ? 2
+            : maxCountPriority(this.value.counts));
+    }
+    constructor(value) {
+        this.value = value;
+        this.changeEmitter = ( new Emitter());
+        this.onDidChange = this.changeEmitter.event;
+        this.type = 'result';
+        this.context = this.value.id;
+        this.id = this.value.id;
+        this.label = this.value.name;
+    }
+}
+const openCoverageLabel = ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+    'openTestCoverage',
+    'View Test Coverage'
+));
+const closeCoverageLabel = ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+    'closeTestCoverage',
+    'Close Test Coverage'
+));
+class CoverageElement {
+    get label() {
+        return this.isOpen ? closeCoverageLabel : openCoverageLabel;
+    }
+    get icon() {
+        return this.isOpen ? widgetClose : testingCoverageReport;
+    }
+    get isOpen() {
+        return this.coverageService.selected.get()?.fromTaskId === this.task.id;
+    }
+    constructor(results, task, coverageService) {
+        this.results = results;
+        this.task = task;
+        this.coverageService = coverageService;
+        this.type = 'coverage';
+        this.id = `coverage-${this.results.id}/${this.task.id}`;
+        this.onDidChange = Event.fromObservableLight(coverageService.selected);
+    }
+}
+class TestCaseElement {
+    get onDidChange() {
+        if (!(this.results instanceof LiveTestResult)) {
+            return Event.None;
+        }
+        return Event.filter(this.results.onChange, e => e.item.item.extId === this.test.item.extId);
+    }
+    get state() {
+        return this.test.tasks[this.taskIndex].state;
+    }
+    get label() {
+        return this.test.item.label;
+    }
+    get labelWithIcons() {
+        return renderLabelWithIcons(this.label);
+    }
+    get icon() {
+        return testingStatesToIcons.get(this.state);
+    }
+    get outputSubject() {
+        return ( new TestOutputSubject(this.results, this.taskIndex, this.test));
+    }
+    constructor(results, test, taskIndex) {
+        this.results = results;
+        this.test = test;
+        this.taskIndex = taskIndex;
+        this.type = 'test';
+        this.context = {
+            $mid: 16 ,
+            tests: [InternalTestItem.serialize(this.test)],
+        };
+        this.id = `${this.results.id}/${this.test.item.extId}`;
+    }
+}
+class TaskElement {
+    get icon() {
+        return this.results.tasks[this.index].running ? testingStatesToIcons.get(2 ) : undefined;
+    }
+    constructor(results, task, index) {
+        this.results = results;
+        this.task = task;
+        this.index = index;
+        this.changeEmitter = ( new Emitter());
+        this.onDidChange = this.changeEmitter.event;
+        this.type = 'task';
+        this.itemsCache = ( new CreationCache());
+        this.id = `${results.id}/${index}`;
+        this.task = results.tasks[index];
+        this.context = String(index);
+        this.label = this.task.name ?? ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingOutputPeek',
+            'testUnnamedTask',
+            'Unnamed Task'
+        ));
+    }
+}
+class TestMessageElement {
+    get onDidChange() {
+        if (!(this.result instanceof LiveTestResult)) {
+            return Event.None;
+        }
+        return Event.filter(this.result.onChange, e => e.item.item.extId === this.test.item.extId);
+    }
+    get context() {
+        return getMessageArgs(this.test, this.message);
+    }
+    get outputSubject() {
+        return ( new TestOutputSubject(this.result, this.taskIndex, this.test));
+    }
+    constructor(result, test, taskIndex, messageIndex) {
+        this.result = result;
+        this.test = test;
+        this.taskIndex = taskIndex;
+        this.messageIndex = messageIndex;
+        this.type = 'message';
+        const m = this.message = test.tasks[taskIndex].messages[messageIndex];
+        this.location = m.location;
+        this.contextValue = m.type === 0  ? m.contextValue : undefined;
+        this.uri = buildTestUri({
+            type: 2 ,
+            messageIndex,
+            resultId: result.id,
+            taskIndex,
+            testExtId: test.item.extId
+        });
+        this.id = ( this.uri.toString());
+        const asPlaintext = renderTestMessageAsText(m.message);
+        const lines = count(asPlaintext.trimEnd(), '\n');
+        this.label = firstLine(asPlaintext);
+        if (lines > 0) {
+            this.description = lines > 1
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'messageMoreLinesN',
+                '+ {0} more lines',
+                lines
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'messageMoreLines1',
+                '+ 1 more line'
+            ));
+        }
+    }
+}
+let OutputPeekTree = class OutputPeekTree extends Disposable {
+    constructor(container, onDidReveal, options, contextMenuService, results, instantiationService, explorerFilter, coverageService, progressService) {
+        super();
+        this.contextMenuService = contextMenuService;
+        this.disposed = false;
+        this.requestReveal = this._register(( new Emitter()));
+        this.onDidRequestReview = this.requestReveal.event;
+        this.treeActions = instantiationService.createInstance(TreeActionsProvider, options.showRevealLocationOnMessages, this.requestReveal);
+        const diffIdentityProvider = {
+            getId(e) {
+                return e.id;
+            }
+        };
+        this.tree = this._register(instantiationService.createInstance(WorkbenchCompressibleObjectTree, 'Test Output Peek', container, {
+            getHeight: () => 22,
+            getTemplateId: () => TestRunElementRenderer.ID,
+        }, [instantiationService.createInstance(TestRunElementRenderer, this.treeActions)], {
+            compressionEnabled: true,
+            hideTwistiesOfChildlessElements: true,
+            identityProvider: diffIdentityProvider,
+            sorter: {
+                compare(a, b) {
+                    if (a instanceof TestCaseElement && b instanceof TestCaseElement) {
+                        return cmpPriority(a.state, b.state);
+                    }
+                    return 0;
+                },
+            },
+            accessibilityProvider: {
+                getAriaLabel(element) {
+                    return element.ariaLabel || element.label;
+                },
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                        'testingPeekLabel',
+                        'Test Result Messages'
+                    ));
+                }
+            }
+        }));
+        const cc = ( new CreationCache());
+        const getTaskChildren = (taskElem) => {
+            const { results, index, itemsCache, task } = taskElem;
+            const tests = Iterable.filter(results.tests, test => test.tasks[index].state >= 2  || test.tasks[index].messages.length > 0);
+            let result = ( Iterable.map(tests, test => ({
+                element: itemsCache.getOrCreate(test, () => ( new TestCaseElement(results, test, index))),
+                incompressible: true,
+                children: getTestChildren(results, test, index),
+            })));
+            if (task.coverage.get()) {
+                result = Iterable.concat(Iterable.single({
+                    element: ( new CoverageElement(results, task, coverageService)),
+                    incompressible: true,
+                }), result);
+            }
+            return result;
+        };
+        const getTestChildren = (result, test, taskIndex) => {
+            return ( test.tasks[taskIndex].messages
+                .map((m, messageIndex) => m.type === 0
+                ? { element: cc.getOrCreate(m, () => ( new TestMessageElement(result, test, taskIndex, messageIndex))), incompressible: false }
+                : undefined))
+                .filter(isDefined);
+        };
+        const getResultChildren = (result) => {
+            return ( result.tasks.map((task, taskIndex) => {
+                const taskElem = cc.getOrCreate(task, () => ( new TaskElement(result, task, taskIndex)));
+                return ({
+                    element: taskElem,
+                    incompressible: false,
+                    children: getTaskChildren(taskElem),
+                });
+            }));
+        };
+        const getRootChildren = () => ( results.results.map(result => {
+            const element = cc.getOrCreate(result, () => ( new TestResultElement(result)));
+            return {
+                element,
+                incompressible: true,
+                collapsed: this.tree.hasElement(element) ? this.tree.isCollapsed(element) : true,
+                children: getResultChildren(result)
+            };
+        }));
+        const taskChildrenToUpdate = ( new Set());
+        const taskChildrenUpdate = this._register(( new RunOnceScheduler(() => {
+            for (const taskNode of taskChildrenToUpdate) {
+                if (this.tree.hasElement(taskNode)) {
+                    this.tree.setChildren(taskNode, getTaskChildren(taskNode), { diffIdentityProvider });
+                }
+            }
+            taskChildrenToUpdate.clear();
+        }, 300)));
+        const queueTaskChildrenUpdate = (taskNode) => {
+            taskChildrenToUpdate.add(taskNode);
+            if (!taskChildrenUpdate.isScheduled()) {
+                taskChildrenUpdate.schedule();
+            }
+        };
+        const attachToResults = (result) => {
+            const resultNode = cc.get(result);
+            const disposable = ( new DisposableStore());
+            disposable.add(result.onNewTask(i => {
+                if (result.tasks.length === 1) {
+                    this.requestReveal.fire(( new TaskSubject(result, 0)));
+                }
+                if (this.tree.hasElement(resultNode)) {
+                    this.tree.setChildren(resultNode, getResultChildren(result), { diffIdentityProvider });
+                }
+                const task = result.tasks[i];
+                disposable.add(autorun(reader => {
+                    task.coverage.read(reader);
+                    queueTaskChildrenUpdate(cc.get(task));
+                }));
+            }));
+            disposable.add(result.onEndTask(index => {
+                cc.get(result.tasks[index])?.changeEmitter.fire();
+            }));
+            disposable.add(result.onChange(e => {
+                for (const [index, task] of result.tasks.entries()) {
+                    const taskNode = cc.get(task);
+                    if (!this.tree.hasElement(taskNode)) {
+                        continue;
+                    }
+                    const itemNode = taskNode.itemsCache.get(e.item);
+                    if (itemNode && this.tree.hasElement(itemNode)) {
+                        if (e.reason === 2  && e.message.type === 0 ) {
+                            this.tree.setChildren(itemNode, getTestChildren(result, e.item, index), { diffIdentityProvider });
+                        }
+                        return;
+                    }
+                    queueTaskChildrenUpdate(taskNode);
+                }
+            }));
+            disposable.add(result.onComplete(() => {
+                resultNode.changeEmitter.fire();
+                disposable.dispose();
+            }));
+            return resultNode;
+        };
+        this._register(results.onResultsChanged(e => {
+            if (this.disposed) {
+                return;
+            }
+            if ('completed' in e) {
+                cc.get(e.completed)?.changeEmitter.fire();
+                return;
+            }
+            this.tree.setChildren(null, getRootChildren(), { diffIdentityProvider });
+            if ('started' in e) {
+                for (const child of this.tree.getNode(null).children) {
+                    this.tree.collapse(child.element, false);
+                }
+                this.tree.expand(attachToResults(e.started), true);
+            }
+        }));
+        const revealItem = (element, preserveFocus) => {
+            this.tree.setFocus([element]);
+            this.tree.setSelection([element]);
+            if (!preserveFocus) {
+                this.tree.domFocus();
+            }
+        };
+        this._register(onDidReveal(async ({ subject, preserveFocus = false }) => {
+            if (subject instanceof TaskSubject) {
+                const resultItem = this.tree.getNode(null).children.find(c => {
+                    if (c.element instanceof TaskElement) {
+                        return c.element.results.id === subject.result.id && c.element.index === subject.taskIndex;
+                    }
+                    if (c.element instanceof TestResultElement) {
+                        return c.element.id === subject.result.id;
+                    }
+                    return false;
+                });
+                if (resultItem) {
+                    revealItem(resultItem.element, preserveFocus);
+                }
+                return;
+            }
+            const revealElement = subject instanceof TestOutputSubject
+                ? cc.get(subject.task)?.itemsCache.get(subject.test)
+                : cc.get(subject.message);
+            if (!revealElement || !this.tree.hasElement(revealElement)) {
+                return;
+            }
+            const parents = [];
+            for (let parent = this.tree.getParentElement(revealElement); parent; parent = this.tree.getParentElement(parent)) {
+                parents.unshift(parent);
+            }
+            for (const parent of parents) {
+                this.tree.expand(parent);
+            }
+            if (this.tree.getRelativeTop(revealElement) === null) {
+                this.tree.reveal(revealElement, 0.5);
+            }
+            revealItem(revealElement, preserveFocus);
+        }));
+        this._register(this.tree.onDidOpen(async (e) => {
+            if (e.element instanceof TestMessageElement) {
+                this.requestReveal.fire(( new MessageSubject(
+                    e.element.result,
+                    e.element.test,
+                    e.element.taskIndex,
+                    e.element.messageIndex
+                )));
+            }
+            else if (e.element instanceof TestCaseElement) {
+                const t = e.element;
+                const message = mapFindTestMessage(e.element.test, (_t, _m, mesasgeIndex, taskIndex) => ( new MessageSubject(t.results, t.test, taskIndex, mesasgeIndex)));
+                this.requestReveal.fire(message || ( new TestOutputSubject(t.results, 0, t.test)));
+            }
+            else if (e.element instanceof CoverageElement) {
+                const task = e.element.task;
+                if (e.element.isOpen) {
+                    return coverageService.closeCoverage();
+                }
+                progressService.withProgress({ location: options.locationForProgress }, () => coverageService.openCoverage(task, true));
+            }
+        }));
+        this._register(this.tree.onDidChangeSelection(evt => {
+            for (const element of evt.elements) {
+                if (element && 'test' in element) {
+                    explorerFilter.reveal.value = element.test.item.extId;
+                    break;
+                }
+            }
+        }));
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        this.tree.setChildren(null, getRootChildren());
+        for (const result of results.results) {
+            if (!result.completedAt && result instanceof LiveTestResult) {
+                attachToResults(result);
+            }
+        }
+    }
+    layout(height, width) {
+        this.tree.layout(height, width);
+    }
+    onContextMenu(evt) {
+        if (!evt.element) {
+            return;
+        }
+        const actions = this.treeActions.provideActionBar(evt.element);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => evt.anchor,
+            getActions: () => actions.secondary.length
+                ? [...actions.primary, ( new Separator()), ...actions.secondary]
+                : actions.primary,
+            getActionsContext: () => evt.element?.context
+        });
+    }
+    dispose() {
+        super.dispose();
+        this.disposed = true;
+    }
+};
+OutputPeekTree = ( __decorate([
+    ( __param(3, IContextMenuService)),
+    ( __param(4, ITestResultService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ITestExplorerFilterState)),
+    ( __param(7, ITestCoverageService)),
+    ( __param(8, IProgressService))
+], OutputPeekTree));
+let TestRunElementRenderer = class TestRunElementRenderer {
+    static { TestRunElementRenderer_1 = this; }
+    static { this.ID = 'testRunElementRenderer'; }
+    constructor(treeActions, instantiationService) {
+        this.treeActions = treeActions;
+        this.instantiationService = instantiationService;
+        this.templateId = TestRunElementRenderer_1.ID;
+    }
+    renderCompressedElements(node, _index, templateData) {
+        const chain = node.element.elements;
+        const lastElement = chain[chain.length - 1];
+        if ((lastElement instanceof TaskElement || lastElement instanceof TestMessageElement) && chain.length >= 2) {
+            this.doRender(chain[chain.length - 2], templateData, lastElement);
+        }
+        else {
+            this.doRender(lastElement, templateData);
+        }
+    }
+    renderTemplate(container) {
+        const templateDisposable = ( new DisposableStore());
+        const wrapper = append(container, $('.test-peek-item'));
+        const icon = append(wrapper, $('.state'));
+        const label = append(wrapper, $('.name'));
+        const actionBar = ( new ActionBar(wrapper, {
+            actionViewItemProvider: (action, options) => action instanceof MenuItemAction
+                ? this.instantiationService.createInstance(MenuEntryActionViewItem, action, { hoverDelegate: options.hoverDelegate })
+                : undefined
+        }));
+        const elementDisposable = ( new DisposableStore());
+        templateDisposable.add(elementDisposable);
+        templateDisposable.add(actionBar);
+        return {
+            icon,
+            label,
+            actionBar,
+            elementDisposable,
+            templateDisposable,
+        };
+    }
+    renderElement(element, _index, templateData) {
+        this.doRender(element.element, templateData);
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposable.dispose();
+    }
+    doRender(element, templateData, subjectElement) {
+        templateData.elementDisposable.clear();
+        templateData.elementDisposable.add(element.onDidChange(() => this.doRender(element, templateData, subjectElement)));
+        this.doRenderInner(element, templateData, subjectElement);
+    }
+    doRenderInner(element, templateData, subjectElement) {
+        let { label, labelWithIcons, description } = element;
+        if (subjectElement instanceof TestMessageElement) {
+            description = subjectElement.label;
+        }
+        const descriptionElement = description ? $('span.test-label-description', {}, description) : '';
+        if (labelWithIcons) {
+            reset(templateData.label, ...labelWithIcons, descriptionElement);
+        }
+        else {
+            reset(templateData.label, label, descriptionElement);
+        }
+        const icon = element.icon;
+        templateData.icon.className = `computed-state ${icon ? ThemeIcon.asClassName(icon) : ''}`;
+        const actions = this.treeActions.provideActionBar(element);
+        templateData.actionBar.clear();
+        templateData.actionBar.context = element.context;
+        templateData.actionBar.push(actions.primary, { icon: true, label: false });
+    }
+};
+TestRunElementRenderer = TestRunElementRenderer_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], TestRunElementRenderer));
+let TreeActionsProvider = class TreeActionsProvider {
+    constructor(showRevealLocationOnMessages, requestReveal, contextKeyService, menuService, commandService, testProfileService, editorService) {
+        this.showRevealLocationOnMessages = showRevealLocationOnMessages;
+        this.requestReveal = requestReveal;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this.commandService = commandService;
+        this.testProfileService = testProfileService;
+        this.editorService = editorService;
+    }
+    provideActionBar(element) {
+        const test = element instanceof TestCaseElement ? element.test : undefined;
+        const capabilities = test ? this.testProfileService.capabilitiesForTest(test) : 0;
+        const contextKeys = [
+            ['peek', "editor.contrib.testingOutputPeek" ],
+            [TestingContextKeys.peekItemType.key, element.type],
+        ];
+        let id = MenuId.TestPeekElement;
+        const primary = [];
+        const secondary = [];
+        if (element instanceof TaskElement) {
+            primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.showResultOutput',
+                "Show Result Output"
+            )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(( new TaskSubject(element.results, element.index))))));
+        }
+        if (element instanceof TestResultElement) {
+            if (element.value.tasks.length === 1) {
+                primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'testing.showResultOutput',
+                    "Show Result Output"
+                )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(( new TaskSubject(element.value, 0))))));
+            }
+            primary.push(( new Action('testing.outputPeek.reRunLastRun', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.reRunLastRun',
+                "Rerun Test Run"
+            )), ThemeIcon.asClassName(testingRunIcon), undefined, () => this.commandService.executeCommand('testing.reRunLastRun', element.value.id))));
+            if (capabilities & 4 ) {
+                primary.push(( new Action('testing.outputPeek.debugLastRun', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'testing.debugLastRun',
+                    "Debug Test Run"
+                )), ThemeIcon.asClassName(testingDebugIcon), undefined, () => this.commandService.executeCommand('testing.debugLastRun', element.value.id))));
+            }
+        }
+        if (element instanceof TestCaseElement || element instanceof TestMessageElement) {
+            contextKeys.push([TestingContextKeys.testResultOutdated.key, element.test.retired], [TestingContextKeys.testResultState.key, testResultStateToContextValues[element.test.ownComputedState]], ...getTestItemContextOverlay(element.test, capabilities));
+            const extId = element.test.item.extId;
+            if (( element.test.tasks[element.taskIndex].messages.some(m => m.type === 1 ))) {
+                primary.push(( new Action('testing.outputPeek.showResultOutput', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'testing.showResultOutput',
+                    "Show Result Output"
+                )), ThemeIcon.asClassName(Codicon.terminal), undefined, () => this.requestReveal.fire(element.outputSubject))));
+            }
+            secondary.push(( new Action('testing.outputPeek.revealInExplorer', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.revealInExplorer',
+                "Reveal in Test Explorer"
+            )), ThemeIcon.asClassName(Codicon.listTree), undefined, () => this.commandService.executeCommand('_revealTestInExplorer', extId))));
+            if (capabilities & 2 ) {
+                primary.push(( new Action('testing.outputPeek.runTest', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'run test',
+                    'Run Test'
+                )), ThemeIcon.asClassName(testingRunIcon), undefined, () => this.commandService.executeCommand('vscode.runTestsById', 2 , extId))));
+            }
+            if (capabilities & 4 ) {
+                primary.push(( new Action('testing.outputPeek.debugTest', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'debug test',
+                    'Debug Test'
+                )), ThemeIcon.asClassName(testingDebugIcon), undefined, () => this.commandService.executeCommand('vscode.runTestsById', 4 , extId))));
+            }
+        }
+        if (element instanceof TestMessageElement) {
+            primary.push(( new Action('testing.outputPeek.goToFile', ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.goToFile',
+                "Go to Source"
+            )), ThemeIcon.asClassName(Codicon.goToFile), undefined, () => this.commandService.executeCommand('vscode.revealTest', element.test.item.extId))));
+        }
+        if (element instanceof TestMessageElement) {
+            id = MenuId.TestMessageContext;
+            contextKeys.push([TestingContextKeys.testMessageContext.key, element.contextValue]);
+            if (this.showRevealLocationOnMessages && element.location) {
+                primary.push(( new Action('testing.outputPeek.goToError', ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                    'testing.goToError',
+                    "Go to Source"
+                )), ThemeIcon.asClassName(Codicon.goToFile), undefined, () => this.editorService.openEditor({
+                    resource: element.location.uri,
+                    options: {
+                        selection: element.location.range,
+                        preserveFocus: true,
+                    }
+                }))));
+            }
+        }
+        const contextOverlay = this.contextKeyService.createOverlay(contextKeys);
+        const result = { primary, secondary };
+        const menu = this.menuService.createMenu(id, contextOverlay);
+        try {
+            createAndFillInActionBarActions(menu, { arg: element.context }, result, 'inline');
+            return result;
+        }
+        finally {
+            menu.dispose();
+        }
+    }
+};
+TreeActionsProvider = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, ITestProfileService)),
+    ( __param(6, IEditorService))
+], TreeActionsProvider));
+const navWhen = ( ContextKeyExpr.and(EditorContextKeys.focus, TestingContextKeys.isPeekVisible));
+const getPeekedEditorFromFocus = (codeEditorService) => {
+    const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+    return editor && getPeekedEditor(codeEditorService, editor);
+};
+const getPeekedEditor = (codeEditorService, editor) => {
+    if (TestingOutputPeekController.get(editor)?.subject) {
+        return editor;
+    }
+    if (editor instanceof EmbeddedCodeEditorWidget) {
+        return editor.getParentEditor();
+    }
+    const outer = getOuterEditorFromDiffEditor(codeEditorService);
+    if (outer) {
+        return outer;
+    }
+    return editor;
+};
+class GoToNextMessageAction extends Action2 {
+    static { this.ID = 'testing.goToNextMessage'; }
+    constructor() {
+        super({
+            id: GoToNextMessageAction.ID,
+            f1: true,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.goToNextMessage',
+                'Go to Next Test Failure'
+            )),
+            icon: Codicon.arrowDown,
+            category: Categories.Test,
+            keybinding: {
+                primary: 512  | 66 ,
+                weight: 100  + 1,
+                when: navWhen,
+            },
+            menu: [{
+                    id: MenuId.TestPeekTitle,
+                    group: 'navigation',
+                    order: 2,
+                }, {
+                    id: MenuId.CommandPalette,
+                    when: navWhen
+                }],
+        });
+    }
+    run(accessor) {
+        const editor = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
+        if (editor) {
+            TestingOutputPeekController.get(editor)?.next();
+        }
+    }
+}
+class GoToPreviousMessageAction extends Action2 {
+    static { this.ID = 'testing.goToPreviousMessage'; }
+    constructor() {
+        super({
+            id: GoToPreviousMessageAction.ID,
+            f1: true,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.goToPreviousMessage',
+                'Go to Previous Test Failure'
+            )),
+            icon: Codicon.arrowUp,
+            category: Categories.Test,
+            keybinding: {
+                primary: 1024  | 512  | 66 ,
+                weight: 100  + 1,
+                when: navWhen
+            },
+            menu: [{
+                    id: MenuId.TestPeekTitle,
+                    group: 'navigation',
+                    order: 1,
+                }, {
+                    id: MenuId.CommandPalette,
+                    when: navWhen
+                }],
+        });
+    }
+    run(accessor) {
+        const editor = getPeekedEditorFromFocus(accessor.get(ICodeEditorService));
+        if (editor) {
+            TestingOutputPeekController.get(editor)?.previous();
+        }
+    }
+}
+class OpenMessageInEditorAction extends Action2 {
+    static { this.ID = 'testing.openMessageInEditor'; }
+    constructor() {
+        super({
+            id: OpenMessageInEditorAction.ID,
+            f1: false,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.openMessageInEditor',
+                'Open in Editor'
+            )),
+            icon: Codicon.goToFile,
+            category: Categories.Test,
+            menu: [{ id: MenuId.TestPeekTitle }],
+        });
+    }
+    run(accessor) {
+        accessor.get(ITestingPeekOpener).openCurrentInEditor();
+    }
+}
+class ToggleTestingPeekHistory extends Action2 {
+    static { this.ID = 'testing.toggleTestingPeekHistory'; }
+    constructor() {
+        super({
+            id: ToggleTestingPeekHistory.ID,
+            f1: true,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testingOutputPeek',
+                'testing.toggleTestingPeekHistory',
+                'Toggle Test History in Peek'
+            )),
+            icon: Codicon.history,
+            category: Categories.Test,
+            menu: [{
+                    id: MenuId.TestPeekTitle,
+                    group: 'navigation',
+                    order: 3,
+                }],
+            keybinding: {
+                weight: 200 ,
+                primary: 512  | 38 ,
+                when: ( TestingContextKeys.isPeekVisible.isEqualTo(true)),
+            },
+        });
+    }
+    run(accessor) {
+        const opener = accessor.get(ITestingPeekOpener);
+        opener.historyVisible.value = !opener.historyVisible.value;
+    }
+}
+class CreationCache {
+    constructor() {
+        this.v = ( new WeakMap());
+    }
+    get(key) {
+        return this.v.get(key);
+    }
+    getOrCreate(ref, factory) {
+        const existing = this.v.get(ref);
+        if (existing) {
+            return existing;
+        }
+        const fresh = factory();
+        this.v.set(ref, fresh);
+        return fresh;
+    }
+}
+export { CloseTestPeek, GoToNextMessageAction, GoToPreviousMessageAction, OpenMessageInEditorAction, TestResultsView, TestingOutputPeekController, TestingPeekOpener, ToggleTestingPeekHistory };