@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,1671 @@
+import { distinct } from '../../../../base/common/arrays.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { isDefined } from '../../../../base/common/types.js';
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { EmbeddedCodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/embeddedCodeEditorWidget.js';
+import { Position } from '../../../../editor/common/core/position.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
+import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ContextKeyGreaterExpr, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { widgetClose } from '../../../../platform/theme/common/iconRegistry.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { ViewAction } from '../../../browser/parts/views/viewPane.js';
+import { FocusedViewContext } from '../../../common/contextkeys.js';
+import { VIEWLET_ID } from '../../extensions/common/extensions.js';
+import { TestItemTreeElement } from './explorerProjections/index.js';
+import { testingDebugIcon, testingCoverageIcon, testingRunIcon, testingUpdateProfiles, testingTurnContinuousRunOn, testingContinuousIsOn, testingTurnContinuousRunOff, testingRunAllIcon, testingDebugAllIcon, testingCoverageAllIcon, testingCancelIcon, testingRefreshTests, testingCancelRefreshTests } from './icons.js';
+import { getTestingConfiguration } from '../common/configuration.js';
+import { testConfigurationGroupNames } from '../common/constants.js';
+import { ITestCoverageService } from '../common/testCoverageService.js';
+import { TestId } from '../common/testId.js';
+import { canUseProfileWithTest, ITestProfileService } from '../common/testProfileService.js';
+import { ITestResultService } from '../common/testResultService.js';
+import { expandAndGetTestById, ITestService, testsInFile, testsUnderUri } from '../common/testService.js';
+import { TestingContextKeys } from '../common/testingContextKeys.js';
+import { ITestingContinuousRunService } from '../common/testingContinuousRunService.js';
+import { ITestingPeekOpener } from '../common/testingPeekOpener.js';
+import { isFailedState } from '../common/testingStates.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
+const category = Categories.Test;
+const hasAnyTestProvider = ContextKeyGreaterExpr.create(TestingContextKeys.providerCount.key, 0);
+const LABEL_RUN_TESTS = ( localize2WithPath(
+    'vs/workbench/contrib/testing/browser/testExplorerActions',
+    'runSelectedTests',
+    "Run Tests"
+));
+const LABEL_DEBUG_TESTS = ( localize2WithPath(
+    'vs/workbench/contrib/testing/browser/testExplorerActions',
+    'debugSelectedTests',
+    "Debug Tests"
+));
+const LABEL_COVERAGE_TESTS = ( localize2WithPath(
+    'vs/workbench/contrib/testing/browser/testExplorerActions',
+    'coverageSelectedTests',
+    "Run Tests with Coverage"
+));
+class HideTestAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.hideTest" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'hideTest',
+                'Hide Test'
+            )),
+            menu: {
+                id: MenuId.TestItem,
+                group: 'builtin@2',
+                when: ( TestingContextKeys.testItemIsHidden.isEqualTo(false))
+            },
+        });
+    }
+    run(accessor, ...elements) {
+        const service = accessor.get(ITestService);
+        for (const element of elements) {
+            service.excluded.toggle(element.test, true);
+        }
+        return Promise.resolve();
+    }
+}
+class UnhideTestAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.unhideTest" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'unhideTest',
+                'Unhide Test'
+            )),
+            menu: {
+                id: MenuId.TestItem,
+                order: 21 ,
+                when: ( TestingContextKeys.testItemIsHidden.isEqualTo(true))
+            },
+        });
+    }
+    run(accessor, ...elements) {
+        const service = accessor.get(ITestService);
+        for (const element of elements) {
+            if (element instanceof TestItemTreeElement) {
+                service.excluded.toggle(element.test, false);
+            }
+        }
+        return Promise.resolve();
+    }
+}
+class UnhideAllTestsAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.unhideAllTests" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'unhideAllTests',
+                'Unhide All Tests'
+            )),
+        });
+    }
+    run(accessor) {
+        const service = accessor.get(ITestService);
+        service.excluded.clear();
+        return Promise.resolve();
+    }
+}
+const testItemInlineAndInContext = (order, when) => [
+    {
+        id: MenuId.TestItem,
+        group: 'inline',
+        order,
+        when,
+    }, {
+        id: MenuId.TestItem,
+        group: 'builtin@1',
+        order,
+        when,
+    }
+];
+class RunVisibleAction extends ViewAction {
+    constructor(bitset, desc) {
+        super({
+            ...desc,
+            viewId: "workbench.view.testing" ,
+        });
+        this.bitset = bitset;
+    }
+    runInView(accessor, view, ...elements) {
+        const { include, exclude } = view.getTreeIncludeExclude(( elements.map(e => e.test)));
+        return accessor.get(ITestService).runTests({
+            tests: include,
+            exclude,
+            group: this.bitset,
+        });
+    }
+}
+class DebugAction extends RunVisibleAction {
+    constructor() {
+        super(4 , {
+            id: "testing.debug" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'debug test',
+                'Debug Test'
+            )),
+            icon: testingDebugIcon,
+            menu: testItemInlineAndInContext(12 , ( TestingContextKeys.hasDebuggableTests.isEqualTo(true))),
+        });
+    }
+}
+class CoverageAction extends RunVisibleAction {
+    constructor() {
+        super(8 , {
+            id: "testing.coverage" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'run with cover test',
+                'Run Test with Coverage'
+            )),
+            icon: testingCoverageIcon,
+            menu: testItemInlineAndInContext(13 , ( TestingContextKeys.hasCoverableTests.isEqualTo(true))),
+        });
+    }
+}
+class RunUsingProfileAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.runUsing" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.runUsing',
+                'Execute Using Profile...'
+            )),
+            icon: testingDebugIcon,
+            menu: {
+                id: MenuId.TestItem,
+                order: 15 ,
+                group: 'builtin@2',
+                when: ( TestingContextKeys.hasNonDefaultProfile.isEqualTo(true)),
+            },
+        });
+    }
+    async run(acessor, ...elements) {
+        const commandService = acessor.get(ICommandService);
+        const testService = acessor.get(ITestService);
+        const profile = await commandService.executeCommand('vscode.pickTestProfile', {
+            onlyForTest: elements[0].test,
+        });
+        if (!profile) {
+            return;
+        }
+        testService.runResolvedTests({
+            targets: [{
+                    profileGroup: profile.group,
+                    profileId: profile.profileId,
+                    controllerId: profile.controllerId,
+                    testIds: ( elements.filter(t => canUseProfileWithTest(profile, t.test)).map(t => t.test.item.extId))
+                }]
+        });
+    }
+}
+class RunAction extends RunVisibleAction {
+    constructor() {
+        super(2 , {
+            id: "testing.run" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'run test',
+                'Run Test'
+            )),
+            icon: testingRunIcon,
+            menu: testItemInlineAndInContext(11 , ( TestingContextKeys.hasRunnableTests.isEqualTo(true))),
+        });
+    }
+}
+class SelectDefaultTestProfiles extends Action2 {
+    constructor() {
+        super({
+            id: "testing.selectDefaultTestProfiles" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.selectDefaultTestProfiles',
+                'Select Default Profile'
+            )),
+            icon: testingUpdateProfiles,
+            category,
+        });
+    }
+    async run(acessor, onlyGroup) {
+        const commands = acessor.get(ICommandService);
+        const testProfileService = acessor.get(ITestProfileService);
+        const profiles = await commands.executeCommand('vscode.pickMultipleTestProfiles', {
+            showConfigureButtons: false,
+            selected: testProfileService.getGroupDefaultProfiles(onlyGroup),
+            onlyGroup,
+        });
+        if (profiles?.length) {
+            testProfileService.setGroupDefaultProfiles(onlyGroup, profiles);
+        }
+    }
+}
+class ContinuousRunTestAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.toggleContinuousRunForTest" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.toggleContinuousRunOn',
+                'Turn on Continuous Run'
+            )),
+            icon: testingTurnContinuousRunOn,
+            precondition: ( ContextKeyExpr.or(( TestingContextKeys.isContinuousModeOn.isEqualTo(true)), ( TestingContextKeys.isParentRunningContinuously.isEqualTo(false)))),
+            toggled: {
+                condition: ( TestingContextKeys.isContinuousModeOn.isEqualTo(true)),
+                icon: testingContinuousIsOn,
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/testing/browser/testExplorerActions',
+                    'testing.toggleContinuousRunOff',
+                    'Turn off Continuous Run'
+                )),
+            },
+            menu: testItemInlineAndInContext(2147483647 , ( TestingContextKeys.supportsContinuousRun.isEqualTo(true))),
+        });
+    }
+    async run(accessor, ...elements) {
+        const crService = accessor.get(ITestingContinuousRunService);
+        for (const element of elements) {
+            const id = element.test.item.extId;
+            if (crService.isSpecificallyEnabledFor(id)) {
+                crService.stop(id);
+                continue;
+            }
+            crService.start(2 , id);
+        }
+    }
+}
+class ContinuousRunUsingProfileTestAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.continuousRunUsingForTest" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.startContinuousRunUsing',
+                'Start Continous Run Using...'
+            )),
+            icon: testingDebugIcon,
+            menu: [
+                {
+                    id: MenuId.TestItem,
+                    order: 14 ,
+                    group: 'builtin@2',
+                    when: ( ContextKeyExpr.and(( TestingContextKeys.supportsContinuousRun.isEqualTo(true)), ( TestingContextKeys.isContinuousModeOn.isEqualTo(false))))
+                }
+            ],
+        });
+    }
+    async run(accessor, ...elements) {
+        const crService = accessor.get(ITestingContinuousRunService);
+        const profileService = accessor.get(ITestProfileService);
+        const notificationService = accessor.get(INotificationService);
+        const quickInputService = accessor.get(IQuickInputService);
+        for (const element of elements) {
+            const selected = await selectContinuousRunProfiles(crService, notificationService, quickInputService, [{ profiles: profileService.getControllerProfiles(element.test.controllerId) }]);
+            if (selected.length) {
+                crService.start(selected, element.test.item.extId);
+            }
+        }
+    }
+}
+class ConfigureTestProfilesAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.configureProfile" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.configureProfile',
+                "Configure Test Profiles"
+            )),
+            icon: testingUpdateProfiles,
+            f1: true,
+            category,
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( TestingContextKeys.hasConfigurableProfile.isEqualTo(true)),
+            },
+        });
+    }
+    async run(acessor, onlyGroup) {
+        const commands = acessor.get(ICommandService);
+        const testProfileService = acessor.get(ITestProfileService);
+        const profile = await commands.executeCommand('vscode.pickTestProfile', {
+            placeholder: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'configureProfile',
+                'Select a profile to update'
+            )),
+            showConfigureButtons: false,
+            onlyConfigurable: true,
+            onlyGroup,
+        });
+        if (profile) {
+            testProfileService.configure(profile.controllerId, profile.profileId);
+        }
+    }
+}
+const continuousMenus = (whenIsContinuousOn) => [
+    {
+        id: MenuId.ViewTitle,
+        group: 'navigation',
+        order: 15 ,
+        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', "workbench.view.testing" )), ( TestingContextKeys.supportsContinuousRun.isEqualTo(true)), ( TestingContextKeys.isContinuousModeOn.isEqualTo(whenIsContinuousOn)))),
+    },
+    {
+        id: MenuId.CommandPalette,
+        when: ( TestingContextKeys.supportsContinuousRun.isEqualTo(true)),
+    },
+];
+class StopContinuousRunAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.stopContinuousRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.stopContinuous',
+                'Stop Continuous Run'
+            )),
+            category,
+            icon: testingTurnContinuousRunOff,
+            menu: continuousMenus(true),
+        });
+    }
+    run(accessor) {
+        accessor.get(ITestingContinuousRunService).stop();
+    }
+}
+function selectContinuousRunProfiles(crs, notificationService, quickInputService, profilesToPickFrom) {
+    const items = [];
+    for (const { controller, profiles } of profilesToPickFrom) {
+        for (const profile of profiles) {
+            if (profile.supportsContinuousRun) {
+                items.push({
+                    label: profile.label || controller?.label.value || '',
+                    description: controller?.label.value,
+                    profile,
+                });
+            }
+        }
+    }
+    if (items.length === 0) {
+        notificationService.info(( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'testing.noProfiles',
+            'No test continuous run-enabled profiles were found'
+        )));
+        return Promise.resolve([]);
+    }
+    if (items.length === 1) {
+        return Promise.resolve([items[0].profile]);
+    }
+    const qpItems = [];
+    const selectedItems = [];
+    const lastRun = crs.lastRunProfileIds;
+    items.sort((a, b) => a.profile.group - b.profile.group
+        || a.profile.controllerId.localeCompare(b.profile.controllerId)
+        || a.label.localeCompare(b.label));
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (i === 0 || items[i - 1].profile.group !== item.profile.group) {
+            qpItems.push({ type: 'separator', label: testConfigurationGroupNames[item.profile.group] });
+        }
+        qpItems.push(item);
+        if (( lastRun.has(item.profile.profileId))) {
+            selectedItems.push(item);
+        }
+    }
+    const quickpick = quickInputService.createQuickPick();
+    quickpick.title = ( localizeWithPath(
+        'vs/workbench/contrib/testing/browser/testExplorerActions',
+        'testing.selectContinuousProfiles',
+        'Select profiles to run when files change:'
+    ));
+    quickpick.canSelectMany = true;
+    quickpick.items = qpItems;
+    quickpick.selectedItems = selectedItems;
+    quickpick.show();
+    return ( new Promise((resolve, reject) => {
+        quickpick.onDidAccept(() => {
+            resolve(( quickpick.selectedItems.map(i => i.profile)));
+            quickpick.dispose();
+        });
+        quickpick.onDidHide(() => {
+            resolve([]);
+            quickpick.dispose();
+        });
+    }));
+}
+class StartContinuousRunAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.startContinuousRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.startContinuous',
+                "Start Continuous Run"
+            )),
+            category,
+            icon: testingTurnContinuousRunOn,
+            menu: continuousMenus(false),
+        });
+    }
+    async run(accessor, ...args) {
+        const crs = accessor.get(ITestingContinuousRunService);
+        const selected = await selectContinuousRunProfiles(crs, accessor.get(INotificationService), accessor.get(IQuickInputService), accessor.get(ITestProfileService).all());
+        if (selected.length) {
+            crs.start(selected);
+        }
+    }
+}
+class ExecuteSelectedAction extends ViewAction {
+    constructor(options, group) {
+        super({
+            ...options,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    order: group === 2
+                        ? 11
+                        : group === 4
+                            ? 12
+                            : 13 ,
+                    group: 'navigation',
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', "workbench.view.testing" )), ( TestingContextKeys.isRunning.isEqualTo(false)), ( TestingContextKeys.capabilityToContextKey[group].isEqualTo(true))))
+                }],
+            category,
+            viewId: "workbench.view.testing" ,
+        });
+        this.group = group;
+    }
+    runInView(accessor, view) {
+        const { include, exclude } = view.getTreeIncludeExclude();
+        return accessor.get(ITestService).runTests({ tests: include, exclude, group: this.group });
+    }
+}
+class GetSelectedProfiles extends Action2 {
+    constructor() {
+        super({ id: "testing.getSelectedProfiles" , title: ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'getSelectedProfiles',
+            'Get Selected Profiles'
+        )) });
+    }
+    run(accessor) {
+        const profiles = accessor.get(ITestProfileService);
+        return ( [
+            ...profiles.getGroupDefaultProfiles(2 ),
+            ...profiles.getGroupDefaultProfiles(4 ),
+            ...profiles.getGroupDefaultProfiles(8 ),
+        ].map(p => ({
+            controllerId: p.controllerId,
+            label: p.label,
+            kind: p.group & 8
+                ? 3
+                : p.group & 4
+                    ? 2
+                    : 1 ,
+        })));
+    }
+}
+class GetExplorerSelection extends ViewAction {
+    constructor() {
+        super({ id: "_testing.getExplorerSelection" , title: ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'getExplorerSelection',
+            'Get Explorer Selection'
+        )), viewId: "workbench.view.testing"  });
+    }
+    runInView(_accessor, view) {
+        const { include, exclude } = view.getTreeIncludeExclude(undefined, undefined, 'selected');
+        const mapper = (i) => i.item.extId;
+        return { include: ( include.map(mapper)), exclude: ( exclude.map(mapper)) };
+    }
+}
+class RunSelectedAction extends ExecuteSelectedAction {
+    constructor() {
+        super({
+            id: "testing.runSelected" ,
+            title: LABEL_RUN_TESTS,
+            icon: testingRunAllIcon,
+        }, 2 );
+    }
+}
+class DebugSelectedAction extends ExecuteSelectedAction {
+    constructor() {
+        super({
+            id: "testing.debugSelected" ,
+            title: LABEL_DEBUG_TESTS,
+            icon: testingDebugAllIcon,
+        }, 4 );
+    }
+}
+class CoverageSelectedAction extends ExecuteSelectedAction {
+    constructor() {
+        super({
+            id: "testing.coverageSelected" ,
+            title: LABEL_COVERAGE_TESTS,
+            icon: testingCoverageAllIcon,
+        }, 8 );
+    }
+}
+const showDiscoveringWhile = (progress, task) => {
+    return progress.withProgress({
+        location: 10 ,
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'discoveringTests',
+            'Discovering Tests'
+        )),
+    }, () => task);
+};
+class RunOrDebugAllTestsAction extends Action2 {
+    constructor(options, group, noTestsFoundError) {
+        super({
+            ...options,
+            category,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.capabilityToContextKey[group].isEqualTo(true)),
+                }]
+        });
+        this.group = group;
+        this.noTestsFoundError = noTestsFoundError;
+    }
+    async run(accessor) {
+        const testService = accessor.get(ITestService);
+        const notifications = accessor.get(INotificationService);
+        const roots = [...testService.collection.rootItems];
+        if (!roots.length) {
+            notifications.info(this.noTestsFoundError);
+            return;
+        }
+        await testService.runTests({ tests: roots, group: this.group });
+    }
+}
+class RunAllAction extends RunOrDebugAllTestsAction {
+    constructor() {
+        super({
+            id: "testing.runAll" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'runAllTests',
+                'Run All Tests'
+            )),
+            icon: testingRunAllIcon,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 31 ),
+            },
+        }, 2 , ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'noTestProvider',
+            'No tests found in this workspace. You may need to install a test provider extension'
+        )));
+    }
+}
+class DebugAllAction extends RunOrDebugAllTestsAction {
+    constructor() {
+        super({
+            id: "testing.debugAll" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'debugAllTests',
+                'Debug All Tests'
+            )),
+            icon: testingDebugIcon,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 31 ),
+            },
+        }, 4 , ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'noDebugTestProvider',
+            'No debuggable tests found in this workspace. You may need to install a test provider extension'
+        )));
+    }
+}
+class CoverageAllAction extends RunOrDebugAllTestsAction {
+    constructor() {
+        super({
+            id: "testing.coverageAll" ,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'runAllWithCoverage',
+                'Run All Tests with Coverage'
+            )),
+            icon: testingCoverageIcon,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 1024  | 31 ),
+            },
+        }, 8 , ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testExplorerActions',
+            'noCoverageTestProvider',
+            'No tests with coverage runners found in this workspace. You may need to install a test provider extension'
+        )));
+    }
+}
+class CancelTestRunAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.cancelRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.cancelRun',
+                'Cancel Test Run'
+            )),
+            icon: testingCancelIcon,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 54 ),
+            },
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 11 ,
+                group: 'navigation',
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', "workbench.view.testing" )), ( ContextKeyExpr.equals(TestingContextKeys.isRunning.serialize(), true))))
+            }
+        });
+    }
+    async run(accessor) {
+        const resultService = accessor.get(ITestResultService);
+        const testService = accessor.get(ITestService);
+        for (const run of resultService.results) {
+            if (!run.completedAt) {
+                testService.cancelTestRun(run.id);
+            }
+        }
+    }
+}
+class TestingViewAsListAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.viewAsList" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.viewAsList',
+                'View as List'
+            )),
+            toggled: ( TestingContextKeys.viewMode.isEqualTo("list" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 18 ,
+                group: 'viewAs',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.viewMode = "list" ;
+    }
+}
+class TestingViewAsTreeAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.viewAsTree" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.viewAsTree',
+                'View as Tree'
+            )),
+            toggled: ( TestingContextKeys.viewMode.isEqualTo("true" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 18 ,
+                group: 'viewAs',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.viewMode = "true" ;
+    }
+}
+class TestingSortByStatusAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.sortByStatus" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.sortByStatus',
+                'Sort by Status'
+            )),
+            toggled: ( TestingContextKeys.viewSorting.isEqualTo("status" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 19 ,
+                group: 'sortBy',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.viewSorting = "status" ;
+    }
+}
+class TestingSortByLocationAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.sortByLocation" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.sortByLocation',
+                'Sort by Location'
+            )),
+            toggled: ( TestingContextKeys.viewSorting.isEqualTo("location" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 19 ,
+                group: 'sortBy',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.viewSorting = "location" ;
+    }
+}
+class TestingSortByDurationAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.sortByDuration" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.sortByDuration',
+                'Sort by Duration'
+            )),
+            toggled: ( TestingContextKeys.viewSorting.isEqualTo("duration" )),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 19 ,
+                group: 'sortBy',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.viewSorting = "duration" ;
+    }
+}
+class ShowMostRecentOutputAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.showMostRecentOutput" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.showMostRecentOutput',
+                'Show Output'
+            )),
+            category,
+            icon: Codicon.terminal,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 45 ),
+            },
+            precondition: ( TestingContextKeys.hasAnyResults.isEqualTo(true)),
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    order: 16 ,
+                    group: 'navigation',
+                    when: ( ContextKeyExpr.equals('view', "workbench.view.testing" )),
+                }, {
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.hasAnyResults.isEqualTo(true))
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewService = accessor.get(IViewsService);
+        const testView = await viewService.openView("workbench.panel.testResults.view" , true);
+        testView?.showLatestRun();
+    }
+}
+class CollapseAllAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.collapseAll" ,
+            viewId: "workbench.view.testing" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.collapseAll',
+                'Collapse All Tests'
+            )),
+            icon: Codicon.collapseAll,
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 16 ,
+                group: 'displayAction',
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.viewModel.collapseAll();
+    }
+}
+class ClearTestResultsAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.clearTestResults" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.clearResults',
+                'Clear All Results'
+            )),
+            category,
+            icon: Codicon.clearAll,
+            menu: [{
+                    id: MenuId.TestPeekTitle,
+                }, {
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.hasAnyResults.isEqualTo(true)),
+                }, {
+                    id: MenuId.ViewTitle,
+                    order: 17 ,
+                    group: 'displayAction',
+                    when: ( ContextKeyExpr.equals('view', "workbench.view.testing" ))
+                }, {
+                    id: MenuId.ViewTitle,
+                    order: 17 ,
+                    group: 'navigation',
+                    when: ( ContextKeyExpr.equals('view', "workbench.panel.testResults.view" ))
+                }],
+        });
+    }
+    run(accessor) {
+        accessor.get(ITestResultService).clear();
+    }
+}
+class GoToTest extends Action2 {
+    constructor() {
+        super({
+            id: "testing.editFocusedTest" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.editFocusedTest',
+                'Go to Test'
+            )),
+            icon: Codicon.goToFile,
+            menu: testItemInlineAndInContext(20 , ( TestingContextKeys.testItemHasUri.isEqualTo(true))),
+            keybinding: {
+                weight: 100  - 10,
+                when: ( FocusedViewContext.isEqualTo("workbench.view.testing" )),
+                primary: 3  | 512 ,
+            },
+        });
+    }
+    async run(accessor, element, preserveFocus) {
+        if (!element) {
+            const view = accessor.get(IViewsService).getActiveViewWithId("workbench.view.testing" );
+            element = view?.focusedTreeElements[0];
+        }
+        if (element && element instanceof TestItemTreeElement) {
+            accessor.get(ICommandService).executeCommand('vscode.revealTest', element.test.item.extId, preserveFocus);
+        }
+    }
+}
+class ExecuteTestAtCursor extends Action2 {
+    constructor(options, group) {
+        super({
+            ...options,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: hasAnyTestProvider,
+                }, {
+                    id: MenuId.EditorContext,
+                    group: 'testing',
+                    order: group === 2  ? 11  : 12 ,
+                    when: ( ContextKeyExpr.and(
+                        TestingContextKeys.activeEditorHasTests,
+                        TestingContextKeys.capabilityToContextKey[group]
+                    )),
+                }]
+        });
+        this.group = group;
+    }
+    async run(accessor) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        let editor = codeEditorService.getActiveCodeEditor();
+        if (!activeEditorPane || !editor) {
+            return;
+        }
+        if (editor instanceof EmbeddedCodeEditorWidget) {
+            editor = editor.getParentEditor();
+        }
+        const position = editor?.getPosition();
+        const model = editor?.getModel();
+        if (!position || !model || !('uri' in model)) {
+            return;
+        }
+        const testService = accessor.get(ITestService);
+        const profileService = accessor.get(ITestProfileService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        const progressService = accessor.get(IProgressService);
+        const configurationService = accessor.get(IConfigurationService);
+        let bestNodes = [];
+        let bestRange;
+        let bestNodesBefore = [];
+        let bestRangeBefore;
+        const saveBeforeTest = getTestingConfiguration(configurationService, "testing.saveBeforeTest" );
+        if (saveBeforeTest) {
+            await editorService.save({ editor: activeEditorPane.input, groupId: activeEditorPane.group.id });
+            await testService.syncTests();
+        }
+        await showDiscoveringWhile(progressService, (async () => {
+            for await (const test of testsInFile(testService, uriIdentityService, model.uri)) {
+                if (!test.item.range || !(profileService.capabilitiesForTest(test) & this.group)) {
+                    continue;
+                }
+                const irange = Range.lift(test.item.range);
+                if (irange.containsPosition(position)) {
+                    if (bestRange && Range.equalsRange(test.item.range, bestRange)) {
+                        if (!( bestNodes.some(b => TestId.isChild(b.item.extId, test.item.extId)))) {
+                            bestNodes.push(test);
+                        }
+                    }
+                    else {
+                        bestRange = irange;
+                        bestNodes = [test];
+                    }
+                }
+                else if (Position.isBefore(irange.getStartPosition(), position)) {
+                    if (!bestRangeBefore || bestRangeBefore.getStartPosition().isBefore(irange.getStartPosition())) {
+                        bestRangeBefore = irange;
+                        bestNodesBefore = [test];
+                    }
+                    else if (irange.equalsRange(bestRangeBefore) && !( bestNodesBefore.some(b => TestId.isChild(b.item.extId, test.item.extId)))) {
+                        bestNodesBefore.push(test);
+                    }
+                }
+            }
+        })());
+        const testsToRun = bestNodes.length ? bestNodes : bestNodesBefore;
+        if (testsToRun.length) {
+            await testService.runTests({
+                group: this.group,
+                tests: bestNodes.length ? bestNodes : bestNodesBefore,
+            });
+        }
+        else if (editor) {
+            MessageController.get(editor)?.showMessage(( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'noTestsAtCursor',
+                "No tests found here"
+            )), position);
+        }
+    }
+}
+class RunAtCursor extends ExecuteTestAtCursor {
+    constructor() {
+        super({
+            id: "testing.runAtCursor" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.runAtCursor',
+                'Run Test at Cursor'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 33 ),
+            },
+        }, 2 );
+    }
+}
+class DebugAtCursor extends ExecuteTestAtCursor {
+    constructor() {
+        super({
+            id: "testing.debugAtCursor" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.debugAtCursor',
+                'Debug Test at Cursor'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 2048  | 33 ),
+            },
+        }, 4 );
+    }
+}
+class CoverageAtCursor extends ExecuteTestAtCursor {
+    constructor() {
+        super({
+            id: "testing.coverageAtCursor" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.coverageAtCursor',
+                'Run Test at Cursor with Coverage'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 2048  | 1024  | 33 ),
+            },
+        }, 8 );
+    }
+}
+class ExecuteTestsUnderUriAction extends Action2 {
+    constructor(options, group) {
+        super({
+            ...options,
+            menu: [{
+                    id: MenuId.ExplorerContext,
+                    when: ( TestingContextKeys.capabilityToContextKey[group].isEqualTo(true)),
+                    group: '6.5_testing',
+                    order: ((group === 2  ? 11  : 12) ) + 0.1,
+                }],
+        });
+        this.group = group;
+    }
+    async run(accessor, uri) {
+        const testService = accessor.get(ITestService);
+        const notificationService = accessor.get(INotificationService);
+        const tests = await Iterable.asyncToArray(testsUnderUri(testService, accessor.get(IUriIdentityService), uri));
+        if (!tests.length) {
+            notificationService.notify({ message: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'noTests',
+                'No tests found in the selected file or folder'
+            )), severity: Severity.Info });
+            return;
+        }
+        return testService.runTests({ tests, group: this.group });
+    }
+}
+class RunTestsUnderUri extends ExecuteTestsUnderUriAction {
+    constructor() {
+        super({
+            id: "testing.run.uri" ,
+            title: LABEL_RUN_TESTS,
+            category,
+        }, 2 );
+    }
+}
+class DebugTestsUnderUri extends ExecuteTestsUnderUriAction {
+    constructor() {
+        super({
+            id: "testing.debug.uri" ,
+            title: LABEL_DEBUG_TESTS,
+            category,
+        }, 4 );
+    }
+}
+class CoverageTestsUnderUri extends ExecuteTestsUnderUriAction {
+    constructor() {
+        super({
+            id: "testing.coverage.uri" ,
+            title: LABEL_COVERAGE_TESTS,
+            category,
+        }, 8 );
+    }
+}
+class ExecuteTestsInCurrentFile extends Action2 {
+    constructor(options, group) {
+        super({
+            ...options,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.capabilityToContextKey[group].isEqualTo(true)),
+                }, {
+                    id: MenuId.EditorContext,
+                    group: 'testing',
+                    order: ((group === 2  ? 11  : 12) ) + 0.1,
+                    when: ( ContextKeyExpr.and(
+                        TestingContextKeys.activeEditorHasTests,
+                        TestingContextKeys.capabilityToContextKey[group]
+                    )),
+                }],
+        });
+        this.group = group;
+    }
+    run(accessor) {
+        let editor = accessor.get(ICodeEditorService).getActiveCodeEditor();
+        if (!editor) {
+            return;
+        }
+        if (editor instanceof EmbeddedCodeEditorWidget) {
+            editor = editor.getParentEditor();
+        }
+        const position = editor?.getPosition();
+        const model = editor?.getModel();
+        if (!position || !model || !('uri' in model)) {
+            return;
+        }
+        const testService = accessor.get(ITestService);
+        const demandedUri = ( model.uri.toString());
+        const queue = [testService.collection.rootIds];
+        const discovered = [];
+        while (queue.length) {
+            for (const id of queue.pop()) {
+                const node = testService.collection.getNodeById(id);
+                if (node.item.uri?.toString() === demandedUri) {
+                    discovered.push(node);
+                }
+                else {
+                    queue.push(node.children);
+                }
+            }
+        }
+        if (discovered.length) {
+            return testService.runTests({
+                tests: discovered,
+                group: this.group,
+            });
+        }
+        if (editor) {
+            MessageController.get(editor)?.showMessage(( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'noTestsInFile',
+                "No tests found in this file"
+            )), position);
+        }
+        return undefined;
+    }
+}
+class RunCurrentFile extends ExecuteTestsInCurrentFile {
+    constructor() {
+        super({
+            id: "testing.runCurrentFile" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.runCurrentFile',
+                'Run Tests in Current File'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 36 ),
+            },
+        }, 2 );
+    }
+}
+class DebugCurrentFile extends ExecuteTestsInCurrentFile {
+    constructor() {
+        super({
+            id: "testing.debugCurrentFile" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.debugCurrentFile',
+                'Debug Tests in Current File'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 2048  | 36 ),
+            },
+        }, 4 );
+    }
+}
+class CoverageCurrentFile extends ExecuteTestsInCurrentFile {
+    constructor() {
+        super({
+            id: "testing.coverageCurrentFile" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.coverageCurrentFile',
+                'Run Tests with Coverage in Current File'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                when: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 85 , 2048  | 1024  | 36 ),
+            },
+        }, 8 );
+    }
+}
+const discoverAndRunTests = async (collection, progress, ids, runTests) => {
+    const todo = Promise.all(( ids.map(p => expandAndGetTestById(collection, p))));
+    const tests = (await showDiscoveringWhile(progress, todo)).filter(isDefined);
+    return tests.length ? await runTests(tests) : undefined;
+};
+class RunOrDebugExtsByPath extends Action2 {
+    async run(accessor, ...args) {
+        const testService = accessor.get(ITestService);
+        await discoverAndRunTests(accessor.get(ITestService).collection, accessor.get(IProgressService), [...this.getTestExtIdsToRun(accessor, ...args)], tests => this.runTest(testService, tests));
+    }
+}
+class RunOrDebugFailedTests extends RunOrDebugExtsByPath {
+    constructor(options) {
+        super({
+            ...options,
+            menu: {
+                id: MenuId.CommandPalette,
+                when: hasAnyTestProvider,
+            },
+        });
+    }
+    getTestExtIdsToRun(accessor) {
+        const { results } = accessor.get(ITestResultService);
+        const ids = ( new Set());
+        for (let i = results.length - 1; i >= 0; i--) {
+            const resultSet = results[i];
+            for (const test of resultSet.tests) {
+                if (isFailedState(test.ownComputedState)) {
+                    ids.add(test.item.extId);
+                }
+                else {
+                    ids.delete(test.item.extId);
+                }
+            }
+        }
+        return ids;
+    }
+}
+class RunOrDebugLastRun extends RunOrDebugExtsByPath {
+    constructor(options) {
+        super({
+            ...options,
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( ContextKeyExpr.and(hasAnyTestProvider, ( TestingContextKeys.hasAnyResults.isEqualTo(true)))),
+            },
+        });
+    }
+    *getTestExtIdsToRun(accessor, runId) {
+        const resultService = accessor.get(ITestResultService);
+        const lastResult = runId ? resultService.results.find(r => r.id === runId) : resultService.results[0];
+        if (!lastResult) {
+            return;
+        }
+        for (const test of lastResult.request.targets) {
+            for (const testId of test.testIds) {
+                yield testId;
+            }
+        }
+    }
+}
+class ReRunFailedTests extends RunOrDebugFailedTests {
+    constructor() {
+        super({
+            id: "testing.reRunFailTests" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.reRunFailTests',
+                'Rerun Failed Tests'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 35 ),
+            },
+        });
+    }
+    runTest(service, internalTests) {
+        return service.runTests({
+            group: 2 ,
+            tests: internalTests,
+        });
+    }
+}
+class DebugFailedTests extends RunOrDebugFailedTests {
+    constructor() {
+        super({
+            id: "testing.debugFailTests" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.debugFailTests',
+                'Debug Failed Tests'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 35 ),
+            },
+        });
+    }
+    runTest(service, internalTests) {
+        return service.runTests({
+            group: 4 ,
+            tests: internalTests,
+        });
+    }
+}
+class ReRunLastRun extends RunOrDebugLastRun {
+    constructor() {
+        super({
+            id: "testing.reRunLastRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.reRunLastRun',
+                'Rerun Last Run'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 42 ),
+            },
+        });
+    }
+    runTest(service, internalTests) {
+        return service.runTests({
+            group: 2 ,
+            tests: internalTests,
+        });
+    }
+}
+class DebugLastRun extends RunOrDebugLastRun {
+    constructor() {
+        super({
+            id: "testing.debugLastRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.debugLastRun',
+                'Debug Last Run'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 42 ),
+            },
+        });
+    }
+    runTest(service, internalTests) {
+        return service.runTests({
+            group: 4 ,
+            tests: internalTests,
+        });
+    }
+}
+class CoverageLastRun extends RunOrDebugLastRun {
+    constructor() {
+        super({
+            id: "testing.coverageLastRun" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.coverageLastRun',
+                'Rerun Last Run with Coverage'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 1024  | 42 ),
+            },
+        });
+    }
+    runTest(service, internalTests) {
+        return service.runTests({
+            group: 8 ,
+            tests: internalTests,
+        });
+    }
+}
+class SearchForTestExtension extends Action2 {
+    constructor() {
+        super({
+            id: "testing.searchForTestExtension" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.searchForTestExtension',
+                'Search for Test Extension'
+            )),
+        });
+    }
+    async run(accessor) {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const viewlet = (await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true))?.getViewPaneContainer();
+        viewlet.search('@category:"testing"');
+        viewlet.focus();
+    }
+}
+class OpenOutputPeek extends Action2 {
+    constructor() {
+        super({
+            id: "testing.openOutputPeek" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.openOutputPeek',
+                'Peek Output'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 43 ),
+            },
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( TestingContextKeys.hasAnyResults.isEqualTo(true)),
+            },
+        });
+    }
+    async run(accessor) {
+        accessor.get(ITestingPeekOpener).open();
+    }
+}
+class ToggleInlineTestOutput extends Action2 {
+    constructor() {
+        super({
+            id: "testing.toggleInlineTestOutput" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.toggleInlineTestOutput',
+                'Toggle Inline Test Output'
+            )),
+            category,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 39 ),
+            },
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( TestingContextKeys.hasAnyResults.isEqualTo(true)),
+            },
+        });
+    }
+    async run(accessor) {
+        const testService = accessor.get(ITestService);
+        testService.showInlineOutput.value = !testService.showInlineOutput.value;
+    }
+}
+const refreshMenus = (whenIsRefreshing) => [
+    {
+        id: MenuId.TestItem,
+        group: 'inline',
+        order: 10 ,
+        when: ( ContextKeyExpr.and(( TestingContextKeys.canRefreshTests.isEqualTo(true)), ( TestingContextKeys.isRefreshingTests.isEqualTo(whenIsRefreshing)))),
+    },
+    {
+        id: MenuId.ViewTitle,
+        group: 'navigation',
+        order: 10 ,
+        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', "workbench.view.testing" )), ( TestingContextKeys.canRefreshTests.isEqualTo(true)), ( TestingContextKeys.isRefreshingTests.isEqualTo(whenIsRefreshing)))),
+    },
+    {
+        id: MenuId.CommandPalette,
+        when: ( TestingContextKeys.canRefreshTests.isEqualTo(true)),
+    },
+];
+class RefreshTestsAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.refreshTests" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.refreshTests',
+                'Refresh Tests'
+            )),
+            category,
+            icon: testingRefreshTests,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 85 , 2048  | 48 ),
+                when: ( TestingContextKeys.canRefreshTests.isEqualTo(true)),
+            },
+            menu: refreshMenus(false),
+        });
+    }
+    async run(accessor, ...elements) {
+        const testService = accessor.get(ITestService);
+        const progressService = accessor.get(IProgressService);
+        const controllerIds = distinct(( elements.filter(isDefined).map(e => e.test.controllerId)));
+        return progressService.withProgress({ location: "workbench.view.extension.test"  }, async () => {
+            if (controllerIds.length) {
+                await Promise.all(( controllerIds.map(id => testService.refreshTests(id))));
+            }
+            else {
+                await testService.refreshTests();
+            }
+        });
+    }
+}
+class CancelTestRefreshAction extends Action2 {
+    constructor() {
+        super({
+            id: "testing.cancelTestRefresh" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.cancelTestRefresh',
+                'Cancel Test Refresh'
+            )),
+            category,
+            icon: testingCancelRefreshTests,
+            menu: refreshMenus(true),
+        });
+    }
+    async run(accessor) {
+        accessor.get(ITestService).cancelRefreshTests();
+    }
+}
+class CleareCoverage extends Action2 {
+    constructor() {
+        super({
+            id: "testing.coverage.close" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.clearCoverage',
+                'Clear Coverage'
+            )),
+            icon: widgetClose,
+            category,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 10 ,
+                    when: ( ContextKeyExpr.equals('view', "workbench.view.testCoverage" ))
+                }, {
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.isTestCoverageOpen.isEqualTo(true)),
+                }]
+        });
+    }
+    run(accessor) {
+        accessor.get(ITestCoverageService).closeCoverage();
+    }
+}
+class OpenCoverage extends Action2 {
+    constructor() {
+        super({
+            id: "testing.openCoverage" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.openCoverage',
+                'Open Coverage'
+            )),
+            category,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: ( TestingContextKeys.hasAnyResults.isEqualTo(true)),
+                }]
+        });
+    }
+    run(accessor) {
+        const results = accessor.get(ITestResultService).results;
+        const task = results.length && results[0].tasks.find(r => r.coverage);
+        if (!task) {
+            const notificationService = accessor.get(INotificationService);
+            notificationService.info(( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testExplorerActions',
+                'testing.noCoverage',
+                'No coverage information available on the last test run.'
+            )));
+            return;
+        }
+        accessor.get(ITestCoverageService).openCoverage(task, true);
+    }
+}
+const allTestActions = [
+    CancelTestRefreshAction,
+    CancelTestRunAction,
+    ClearTestResultsAction,
+    CleareCoverage,
+    CollapseAllAction,
+    ConfigureTestProfilesAction,
+    ContinuousRunTestAction,
+    ContinuousRunUsingProfileTestAction,
+    CoverageAction,
+    CoverageAllAction,
+    CoverageAtCursor,
+    CoverageCurrentFile,
+    CoverageLastRun,
+    CoverageSelectedAction,
+    CoverageTestsUnderUri,
+    DebugAction,
+    DebugAllAction,
+    DebugAtCursor,
+    DebugCurrentFile,
+    DebugFailedTests,
+    DebugLastRun,
+    DebugSelectedAction,
+    DebugTestsUnderUri,
+    GetExplorerSelection,
+    GetSelectedProfiles,
+    GoToTest,
+    HideTestAction,
+    OpenCoverage,
+    OpenOutputPeek,
+    RefreshTestsAction,
+    ReRunFailedTests,
+    ReRunLastRun,
+    RunAction,
+    RunAllAction,
+    RunAtCursor,
+    RunCurrentFile,
+    RunSelectedAction,
+    RunTestsUnderUri,
+    RunUsingProfileAction,
+    SearchForTestExtension,
+    SelectDefaultTestProfiles,
+    ShowMostRecentOutputAction,
+    StartContinuousRunAction,
+    StopContinuousRunAction,
+    TestingSortByDurationAction,
+    TestingSortByLocationAction,
+    TestingSortByStatusAction,
+    TestingViewAsListAction,
+    TestingViewAsTreeAction,
+    ToggleInlineTestOutput,
+    UnhideAllTestsAction,
+    UnhideTestAction,
+];
+export { CancelTestRefreshAction, CancelTestRunAction, ClearTestResultsAction, CleareCoverage, CollapseAllAction, ConfigureTestProfilesAction, ContinuousRunTestAction, ContinuousRunUsingProfileTestAction, CoverageAction, CoverageAllAction, CoverageAtCursor, CoverageCurrentFile, CoverageLastRun, CoverageSelectedAction, DebugAction, DebugAllAction, DebugAtCursor, DebugCurrentFile, DebugFailedTests, DebugLastRun, DebugSelectedAction, GetExplorerSelection, GetSelectedProfiles, GoToTest, HideTestAction, OpenCoverage, OpenOutputPeek, ReRunFailedTests, ReRunLastRun, RefreshTestsAction, RunAction, RunAllAction, RunAtCursor, RunCurrentFile, RunSelectedAction, RunUsingProfileAction, SearchForTestExtension, SelectDefaultTestProfiles, ShowMostRecentOutputAction, TestingSortByDurationAction, TestingSortByLocationAction, TestingSortByStatusAction, TestingViewAsListAction, TestingViewAsTreeAction, ToggleInlineTestOutput, UnhideAllTestsAction, UnhideTestAction, allTestActions, discoverAndRunTests };