@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,1671 +0,0 @@
-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 };