@codingame/monaco-vscode-testing-service-override 6.0.2 → 7.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-testing-service-override",
-  "version": "6.0.2",
+  "version": "7.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@6.0.2",
-    "@codingame/monaco-vscode-terminal-service-override": "6.0.2"
+    "vscode": "npm:@codingame/monaco-vscode-api@7.0.0",
+    "@codingame/monaco-vscode-terminal-service-override": "7.0.0"
   }
 }

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

@@ -12,11 +12,10 @@ import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { KeyChord, KeyMod, KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
 import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
 import { Disposable, DisposableStore, toDisposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/arrays';
 import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
 import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
 import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
-import 'vscode/vscode/vs/base/common/arrays';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { isUriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
 import { MouseTargetType, OverlayWidgetPositionPreference } from 'vscode/vscode/vs/editor/browser/editorBrowser';
@@ -50,21 +49,17 @@ import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/
 import { DetailType } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { TestingContextKeys } from '../common/testingContextKeys.js';
 
-var CodeCoverageDecorations_1;
 const _moduleId = "vs/workbench/contrib/testing/browser/codeCoverageDecorations";
-const MAX_HOVERED_LINES = 30;
 const CLASS_HIT = 'coverage-deco-hit';
 const CLASS_MISS = 'coverage-deco-miss';
 const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(_moduleId, 0, 'Toggle Inline'));
 const TOGGLE_INLINE_COMMAND_ID = 'testing.toggleInlineCoverage';
 const BRANCH_MISS_INDICATOR_CHARS = 4;
 let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
-    static { CodeCoverageDecorations_1 = this; }
-    static { this.showInline = observableValue('inlineCoverage', false); }
-    static { this.fileCoverageDecorations = ( (new WeakMap())); }
     constructor(editor, instantiationService, coverage, configurationService, log) {
         super();
         this.editor = editor;
+        this.coverage = coverage;
         this.log = log;
         this.displayedStore = this._register(( (new DisposableStore())));
         this.hoveredStore = this._register(( (new DisposableStore())));
@@ -72,8 +67,8 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         this.summaryWidget = ( (new Lazy(
             () => this._register(instantiationService.createInstance(CoverageToolbarWidget, this.editor))
         )));
-        const modelObs = observableFromEvent(editor.onDidChangeModel, () => editor.getModel());
-        const configObs = observableFromEvent(editor.onDidChangeConfiguration, i => i);
+        const modelObs = observableFromEvent(this, editor.onDidChangeModel, () => editor.getModel());
+        const configObs = observableFromEvent(this, editor.onDidChangeConfiguration, i => i);
         const fileCoverage = derived(reader => {
             const report = coverage.selected.read(reader);
             if (!report) {
@@ -83,21 +78,17 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
             if (!model) {
                 return;
             }
-            let file = report.getUri(model.uri);
-            if (file) {
-                const testFilter = coverage.filterToTest.read(reader);
-                if (testFilter) {
-                    file = file.perTestData?.get(( (testFilter.toString()))) || file;
-                }
-                return file;
+            const file = report.getUri(model.uri);
+            if (!file) {
+                return;
             }
             report.didAddCoverage.read(reader);
-            return undefined;
+            return { file, testId: coverage.filterToTest.read(reader) };
         });
         this._register(autorun(reader => {
             const c = fileCoverage.read(reader);
             if (c) {
-                this.apply(editor.getModel(), c, CodeCoverageDecorations_1.showInline.read(reader));
+                this.apply(editor.getModel(), c.file, c.testId, coverage.showInline.read(reader));
             }
             else {
                 this.clear();
@@ -107,10 +98,10 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         this._register(autorun(reader => {
             const c = fileCoverage.read(reader);
             if (c && toolbarEnabled.read(reader)) {
-                this.summaryWidget.value.setCoverage(c);
+                this.summaryWidget.value.setCoverage(c.file, c.testId);
             }
             else {
-                this.summaryWidget.rawValue?.setCoverage(undefined);
+                this.summaryWidget.rawValue?.clearCoverage();
             }
         }));
         this._register(autorun(reader => {
@@ -127,7 +118,7 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
             if (e.target.type === MouseTargetType.GUTTER_LINE_NUMBERS && model) {
                 this.hoverLineNumber(editor.getModel(), e.target.position.lineNumber);
             }
-            else if (CodeCoverageDecorations_1.showInline.get() && e.target.type === MouseTargetType.CONTENT_TEXT && model) {
+            else if (coverage.showInline.get() && e.target.type === MouseTargetType.CONTENT_TEXT && model) {
                 this.hoverInlineDecoration(model, e.target.position);
             }
             else {
@@ -184,9 +175,13 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         this.hoveredSubject = lineNumber;
         const todo = [{ line: lineNumber, dir: 0 }];
         const toEnable = ( (new Set()));
-        if (!CodeCoverageDecorations_1.showInline.get()) {
-            for (let i = 0; i < todo.length && i < MAX_HOVERED_LINES; i++) {
+        const ranges = this.editor.getVisibleRanges();
+        if (!this.coverage.showInline.get()) {
+            for (let i = 0; i < todo.length; i++) {
                 const { line, dir } = todo[i];
+                if (!( (ranges.some(r => r.startLineNumber <= line && r.endLineNumber >= line)))) {
+                    continue;
+                }
                 let found = false;
                 for (const decoration of model.getLineDecorations(line)) {
                     if (( (this.decorationIds.has(decoration.id)))) {
@@ -227,8 +222,8 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
             });
         }));
     }
-    async apply(model, coverage, showInlineByDefault) {
-        const details = this.details = await this.loadDetails(coverage, model);
+    async apply(model, coverage, testId, showInlineByDefault) {
+        const details = this.details = await this.loadDetails(coverage, testId, model);
         if (!details) {
             return this.clear();
         }
@@ -303,22 +298,19 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         this.displayedStore.clear();
         this.hoveredStore.clear();
     }
-    async loadDetails(coverage, textModel) {
-        const existing = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage);
-        if (existing) {
-            return existing;
-        }
+    async loadDetails(coverage, testId, textModel) {
         const cts = this.loadingCancellation = ( (new CancellationTokenSource()));
         this.displayedStore.add(this.loadingCancellation);
         try {
-            const details = await coverage.details(this.loadingCancellation.token);
+            const details = testId
+                ? await coverage.detailsForTest(testId, this.loadingCancellation.token)
+                : await coverage.details(this.loadingCancellation.token);
             if (cts.token.isCancellationRequested) {
                 return;
             }
-            const model = CodeCoverageDecorations_1.fileCoverageDecorations.get(coverage)
-                || ( (new CoverageDetailsModel(details, textModel)));
-            CodeCoverageDecorations_1.fileCoverageDecorations.set(coverage, model);
-            return model;
+            return (
+                 (new CoverageDetailsModel(details, textModel))
+            );
         }
         catch (e) {
             this.log.error('Error loading coverage details', e);
@@ -326,7 +318,7 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         return undefined;
     }
 };
-CodeCoverageDecorations = CodeCoverageDecorations_1 = ( (__decorate([
+CodeCoverageDecorations = ( (__decorate([
     ( (__param(1, IInstantiationService))),
     ( (__param(2, ITestCoverageService))),
     ( (__param(3, IConfigurationService))),
@@ -472,7 +464,7 @@ function wrapName(functionNameOrCode) {
     return wrapInBackticks(functionNameOrCode);
 }
 let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
-    constructor(editor, configurationService, contextMenuService, testService, keybindingService, commandService, instaService) {
+    constructor(editor, configurationService, contextMenuService, testService, keybindingService, commandService, coverage, instaService) {
         super();
         this.editor = editor;
         this.configurationService = configurationService;
@@ -480,6 +472,7 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
         this.testService = testService;
         this.keybindingService = keybindingService;
         this.commandService = commandService;
+        this.coverage = coverage;
         this.registered = false;
         this.isRunning = false;
         this.showStore = this._register(( (new DisposableStore())));
@@ -505,7 +498,7 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
             }
         }));
         this._register(autorun(reader => {
-            CodeCoverageDecorations.showInline.read(reader);
+            coverage.showInline.read(reader);
             this.setActions();
         }));
         this._register(addStandardDisposableListener(this._domNode.root, EventType.CONTEXT_MENU, e => {
@@ -527,8 +520,13 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
             stackOridinal: 9,
         };
     }
-    setCoverage(coverage) {
-        this.current = coverage;
+    clearCoverage() {
+        this.current = undefined;
+        this.bars.setCoverageInfo(undefined);
+        this.hide();
+    }
+    setCoverage(coverage, testId) {
+        this.current = { coverage, testId };
         this.bars.setCoverageInfo(coverage);
         if (!coverage) {
             this.hide();
@@ -540,36 +538,36 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
     }
     setActions() {
         this.actionBar.clear();
-        const coverage = this.current;
-        if (!coverage) {
+        const current = this.current;
+        if (!current) {
             return;
         }
-        const toggleAction = ( (new ActionWithIcon('toggleInline', CodeCoverageDecorations.showInline.get()
+        const toggleAction = ( (new ActionWithIcon('toggleInline', this.coverage.showInline.get()
             ? ( localizeWithPath(_moduleId, 8, 'Hide Inline Coverage'))
-            : ( localizeWithPath(_moduleId, 9, 'Show Inline Coverage')), testingCoverageReport, undefined, () => CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined))));
+            : ( localizeWithPath(_moduleId, 9, 'Show Inline Coverage')), testingCoverageReport, undefined, () => this.coverage.showInline.set(!this.coverage.showInline.get(), undefined))));
         const kb = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
         if (kb) {
             toggleAction.tooltip = `${TOGGLE_INLINE_COMMAND_TEXT} (${kb.getLabel()})`;
         }
         this.actionBar.push(toggleAction);
-        if (coverage.isForTest) {
-            const testItem = coverage.fromResult.getTestById(( (coverage.isForTest.id.toString())));
+        if (current.testId) {
+            const testItem = current.coverage.fromResult.getTestById(( (current.testId.toString())));
             assert(!!testItem, 'got coverage for an unreported test');
             this.actionBar.push(( (new ActionWithIcon(
                 'perTestFilter',
                 labels.showingFilterFor(testItem.label),
                 testingFilterIcon,
                 undefined,
-                () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current)
+                () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current, this.editor)
             ))));
         }
-        else if (coverage.perTestData?.size) {
+        else if (current.coverage.perTestData?.size) {
             this.actionBar.push(( (new ActionWithIcon('perTestFilter', ( localizeWithPath(
                 _moduleId,
                 10,
                 "{0} test(s) ran code in this file",
-                coverage.perTestData.size
-            )), testingFilterIcon, undefined, () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current)))));
+                current.coverage.perTestData.size
+            )), testingFilterIcon, undefined, () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current, this.editor)))));
         }
         this.actionBar.push(( (new ActionWithIcon('rerun', ( localizeWithPath(_moduleId, 11, 'Rerun')), testingRerunIcon, !this.isRunning, () => this.rerunTest()))));
     }
@@ -598,8 +596,8 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
             });
         }));
         ds.add(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(TestingConfigKeys.CoverageBarThresholds) || e.affectsConfiguration(TestingConfigKeys.CoveragePercent)) {
-                this.setCoverage(this.current);
+            if (this.current && (e.affectsConfiguration(TestingConfigKeys.CoverageBarThresholds) || e.affectsConfiguration(TestingConfigKeys.CoveragePercent))) {
+                this.setCoverage(this.current.coverage, this.current.testId);
             }
         }));
     }
@@ -608,7 +606,7 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
         if (current) {
             this.isRunning = true;
             this.setActions();
-            this.testService.runResolvedTests(current.fromResult.request).finally(() => {
+            this.testService.runResolvedTests(current.coverage.fromResult.request).finally(() => {
                 this.isRunning = false;
                 this.setActions();
             });
@@ -624,18 +622,23 @@ CoverageToolbarWidget = ( (__decorate([
     ( (__param(3, ITestService))),
     ( (__param(4, IKeybindingService))),
     ( (__param(5, ICommandService))),
-    ( (__param(6, IInstantiationService)))
+    ( (__param(6, ITestCoverageService))),
+    ( (__param(7, IInstantiationService)))
 ], CoverageToolbarWidget)));
 registerAction2(class ToggleInlineCoverage extends Action2 {
     constructor() {
         super({
             id: TOGGLE_INLINE_COMMAND_ID,
-            title: ( localize2WithPath(_moduleId, 12, "Show Inline Coverage")),
+            title: ( localize2WithPath(_moduleId, 12, "Toggle Inline Coverage")),
             category: Categories.Test,
             keybinding: {
                 weight: KeybindingWeight.WorkbenchContrib,
                 primary: KeyChord(KeyMod.CtrlCmd | KeyCode.Semicolon, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyI),
             },
+            toggled: {
+                condition: TestingContextKeys.inlineCoverageEnabled,
+                title: ( localizeWithPath(_moduleId, 13, "Hide Inline Coverage")),
+            },
             icon: testingCoverageReport,
             menu: [
                 { id: MenuId.CommandPalette, when: TestingContextKeys.isTestCoverageOpen },
@@ -646,17 +649,18 @@ registerAction2(class ToggleInlineCoverage extends Action2 {
             ]
         });
     }
-    run() {
-        CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined);
+    run(accessor) {
+        const coverage = accessor.get(ITestCoverageService);
+        coverage.showInline.set(!coverage.showInline.get(), undefined);
     }
 });
 registerAction2(class ToggleCoverageToolbar extends Action2 {
     constructor() {
         super({
             id: TestCommandId.CoverageToggleToolbar,
-            title: ( localize2WithPath(_moduleId, 13, "Test Coverage Toolbar")),
+            title: ( localize2WithPath(_moduleId, 14, "Test Coverage Toolbar")),
             metadata: {
-                description: ( localize2WithPath(_moduleId, 14, 'Toggle the sticky coverage bar in the editor.'))
+                description: ( localize2WithPath(_moduleId, 15, 'Toggle the sticky coverage bar in the editor.'))
             },
             category: Categories.Test,
             toggled: {
@@ -679,7 +683,7 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
     constructor() {
         super({
             id: TestCommandId.CoverageFilterToTestInEditor,
-            title: ( localize2WithPath(_moduleId, 15, "Filter Coverage to Test")),
+            title: ( localize2WithPath(_moduleId, 16, "Filter Coverage to Test")),
             category: Categories.Test,
             icon: Codicon.filter,
             toggled: {
@@ -694,10 +698,10 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
             ]
         });
     }
-    run(accessor, coverageOrUri) {
+    run(accessor, coverageOrUri, editor) {
         const testCoverageService = accessor.get(ITestCoverageService);
         const quickInputService = accessor.get(IQuickInputService);
-        const activeEditor = accessor.get(ICodeEditorService).getActiveCodeEditor();
+        const activeEditor = editor ?? accessor.get(ICodeEditorService).getActiveCodeEditor();
         let coverage;
         if (coverageOrUri instanceof FileCoverage) {
             coverage = coverageOrUri;
@@ -709,23 +713,17 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
             const uri = activeEditor?.getModel()?.uri;
             coverage = uri && testCoverageService.selected.get()?.getUri(uri);
         }
-        if (!coverage || !(coverage.isForTest || coverage.perTestData?.size)) {
-            return;
-        }
-        const options = coverage?.perTestData ?? coverage?.isForTest?.parent.perTestData;
-        if (!options) {
+        if (!coverage || !coverage.perTestData?.size) {
             return;
         }
-        const tests = [...( (options.values()))];
-        const commonPrefix = TestId.getLengthOfCommonPrefix(tests.length, i => tests[i].isForTest.id);
+        const tests = ( ([...coverage.perTestData].map(TestId.fromString)));
+        const commonPrefix = TestId.getLengthOfCommonPrefix(tests.length, i => tests[i]);
         const result = coverage.fromResult;
         const previousSelection = testCoverageService.filterToTest.get();
         const items = [
-            { label: labels.allTests, item: undefined },
+            { label: labels.allTests, testId: undefined },
             { type: 'separator' },
-            ...( (tests.map(
-                item => ({ label: getLabelForItem(result, item.isForTest.id, commonPrefix), description: labels.percentCoverage(item.tpc), item })
-            ))),
+            ...( (tests.map(id => ({ label: getLabelForItem(result, id, commonPrefix), testId: id })))),
         ];
         const scrollTop = activeEditor?.getScrollTop() || 0;
         const revealScrollCts = ( (new MutableDisposable()));
@@ -733,20 +731,20 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
             activeItem: items.find((item) => 'item' in item && item.item === coverage),
             placeHolder: labels.pickShowCoverage,
             onDidFocus: (entry) => {
-                if (!entry.item) {
+                if (!entry.testId) {
                     revealScrollCts.clear();
                     activeEditor?.setScrollTop(scrollTop);
                     testCoverageService.filterToTest.set(undefined, undefined);
                 }
                 else {
                     const cts = revealScrollCts.value = ( (new CancellationTokenSource()));
-                    entry.item.details(cts.token).then(details => {
+                    coverage.detailsForTest(entry.testId, cts.token).then(details => {
                         const first = details.find(d => d.type === DetailType.Statement);
                         if (!cts.token.isCancellationRequested && first) {
                             activeEditor?.revealLineNearTop(first.location instanceof Position ? first.location.lineNumber : first.location.startLineNumber);
                         }
                     }, () => { });
-                    testCoverageService.filterToTest.set(entry.item.isForTest.id, undefined);
+                    testCoverageService.filterToTest.set(entry.testId, undefined);
                 }
             },
         }).then(selected => {
@@ -754,7 +752,7 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
                 activeEditor?.setScrollTop(scrollTop);
             }
             revealScrollCts.dispose();
-            testCoverageService.filterToTest.set(selected ? selected.item?.isForTest.id : previousSelection, undefined);
+            testCoverageService.filterToTest.set(selected ? selected.testId : previousSelection, undefined);
         });
     }
 });

package/vscode/src/vs/workbench/contrib/testing/browser/explorerProjections/treeProjection.js

@@ -142,7 +142,7 @@ let TreeProjection = class TreeProjection extends Disposable {
                         break;
                     }
                     const parent = toRemove.parent;
-                    const affectsRootElement = toRemove.depth === 1 && parent?.children.size === 1;
+                    const affectsRootElement = toRemove.depth === 1 && (parent?.children.size === 1 || !( Iterable.some(this.rootsWithChildren, (_, i) => i === 1)));
                     this.changedParents.add(affectsRootElement ? null : parent);
                     const queue = [[toRemove]];
                     while (queue.length) {

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

@@ -57,7 +57,7 @@ let ManagedTestCoverageBars = class ManagedTestCoverageBars extends Disposable {
         this.customHovers = [];
     }
     attachHover(target, factory) {
-        this._register(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('element'), target, () => this._coverage && factory(this._coverage)));
+        this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('element'), target, () => this._coverage && factory(this._coverage)));
     }
     setCoverageInfo(coverage) {
         const ds = this.visibleStore;
@@ -71,7 +71,7 @@ let ManagedTestCoverageBars = class ManagedTestCoverageBars extends Disposable {
         }
         if (!this._coverage) {
             const root = this.el.value.root;
-            ds.add(toDisposable(() => this.options.container.removeChild(root)));
+            ds.add(toDisposable(() => root.remove()));
             this.options.container.appendChild(root);
             ds.add(this.configurationService.onDidChangeConfiguration(c => {
                 if (!this._coverage) {

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

@@ -541,7 +541,7 @@ registerAction2(class TestCoverageChangePerTestFilterAction extends Action2 {
         if (!coverage) {
             return;
         }
-        const tests = ( ([...coverage.perTestCoverageIDs].map(TestId.fromString)));
+        const tests = ( ([...coverage.allPerTestIDs()].map(TestId.fromString)));
         const commonPrefix = TestId.getLengthOfCommonPrefix(tests.length, i => tests[i]);
         const result = coverage.result;
         const previousSelection = coverageService.filterToTest.get();

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

@@ -38,7 +38,7 @@ import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/
 import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService.service';
 import { testsInFile, testsUnderUri, expandAndGetTestById } from '../common/testService.js';
 import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService.service';
-import { TestRunProfileBitset, ExtTestRunProfileKind } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+import { TestRunProfileBitset, ExtTestRunProfileKind, TestItemExpandState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { TestingContextKeys } from '../common/testingContextKeys.js';
 import { ITestingContinuousRunService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingContinuousRunService.service';
 import { ITestingPeekOpener } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingPeekOpener.service';
@@ -199,8 +199,8 @@ class RunUsingProfileAction extends Action2 {
             return;
         }
         testService.runResolvedTests({
+            group: profile.group,
             targets: [{
-                    profileGroup: profile.group,
                     profileId: profile.profileId,
                     controllerId: profile.controllerId,
                     testIds: ( (elements.filter(t => canUseProfileWithTest(profile, t.test)).map(t => t.test.item.extId)))
@@ -543,7 +543,8 @@ class RunOrDebugAllTestsAction extends Action2 {
     async run(accessor) {
         const testService = accessor.get(ITestService);
         const notifications = accessor.get(INotificationService);
-        const roots = [...testService.collection.rootItems];
+        const roots = [...testService.collection.rootItems].filter(r => r.children.size
+            || r.expand === TestItemExpandState.Expandable || r.expand === TestItemExpandState.BusyExpanding);
         if (!roots.length) {
             notifications.info(this.noTestsFoundError);
             return;
@@ -1150,7 +1151,7 @@ class RunOrDebugFailedTests extends RunOrDebugExtsByPath {
         return ids;
     }
 }
-class RunOrDebugLastRun extends RunOrDebugExtsByPath {
+class RunOrDebugLastRun extends Action2 {
     constructor(options) {
         super({
             ...options,
@@ -1163,17 +1164,33 @@ class RunOrDebugLastRun extends RunOrDebugExtsByPath {
             },
         });
     }
-    *getTestExtIdsToRun(accessor, runId) {
+    getLastTestRunRequest(accessor, runId) {
+        const resultService = accessor.get(ITestResultService);
+        const lastResult = runId ? resultService.results.find(r => r.id === runId) : resultService.results[0];
+        return lastResult?.request;
+    }
+    async run(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;
+        const req = lastResult.request;
+        const testService = accessor.get(ITestService);
+        const profileService = accessor.get(ITestProfileService);
+        const profileExists = (t) => ( (profileService.getControllerProfiles(t.controllerId).some(p => p.profileId === t.profileId)));
+        await discoverAndRunTests(testService.collection, accessor.get(IProgressService), req.targets.flatMap(t => t.testIds), tests => {
+            if (this.getGroup() & req.group && req.targets.every(profileExists)) {
+                return testService.runResolvedTests({
+                    targets: req.targets,
+                    group: req.group,
+                    exclude: req.exclude,
+                });
             }
-        }
+            else {
+                return testService.runTests({ tests, group: this.getGroup() });
+            }
+        });
     }
 }
 class ReRunFailedTests extends RunOrDebugFailedTests {
@@ -1226,11 +1243,8 @@ class ReRunLastRun extends RunOrDebugLastRun {
             },
         });
     }
-    runTest(service, internalTests) {
-        return service.runTests({
-            group: TestRunProfileBitset.Run,
-            tests: internalTests,
-        });
+    getGroup() {
+        return TestRunProfileBitset.Run;
     }
 }
 class DebugLastRun extends RunOrDebugLastRun {
@@ -1245,11 +1259,8 @@ class DebugLastRun extends RunOrDebugLastRun {
             },
         });
     }
-    runTest(service, internalTests) {
-        return service.runTests({
-            group: TestRunProfileBitset.Debug,
-            tests: internalTests,
-        });
+    getGroup() {
+        return TestRunProfileBitset.Debug;
     }
 }
 class CoverageLastRun extends RunOrDebugLastRun {
@@ -1264,11 +1275,8 @@ class CoverageLastRun extends RunOrDebugLastRun {
             },
         });
     }
-    runTest(service, internalTests) {
-        return service.runTests({
-            group: TestRunProfileBitset.Coverage,
-            tests: internalTests,
-        });
+    getGroup() {
+        return TestRunProfileBitset.Coverage;
     }
 }
 class SearchForTestExtension extends Action2 {

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

@@ -682,8 +682,8 @@ let RunTestDecoration = class RunTestDecoration {
                     return;
                 }
                 this.testService.runResolvedTests({
+                    group: profile.group,
                     targets: [{
-                            profileGroup: profile.group,
                             profileId: profile.profileId,
                             controllerId: profile.controllerId,
                             testIds: [test.item.extId]

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

@@ -26,7 +26,8 @@ const testFilterDescriptions = {
     [TestFilterTerm.Failed]: ( localizeWithPath(_moduleId, 0, "Show Only Failed Tests")),
     [TestFilterTerm.Executed]: ( localizeWithPath(_moduleId, 1, "Show Only Executed Tests")),
     [TestFilterTerm.CurrentDoc]: ( localizeWithPath(_moduleId, 2, "Show in Active File Only")),
-    [TestFilterTerm.Hidden]: ( localizeWithPath(_moduleId, 3, "Show Hidden Tests")),
+    [TestFilterTerm.OpenedFiles]: ( localizeWithPath(_moduleId, 3, "Show in Opened Files Only")),
+    [TestFilterTerm.Hidden]: ( localizeWithPath(_moduleId, 4, "Show Hidden Tests")),
 };
 let TestingExplorerFilter = class TestingExplorerFilter extends BaseActionViewItem {
     constructor(action, options, state, instantiationService, testService) {
@@ -41,7 +42,7 @@ let TestingExplorerFilter = class TestingExplorerFilter extends BaseActionViewIt
             scope: StorageScope.WORKSPACE,
             target: StorageTarget.MACHINE
         }));
-        this.filtersAction = ( (new Action('markersFiltersAction', ( localizeWithPath(_moduleId, 4, "More Filters...")), 'testing-filter-button ' + ThemeIcon.asClassName(testingFilterIcon))));
+        this.filtersAction = ( (new Action('markersFiltersAction', ( localizeWithPath(_moduleId, 5, "More Filters...")), 'testing-filter-button ' + ThemeIcon.asClassName(testingFilterIcon))));
         this.updateFilterActiveState();
         this._register(testService.excluded.onTestExclusionsChanged(this.updateFilterActiveState, this));
     }
@@ -59,7 +60,7 @@ let TestingExplorerFilter = class TestingExplorerFilter extends BaseActionViewIt
         }
         const input = this.input = this._register(this.instantiationService.createInstance(ContextScopedSuggestEnabledInputWithHistory, {
             id: 'testing.explorer.filter',
-            ariaLabel: ( localizeWithPath(_moduleId, 5, "Filter text for tests in the explorer")),
+            ariaLabel: ( localizeWithPath(_moduleId, 6, "Filter text for tests in the explorer")),
             parent: wrapper,
             suggestionProvider: {
                 triggerCharacters: ['@'],
@@ -79,7 +80,7 @@ let TestingExplorerFilter = class TestingExplorerFilter extends BaseActionViewIt
             resourceHandle: 'testing:filter',
             suggestOptions: {
                 value: this.state.text.value,
-                placeholderText: ( localizeWithPath(_moduleId, 6, "Filter (e.g. text, !exclude, @tag)")),
+                placeholderText: ( localizeWithPath(_moduleId, 7, "Filter (e.g. text, !exclude, @tag)")),
             },
             history: history.values
         }));
@@ -148,7 +149,7 @@ let FiltersDropdownMenuActionViewItem = class FiltersDropdownMenuActionViewItem
     }
     getActions() {
         return [
-            ...( ([TestFilterTerm.Failed, TestFilterTerm.Executed, TestFilterTerm.CurrentDoc].map(term => ({
+            ...( ([TestFilterTerm.Failed, TestFilterTerm.Executed, TestFilterTerm.CurrentDoc, TestFilterTerm.OpenedFiles].map(term => ({
                 checked: this.filters.isFilteringFor(term),
                 class: undefined,
                 enabled: true,
@@ -164,7 +165,7 @@ let FiltersDropdownMenuActionViewItem = class FiltersDropdownMenuActionViewItem
                 class: undefined,
                 enabled: true,
                 id: 'fuzzy',
-                label: ( localizeWithPath(_moduleId, 7, "Fuzzy Match")),
+                label: ( localizeWithPath(_moduleId, 8, "Fuzzy Match")),
                 run: () => this.filters.fuzzy.value = !this.filters.fuzzy.value,
                 tooltip: ''
             },
@@ -174,7 +175,7 @@ let FiltersDropdownMenuActionViewItem = class FiltersDropdownMenuActionViewItem
                 class: undefined,
                 enabled: this.testService.excluded.hasAny,
                 id: 'showExcluded',
-                label: ( localizeWithPath(_moduleId, 3, "Show Hidden Tests")),
+                label: ( localizeWithPath(_moduleId, 4, "Show Hidden Tests")),
                 run: () => this.filters.toggleFilteringFor(TestFilterTerm.Hidden),
                 tooltip: ''
             },
@@ -182,7 +183,7 @@ let FiltersDropdownMenuActionViewItem = class FiltersDropdownMenuActionViewItem
                 class: undefined,
                 enabled: this.testService.excluded.hasAny,
                 id: 'removeExcluded',
-                label: ( localizeWithPath(_moduleId, 8, "Unhide All Tests")),
+                label: ( localizeWithPath(_moduleId, 9, "Unhide All Tests")),
                 run: async () => this.testService.excluded.clear(),
                 tooltip: ''
             }