@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.js

@@ -17,15 +17,14 @@ import { IInstantiationService } from '../../../../../platform/instantiation/com
 import { DecorationAddon } from './decorationAddon.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
-import { SuggestAddon } from './suggestAddon.js';
 import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
 import { TerminalContextKeys } from '../../common/terminalContextKey.js';
 import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.js';
 import { debounce } from '../../../../../base/common/decorators.js';
 import { MouseWheelClassifier } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
 import { StandardWheelEvent } from '../../../../../base/browser/mouseEvent.js';
-import { IAccessibleNotificationService } from '../../../../../platform/accessibility/common/accessibility.js';
 import { ILayoutService } from '../../../../../platform/layout/browser/layoutService.js';
+import { AudioCue, IAudioCueService } from '../../../../../platform/audioCues/browser/audioCueService.js';
 var XtermTerminal_1;
 let CanvasAddon;
 let ImageAddon;
@@ -57,7 +56,6 @@ let XtermTerminal = class XtermTerminal extends Disposable {
     get isGpuAccelerated() { return !!(this._canvasAddon || this._webglAddon); }
     get markTracker() { return this._markNavigationAddon; }
     get shellIntegration() { return this._shellIntegrationAddon; }
-    get suggestController() { return this._suggestAddon; }
     get textureAtlas() {
         const canvas = this._webglAddon?.textureAtlas || this._canvasAddon?.textureAtlas;
         if (!canvas) {
@@ -71,12 +69,11 @@ let XtermTerminal = class XtermTerminal extends Disposable {
         }
         return isAncestorOfActiveElement(this.raw.element);
     }
-    constructor(xtermCtor, _configHelper, cols, rows, _xtermColorProvider, _capabilities, shellIntegrationNonce, _terminalSuggestWidgetVisibleContextKey, disableShellIntegrationReporting, _configurationService, _instantiationService, _logService, _notificationService, _storageService, _themeService, _telemetryService, _clipboardService, contextKeyService, _accessibleNotificationService, layoutService) {
+    constructor(xtermCtor, _configHelper, cols, rows, _xtermColorProvider, _capabilities, shellIntegrationNonce, disableShellIntegrationReporting, _configurationService, _instantiationService, _logService, _notificationService, _storageService, _themeService, _telemetryService, _clipboardService, contextKeyService, _audioCueService, layoutService) {
         super();
         this._configHelper = _configHelper;
         this._xtermColorProvider = _xtermColorProvider;
         this._capabilities = _capabilities;
-        this._terminalSuggestWidgetVisibleContextKey = _terminalSuggestWidgetVisibleContextKey;
         this._configurationService = _configurationService;
         this._instantiationService = _instantiationService;
         this._logService = _logService;
@@ -85,7 +82,7 @@ let XtermTerminal = class XtermTerminal extends Disposable {
         this._themeService = _themeService;
         this._telemetryService = _telemetryService;
         this._clipboardService = _clipboardService;
-        this._accessibleNotificationService = _accessibleNotificationService;
+        this._audioCueService = _audioCueService;
         this._isPhysicalMouseWheel = MouseWheelClassifier.INSTANCE.isPhysicalMouseWheel();
         this._attachedDisposables = this._register(( new DisposableStore()));
         this._onDidRequestRunCommand = this._register(( new Emitter()));
@@ -176,14 +173,6 @@ let XtermTerminal = class XtermTerminal extends Disposable {
         this.raw.loadAddon(this._shellIntegrationAddon);
         this._anyTerminalFocusContextKey = TerminalContextKeys.focusInAny.bindTo(contextKeyService);
         this._anyFocusedTerminalHasSelection = TerminalContextKeys.textSelectedInFocused.bindTo(contextKeyService);
-        if (this._terminalSuggestWidgetVisibleContextKey) {
-            this._suggestAddon = this._register(this._instantiationService.createInstance(SuggestAddon, this._terminalSuggestWidgetVisibleContextKey));
-            this.raw.loadAddon(this._suggestAddon);
-            this._register(this._suggestAddon.onAcceptedCompletion(async (text) => {
-                this._onDidRequestFocus.fire();
-                this._onDidRequestSendText.fire(text);
-            }));
-        }
     }
     *getBufferReverseIterator() {
         for (let i = this.raw.buffer.active.length; i >= 0; i--) {
@@ -252,7 +241,6 @@ let XtermTerminal = class XtermTerminal extends Disposable {
                 this._updateSmoothScrolling();
             }
         }, { passive: true }));
-        this._suggestAddon?.setContainer(container);
         this._attached = { container, options };
         return this._attached?.container.querySelector('.xterm-screen');
     }
@@ -432,7 +420,7 @@ let XtermTerminal = class XtermTerminal extends Disposable {
         this.raw.clear();
         this._capabilities.get(2 )?.handlePromptStart();
         this._capabilities.get(2 )?.handleCommandStart();
-        this._accessibleNotificationService.notify("clear" );
+        this._audioCueService.playAudioCue(AudioCue.clear);
     }
     hasSelection() {
         return this.raw.hasSelection();
@@ -770,17 +758,17 @@ XtermTerminal.__decorator = ( __decorate([
     debounce(100)
 ], XtermTerminal.prototype, "_refreshImageAddon", null));
 XtermTerminal = XtermTerminal_1 = ( __decorate([
-    ( __param(9, IConfigurationService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, ITerminalLogService)),
-    ( __param(12, INotificationService)),
-    ( __param(13, IStorageService)),
-    ( __param(14, IThemeService)),
-    ( __param(15, ITelemetryService)),
-    ( __param(16, IClipboardService)),
-    ( __param(17, IContextKeyService)),
-    ( __param(18, IAccessibleNotificationService)),
-    ( __param(19, ILayoutService))
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ITerminalLogService)),
+    ( __param(11, INotificationService)),
+    ( __param(12, IStorageService)),
+    ( __param(13, IThemeService)),
+    ( __param(14, ITelemetryService)),
+    ( __param(15, IClipboardService)),
+    ( __param(16, IContextKeyService)),
+    ( __param(17, IAudioCueService)),
+    ( __param(18, ILayoutService))
 ], XtermTerminal));
 function getXtermScaledDimensions(w, font, width, height) {
     if (!font.charWidth || !font.charHeight) {

package/vscode/src/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -116,7 +116,7 @@ const TERMINAL_FIND_MATCH_BACKGROUND_COLOR = registerColor('terminal.findMatchBa
     'vs/workbench/contrib/terminal/common/terminalColorRegistry',
     'terminal.findMatchBackground',
     'Color of the current search match in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
-)));
+)), true);
 registerColor('terminal.hoverHighlightBackground', {
     dark: ( transparent(editorHoverHighlight, 0.5)),
     light: ( transparent(editorHoverHighlight, 0.5)),
@@ -146,7 +146,7 @@ const TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR = registerColor('terminal.f
     'vs/workbench/contrib/terminal/common/terminalColorRegistry',
     'terminal.findMatchHighlightBackground',
     'Color of the other search matches in the terminal. The color must not be opaque so as not to hide underlying terminal content.'
-)));
+)), true);
 const TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR = registerColor('terminal.findMatchHighlightBorder', {
     dark: null,
     light: null,
@@ -176,7 +176,7 @@ registerColor('terminal.dropBackground', {
     'vs/workbench/contrib/terminal/common/terminalColorRegistry',
     'terminal.dragAndDropBackground',
     "Background color when dragging on top of terminals. The color should have transparency so that the terminal contents can still shine through."
-)));
+)), true);
 registerColor('terminal.tab.activeBorder', {
     dark: TAB_ACTIVE_BORDER,
     light: TAB_ACTIVE_BORDER,

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.js

@@ -4,20 +4,22 @@ import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';
 import { ICoveredCount } from './testTypes.js';
 class TestCoverage {
-    static async load(taskId, accessor, token) {
+    static async load(taskId, accessor, uriIdentityService, token) {
         const files = await accessor.provideFileCoverage(token);
         const map = ( new ResourceMap());
         for (const [i, file] of files.entries()) {
             map.set(file.uri, ( new FileCoverage(file, i, accessor)));
         }
-        return ( new TestCoverage(taskId, map));
+        return ( new TestCoverage(taskId, map, uriIdentityService));
     }
     get tree() {
         return this._tree ??= this.buildCoverageTree();
     }
-    constructor(fromTaskId, fileCoverage) {
+    constructor(fromTaskId, fileCoverage, uriIdentityService) {
         this.fromTaskId = fromTaskId;
         this.fileCoverage = fileCoverage;
+        this.uriIdentityService = uriIdentityService;
+        this.associatedData = ( new Map());
     }
     getAllFiles() {
         return this.fileCoverage;
@@ -26,12 +28,17 @@ class TestCoverage {
         return this.fileCoverage.get(uri);
     }
     getComputedForUri(uri) {
-        return this.tree.find(this.treePathForUri(uri));
+        return this.tree.find(this.treePathForUri(uri,  false));
     }
     buildCoverageTree() {
         const tree = ( new WellDefinedPrefixTree());
+        const nodeCanonicalSegments = ( new Map());
         for (const file of ( this.fileCoverage.values())) {
-            tree.insert(this.treePathForUri(file.uri), file);
+            const keyPath = this.treePathForUri(file.uri,  false);
+            const canonicalPath = this.treePathForUri(file.uri,  true);
+            tree.insert(keyPath, file, node => {
+                nodeCanonicalSegments.set(node, canonicalPath.next().value);
+            });
         }
         const calculateComputed = (path, node) => {
             if (node.value) {
@@ -43,7 +50,7 @@ class TestCoverage {
             };
             if (node.children) {
                 for (const [prefix, child] of node.children) {
-                    path.push(prefix);
+                    path.push(nodeCanonicalSegments.get(child) || prefix);
                     const v = calculateComputed(path, child);
                     path.pop();
                     ICoveredCount.sum(fileCoverage.statement, v.statement);
@@ -62,31 +69,35 @@ class TestCoverage {
         }
         return tree;
     }
-    *treePathForUri(uri) {
+    *treePathForUri(uri, canconicalPath) {
         yield uri.scheme;
         yield uri.authority;
-        yield* uri.path.split('/');
+        const path = !canconicalPath && this.uriIdentityService.extUri.ignorePathCasing(uri) ? uri.path.toLowerCase() : uri.path;
+        yield* path.split('/');
     }
     treePathToUri(path) {
         return ( URI.from({ scheme: path[0], authority: path[1], path: path.slice(2).join('/') }));
     }
 }
+const getTotalCoveragePercent = (statement, branch, function_) => {
+    let numerator = statement.covered;
+    let denominator = statement.total;
+    if (branch) {
+        numerator += branch.covered;
+        denominator += branch.total;
+    }
+    if (function_) {
+        numerator += function_.covered;
+        denominator += function_.total;
+    }
+    return denominator === 0 ? 1 : numerator / denominator;
+};
 class AbstractFileCoverage {
     get tpc() {
-        let numerator = this.statement.covered;
-        let denominator = this.statement.total;
-        if (this.branch) {
-            numerator += this.branch.covered;
-            denominator += this.branch.total;
-        }
-        if (this.function) {
-            numerator += this.function.covered;
-            denominator += this.function.total;
-        }
-        return denominator === 0 ? 1 : numerator / denominator;
+        return getTotalCoveragePercent(this.statement, this.branch, this.function);
     }
     constructor(coverage) {
-        this.uri = URI.revive(coverage.uri);
+        this.uri = coverage.uri;
         this.statement = coverage.statement;
         this.branch = coverage.branch;
         this.function = coverage.function;
@@ -95,6 +106,9 @@ class AbstractFileCoverage {
 class ComputedFileCoverage extends AbstractFileCoverage {
 }
 class FileCoverage extends AbstractFileCoverage {
+    get hasSynchronousDetails() {
+        return this._details instanceof Array || this.resolved;
+    }
     constructor(coverage, index, accessor) {
         super(coverage);
         this.index = index;
@@ -104,7 +118,9 @@ class FileCoverage extends AbstractFileCoverage {
     async details(token = CancellationToken.None) {
         this._details ??= this.accessor.resolveFileCoverage(this.index, token);
         try {
-            return await this._details;
+            const d = await this._details;
+            this.resolved = true;
+            return d;
         }
         catch (e) {
             this._details = undefined;
@@ -112,4 +128,4 @@ class FileCoverage extends AbstractFileCoverage {
         }
     }
 }
-export { AbstractFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage };
+export { AbstractFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage, getTotalCoveragePercent };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverageService.js

@@ -5,7 +5,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { INotificationService } from '../../../../platform/notification/common/notification.js';
-import { IViewsService } from '../../../common/views.js';
+import { IViewsService } from '../../../services/views/common/viewsService.js';
 import { ITestResultService } from './testResultService.js';
 import { TestingContextKeys } from './testingContextKeys.js';
 import { observableValue } from '../../../../base/common/observableInternal/base.js';
@@ -24,6 +24,9 @@ let TestCoverageService = class TestCoverageService extends Disposable {
                 if (coverage) {
                     this.openCoverage(coverage, false);
                 }
+                else {
+                    this.closeCoverage();
+                }
             }
             else if ('removed' in evt && this.selected.get()) {
                 const taskId = this.selected.get()?.fromTaskId;
@@ -50,7 +53,7 @@ let TestCoverageService = class TestCoverageService extends Disposable {
                 this.notificationService.error(( localizeWithPath(
                     'vs/workbench/contrib/testing/common/testCoverageService',
                     'testCoverageError',
-                    'Failed to load test coverage: {}',
+                    'Failed to load test coverage: {0}',
                     String(e)
                 )));
             }

package/vscode/src/vs/workbench/contrib/testing/common/testProfileService.js

@@ -1,14 +1,14 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Emitter } from '../../../../base/common/event.js';
-import { isDefined } from '../../../../base/common/types.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { deepClone } from '../../../../base/common/objects.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.js';
 import { StoredValue } from './storedValue.js';
-import { testRunProfileBitsetList } from './testTypes.js';
 import { TestId } from './testId.js';
+import { testRunProfileBitsetList } from './testTypes.js';
 import { TestingContextKeys } from './testingContextKeys.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
 const ITestProfileService = ( createDecorator('testProfileService'));
 const canUseProfileWithTest = (profile, test) => profile.controllerId === test.controllerId && (TestId.isRoot(test.item.extId) || !profile.tag || test.item.tags.includes(profile.tag));
 const sorter = (a, b) => {
@@ -28,8 +28,9 @@ let TestProfileService = class TestProfileService extends Disposable {
         this.changeEmitter = this._register(( new Emitter()));
         this.controllerProfiles = ( new Map());
         this.onDidChange = this.changeEmitter.event;
-        this.preferredDefaults = this._register(( new StoredValue({
-            key: 'testingPreferredProfiles',
+        storageService.remove('testingPreferredProfiles', 1 );
+        this.userDefaults = this._register(( new StoredValue({
+            key: 'testingPreferredProfiles2',
             scope: 1 ,
             target: 1 ,
         }, storageService)));
@@ -44,14 +45,20 @@ let TestProfileService = class TestProfileService extends Disposable {
         this.refreshContextKeys();
     }
     addProfile(controller, profile) {
+        const previousExplicitDefaultValue = this.userDefaults.get()?.[controller.id]?.[profile.profileId];
+        const extended = {
+            ...profile,
+            isDefault: previousExplicitDefaultValue ?? profile.isDefault,
+            wasInitiallyDefault: profile.isDefault,
+        };
         let record = this.controllerProfiles.get(profile.controllerId);
         if (record) {
-            record.profiles.push(profile);
+            record.profiles.push(extended);
             record.profiles.sort(sorter);
         }
         else {
             record = {
-                profiles: [profile],
+                profiles: [extended],
                 controller,
             };
             this.controllerProfiles.set(profile.controllerId, record);
@@ -70,6 +77,11 @@ let TestProfileService = class TestProfileService extends Disposable {
         }
         Object.assign(profile, update);
         ctrl.profiles.sort(sorter);
+        if (update.isDefault !== undefined) {
+            const map = deepClone(this.userDefaults.get({}));
+            setIsDefault(map, profile, update.isDefault);
+            this.userDefaults.store(map);
+        }
         this.changeEmitter.fire();
     }
     configure(controllerId, profileId) {
@@ -113,46 +125,44 @@ let TestProfileService = class TestProfileService extends Disposable {
         return this.controllerProfiles.get(profileId)?.profiles ?? [];
     }
     getGroupDefaultProfiles(group) {
-        const preferred = this.preferredDefaults.get();
-        if (!preferred) {
-            return this.getBaseDefaults(group);
+        let defaults = [];
+        for (const { profiles } of ( this.controllerProfiles.values())) {
+            defaults = defaults.concat(profiles.filter(c => c.group === group && c.isDefault));
         }
-        const profiles = preferred[group]
-            ?.map(p => this.controllerProfiles.get(p.controllerId)?.profiles.find(c => c.profileId === p.profileId && c.group === group))
-            .filter(isDefined);
-        return profiles?.length ? profiles : this.getBaseDefaults(group);
-    }
-    setGroupDefaultProfiles(group, profiles) {
-        const next = {
-            ...this.preferredDefaults.get(),
-            [group]: ( profiles.map(c => ({ profileId: c.profileId, controllerId: c.controllerId }))),
-        };
-        if (group === 2  || group === 4 ) {
-            const otherGroup = group === 2  ? 4  : 2 ;
-            const previousDefaults = next[otherGroup] || [];
-            let newDefaults = previousDefaults.slice();
-            for (const [ctrlId, { profiles: ctrlProfiles }] of this.controllerProfiles) {
-                const labels = ( new Set(( profiles.filter(p => p.controllerId === ctrlId).map(p => p.label))));
-                const nextByLabels = ctrlProfiles.filter(p => ( labels.has(p.label)) && p.group === otherGroup);
-                if (nextByLabels.length) {
-                    newDefaults = newDefaults.filter(p => p.controllerId !== ctrlId);
-                    newDefaults.push(...( nextByLabels.map(p => ({ profileId: p.profileId, controllerId: p.controllerId }))));
+        if (defaults.length === 0) {
+            for (const { profiles } of ( this.controllerProfiles.values())) {
+                const first = profiles.find(p => p.group === group);
+                if (first) {
+                    defaults.push(first);
+                    break;
                 }
             }
-            next[otherGroup] = newDefaults;
         }
-        this.preferredDefaults.store(next);
-        this.changeEmitter.fire();
+        return defaults;
     }
-    getBaseDefaults(group) {
-        const defaults = [];
-        for (const { profiles } of ( this.controllerProfiles.values())) {
-            const profile = profiles.find(c => c.group === group);
-            if (profile) {
-                defaults.push(profile);
+    setGroupDefaultProfiles(group, profiles) {
+        const next = {};
+        for (const ctrl of ( this.controllerProfiles.values())) {
+            next[ctrl.controller.id] = {};
+            for (const profile of ctrl.profiles) {
+                if (profile.group !== group) {
+                    continue;
+                }
+                setIsDefault(next, profile, ( profiles.some(p => p.profileId === profile.profileId)));
+            }
+            for (const profile of ctrl.profiles) {
+                if (profile.group === group) {
+                    continue;
+                }
+                const matching = ctrl.profiles.find(p => p.group === group && p.label === profile.label);
+                if (matching) {
+                    setIsDefault(next, profile, matching.isDefault);
+                }
             }
+            ctrl.profiles.sort(sorter);
         }
-        return defaults;
+        this.userDefaults.store(next);
+        this.changeEmitter.fire();
     }
     refreshContextKeys() {
         let allCapabilities = 0;
@@ -171,4 +181,14 @@ TestProfileService = ( __decorate([
     ( __param(0, IContextKeyService)),
     ( __param(1, IStorageService))
 ], TestProfileService));
+const setIsDefault = (map, profile, isDefault) => {
+    profile.isDefault = isDefault;
+    map[profile.controllerId] ??= {};
+    if (profile.isDefault !== profile.wasInitiallyDefault) {
+        map[profile.controllerId][profile.profileId] = profile.isDefault;
+    }
+    else {
+        delete map[profile.controllerId][profile.profileId];
+    }
+};
 export { ITestProfileService, TestProfileService, canUseProfileWithTest, capabilityContextKeys };

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -348,7 +348,7 @@ class HydratedTestResult {
     get tests() {
         return ( this.testById.values());
     }
-    constructor(serialized, persist = true) {
+    constructor(identity, serialized, persist = true) {
         this.serialized = serialized;
         this.persist = persist;
         this.counts = makeEmptyCounts();
@@ -366,7 +366,7 @@ class HydratedTestResult {
         this.name = serialized.name;
         this.request = serialized.request;
         for (const item of serialized.items) {
-            const de = TestResultItem.deserialize(item);
+            const de = TestResultItem.deserialize(identity, item);
             this.counts[de.ownComputedState]++;
             this.testById.set(item.item.extId, de);
         }

package/vscode/src/vs/workbench/contrib/testing/common/testResultStorage.js

@@ -8,6 +8,7 @@ import { IFileService } from '../../../../platform/files/common/files.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
 import { StoredValue } from './storedValue.js';
 import { HydratedTestResult } from './testResult.js';
@@ -18,8 +19,9 @@ const CLEANUP_PROBABILITY = 0.2;
 const ITestResultStorage = ( createDecorator('ITestResultStorage'));
 const currentRevision = 1;
 let BaseTestResultStorage = class BaseTestResultStorage extends Disposable {
-    constructor(storageService, logService) {
+    constructor(uriIdentityService, storageService, logService) {
         super();
+        this.uriIdentityService = uriIdentityService;
         this.storageService = storageService;
         this.logService = logService;
         this.stored = this._register(( new StoredValue({
@@ -38,7 +40,7 @@ let BaseTestResultStorage = class BaseTestResultStorage extends Disposable {
                 if (!contents) {
                     return undefined;
                 }
-                return ( new HydratedTestResult(contents));
+                return ( new HydratedTestResult(this.uriIdentityService, contents));
             }
             catch (e) {
                 this.logService.warn(`Error deserializing stored test result ${id}`, e);
@@ -83,12 +85,13 @@ let BaseTestResultStorage = class BaseTestResultStorage extends Disposable {
     }
 };
 BaseTestResultStorage = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService))
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, ILogService))
 ], BaseTestResultStorage));
 let TestResultStorage = class TestResultStorage extends BaseTestResultStorage {
-    constructor(storageService, logService, workspaceContext, fileService, environmentService) {
-        super(storageService, logService);
+    constructor(uriIdentityService, storageService, logService, workspaceContext, fileService, environmentService) {
+        super(uriIdentityService, storageService, logService);
         this.fileService = fileService;
         this.directory = URI.joinPath(environmentService.workspaceStorageHome, workspaceContext.getWorkspace().id, 'testResults');
     }
@@ -147,10 +150,11 @@ let TestResultStorage = class TestResultStorage extends BaseTestResultStorage {
     }
 };
 TestResultStorage = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IEnvironmentService))
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IEnvironmentService))
 ], TestResultStorage));
 export { BaseTestResultStorage, ITestResultStorage, RETAIN_MAX_RESULTS, TestResultStorage };

package/vscode/src/vs/workbench/contrib/testing/common/testService.js

@@ -74,4 +74,29 @@ const testsInFile = async function* (testService, ident, uri, waitForIdle = true
         }
     }
 };
-export { ITestService, expandAndGetTestById, getContextForTestItem, testCollectionIsEmpty, testsInFile };
+const testsUnderUri = async function* (testService, ident, uri, waitForIdle = true) {
+    const queue = [testService.collection.rootIds];
+    while (queue.length) {
+        for (const testId of queue.pop()) {
+            const test = testService.collection.getNodeById(testId);
+            if (!test) ;
+            else if (!test.item.uri) {
+                queue.push(( test.children.values()));
+                continue;
+            }
+            else if (ident.extUri.isEqualOrParent(uri, test.item.uri)) {
+                if (test.expand === 1 ) {
+                    await testService.collection.expand(test.item.extId, 1);
+                }
+                if (waitForIdle) {
+                    await waitForTestToBeIdle(testService, test);
+                }
+                queue.push(( test.children.values()));
+            }
+            else if (ident.extUri.isEqualOrParent(test.item.uri, uri)) {
+                yield test;
+            }
+        }
+    }
+};
+export { ITestService, expandAndGetTestById, getContextForTestItem, testCollectionIsEmpty, testsInFile, testsUnderUri };