@codingame/monaco-vscode-testing-service-override 26.2.1 → 27.0.0

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

@@ -261,7 +261,7 @@ let TestingPeekOpener = class TestingPeekOpener extends Disposable {
         } else {
             this.commandService.executeCommand("markdown.showPreview", current.messageUri).catch(err => {
                 this.notificationService.error(( localize(
-                    13177,
+                    14027,
                     "Could not open markdown preview: {0}.\n\nPlease make sure the markdown extension is enabled.",
                     err.message
                 )));
@@ -438,7 +438,7 @@ let TestingOutputPeekController = TestingOutputPeekController_1 = class TestingO
         if (!this.peek.get()) {
             const peek = this.instantiationService.createInstance(TestResultsPeek, this.editor);
             this.peek.set(peek, undefined);
-            peek.onDidClose(() => {
+            Event.once(peek.onDidClose)(() => {
                 this.visible.set(false);
                 this.peek.set(undefined, undefined);
             });
@@ -756,7 +756,7 @@ let TestResultsPeek = class TestResultsPeek extends PeekViewWidget {
                 stripIcons(subject.test.label)
             );
         } else {
-            this.setTitle(( localize(13178, "Test Output")));
+            this.setTitle(( localize(14028, "Test Output")));
         }
         this.applyTheme();
         await this.content.reveal({
@@ -873,7 +873,7 @@ class CloseTestPeek extends EditorAction2 {
     constructor() {
         super({
             id: "editor.closeTestPeek",
-            title: ( localize2(13179, "Close")),
+            title: ( localize2(14029, "Close")),
             icon: Codicon.close,
             precondition: ( ContextKeyExpr.or(TestingContextKeys.isInPeek, TestingContextKeys.isPeekVisible)),
             keybinding: {
@@ -914,9 +914,9 @@ class GoToNextMessageAction extends Action2 {
         super({
             id: GoToNextMessageAction.ID,
             f1: true,
-            title: ( localize2(13180, "Go to Next Test Failure")),
+            title: ( localize2(14030, "Go to Next Test Failure")),
             metadata: {
-                description: ( localize2(13181, "Shows the next failure message in your file"))
+                description: ( localize2(14031, "Shows the next failure message in your file"))
             },
             icon: Codicon.arrowDown,
             category: Categories.Test,
@@ -950,9 +950,9 @@ class GoToPreviousMessageAction extends Action2 {
         super({
             id: GoToPreviousMessageAction.ID,
             f1: true,
-            title: ( localize2(13182, "Go to Previous Test Failure")),
+            title: ( localize2(14032, "Go to Previous Test Failure")),
             metadata: {
-                description: ( localize2(13183, "Shows the previous failure message in your file"))
+                description: ( localize2(14033, "Shows the previous failure message in your file"))
             },
             icon: Codicon.arrowUp,
             category: Categories.Test,
@@ -985,7 +985,7 @@ class CollapsePeekStack extends Action2 {
     constructor() {
         super({
             id: CollapsePeekStack.ID,
-            title: ( localize2(13184, "Collapse Stack Frames")),
+            title: ( localize2(14034, "Collapse Stack Frames")),
             icon: Codicon.collapseAll,
             category: Categories.Test,
             menu: [{
@@ -1011,7 +1011,7 @@ class OpenMessageInEditorAction extends Action2 {
         super({
             id: OpenMessageInEditorAction.ID,
             f1: false,
-            title: ( localize2(13185, "Open in Editor")),
+            title: ( localize2(14035, "Open in Editor")),
             icon: Codicon.goToFile,
             category: Categories.Test,
             menu: [{
@@ -1031,9 +1031,9 @@ class ToggleTestingPeekHistory extends Action2 {
         super({
             id: ToggleTestingPeekHistory.ID,
             f1: true,
-            title: ( localize2(13186, "Toggle Test History in Peek")),
+            title: ( localize2(14036, "Toggle Test History in Peek")),
             metadata: {
-                description: ( localize2(13187, "Shows or hides the history of test runs in the peek view"))
+                description: ( localize2(14037, "Shows or hides the history of test runs in the peek view"))
             },
             icon: Codicon.history,
             category: Categories.Test,

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

@@ -41,7 +41,7 @@ let TestingViewPaneContainer = class TestingViewPaneContainer extends ViewPaneCo
         return 400;
     }
     getTitle() {
-        return localize(13188, "Testing");
+        return localize(14038, "Testing");
     }
 };
 TestingViewPaneContainer = ( __decorate([( __param(0, IWorkbenchLayoutService)), ( __param(1, ITelemetryService)), ( __param(2, IInstantiationService)), ( __param(3, IContextMenuService)), ( __param(4, IThemeService)), ( __param(5, IStorageService)), ( __param(6, IConfigurationService)), ( __param(7, IExtensionService)), ( __param(8, IWorkspaceContextService)), ( __param(9, IViewDescriptorService)), ( __param(10, ILogService))], TestingViewPaneContainer));

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

@@ -19,36 +19,36 @@ const testingColorIconFailed = registerColor("testing.iconFailed", {
     light: "#f14c4c",
     hcDark: "#f14c4c",
     hcLight: "#B5200D"
-}, ( localize(13189, "Color for the 'failed' icon in the test explorer.")));
+}, ( localize(14039, "Color for the 'failed' icon in the test explorer.")));
 const testingColorIconErrored = registerColor("testing.iconErrored", {
     dark: "#f14c4c",
     light: "#f14c4c",
     hcDark: "#f14c4c",
     hcLight: "#B5200D"
-}, ( localize(13190, "Color for the 'Errored' icon in the test explorer.")));
+}, ( localize(14040, "Color for the 'Errored' icon in the test explorer.")));
 const testingColorIconPassed = registerColor("testing.iconPassed", {
     dark: "#73c991",
     light: "#73c991",
     hcDark: "#73c991",
     hcLight: "#007100"
-}, ( localize(13191, "Color for the 'passed' icon in the test explorer.")));
-const testingColorRunAction = registerColor("testing.runAction", testingColorIconPassed, ( localize(13192, "Color for 'run' icons in the editor.")));
-const testingColorIconQueued = registerColor("testing.iconQueued", "#cca700", ( localize(13193, "Color for the 'Queued' icon in the test explorer.")));
-const testingColorIconUnset = registerColor("testing.iconUnset", "#848484", ( localize(13194, "Color for the 'Unset' icon in the test explorer.")));
-const testingColorIconSkipped = registerColor("testing.iconSkipped", "#848484", ( localize(13195, "Color for the 'Skipped' icon in the test explorer.")));
+}, ( localize(14041, "Color for the 'passed' icon in the test explorer.")));
+const testingColorRunAction = registerColor("testing.runAction", testingColorIconPassed, ( localize(14042, "Color for 'run' icons in the editor.")));
+const testingColorIconQueued = registerColor("testing.iconQueued", "#cca700", ( localize(14043, "Color for the 'Queued' icon in the test explorer.")));
+const testingColorIconUnset = registerColor("testing.iconUnset", "#848484", ( localize(14044, "Color for the 'Unset' icon in the test explorer.")));
+const testingColorIconSkipped = registerColor("testing.iconSkipped", "#848484", ( localize(14045, "Color for the 'Skipped' icon in the test explorer.")));
 const testingPeekBorder = registerColor("testing.peekBorder", {
     dark: editorErrorForeground,
     light: editorErrorForeground,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(13196, "Color of the peek view borders and arrow.")));
+}, ( localize(14046, "Color of the peek view borders and arrow.")));
 const testingMessagePeekBorder = registerColor("testing.messagePeekBorder", {
     dark: editorInfoForeground,
     light: editorInfoForeground,
     hcDark: contrastBorder,
     hcLight: contrastBorder
 }, ( localize(
-    13197,
+    14047,
     "Color of the peek view borders and arrow when peeking a logged message."
 )));
 const testingPeekHeaderBackground = registerColor("testing.peekHeaderBackground", {
@@ -56,14 +56,14 @@ const testingPeekHeaderBackground = registerColor("testing.peekHeaderBackground"
     light: ( transparent(editorErrorForeground, 0.1)),
     hcDark: null,
     hcLight: null
-}, ( localize(13196, "Color of the peek view borders and arrow.")));
+}, ( localize(14046, "Color of the peek view borders and arrow.")));
 const testingPeekMessageHeaderBackground = registerColor("testing.messagePeekHeaderBackground", {
     dark: ( transparent(editorInfoForeground, 0.1)),
     light: ( transparent(editorInfoForeground, 0.1)),
     hcDark: null,
     hcLight: null
 }, ( localize(
-    13198,
+    14048,
     "Color of the peek view borders and arrow when peeking a logged message."
 )));
 const testingCoveredBackground = registerColor("testing.coveredBackground", {
@@ -71,66 +71,66 @@ const testingCoveredBackground = registerColor("testing.coveredBackground", {
     light: diffInserted,
     hcDark: null,
     hcLight: null
-}, ( localize(13199, "Background color of text that was covered.")));
+}, ( localize(14049, "Background color of text that was covered.")));
 const testingCoveredBorder = registerColor("testing.coveredBorder", {
     dark: ( transparent(testingCoveredBackground, 0.75)),
     light: ( transparent(testingCoveredBackground, 0.75)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(13200, "Border color of text that was covered.")));
+}, ( localize(14050, "Border color of text that was covered.")));
 registerColor("testing.coveredGutterBackground", {
     dark: ( transparent(diffInserted, 0.6)),
     light: ( transparent(diffInserted, 0.6)),
     hcDark: chartsGreen,
     hcLight: chartsGreen
-}, ( localize(13201, "Gutter color of regions where code was covered.")));
+}, ( localize(14051, "Gutter color of regions where code was covered.")));
 registerColor("testing.uncoveredBranchBackground", {
     dark: opaque(( transparent(diffRemoved, 2)), editorBackground),
     light: opaque(( transparent(diffRemoved, 2)), editorBackground),
     hcDark: null,
     hcLight: null
-}, ( localize(13202, "Background of the widget shown for an uncovered branch.")));
+}, ( localize(14052, "Background of the widget shown for an uncovered branch.")));
 const testingUncoveredBackground = registerColor("testing.uncoveredBackground", {
     dark: diffRemoved,
     light: diffRemoved,
     hcDark: null,
     hcLight: null
-}, ( localize(13203, "Background color of text that was not covered.")));
+}, ( localize(14053, "Background color of text that was not covered.")));
 const testingUncoveredBorder = registerColor("testing.uncoveredBorder", {
     dark: ( transparent(testingUncoveredBackground, 0.75)),
     light: ( transparent(testingUncoveredBackground, 0.75)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(13204, "Border color of text that was not covered.")));
+}, ( localize(14054, "Border color of text that was not covered.")));
 registerColor("testing.uncoveredGutterBackground", {
     dark: ( transparent(diffRemoved, 1.5)),
     light: ( transparent(diffRemoved, 1.5)),
     hcDark: chartsRed,
     hcLight: chartsRed
-}, ( localize(13205, "Gutter color of regions where code not covered.")));
-registerColor("testing.coverCountBadgeBackground", badgeBackground, ( localize(13206, "Background for the badge indicating execution count")));
-registerColor("testing.coverCountBadgeForeground", badgeForeground, ( localize(13207, "Foreground for the badge indicating execution count")));
+}, ( localize(14055, "Gutter color of regions where code not covered.")));
+registerColor("testing.coverCountBadgeBackground", badgeBackground, ( localize(14056, "Background for the badge indicating execution count")));
+registerColor("testing.coverCountBadgeForeground", badgeForeground, ( localize(14057, "Foreground for the badge indicating execution count")));
 const messageBadgeBackground = registerColor(
     "testing.message.error.badgeBackground",
     activityErrorBadgeBackground,
     ( localize(
-    13208,
+    14058,
     "Background color of test error messages shown inline in the editor."
 ))
 );
 registerColor(
     "testing.message.error.badgeBorder",
     messageBadgeBackground,
-    ( localize(13209, "Border color of test error messages shown inline in the editor."))
+    ( localize(14059, "Border color of test error messages shown inline in the editor."))
 );
 registerColor(
     "testing.message.error.badgeForeground",
     activityErrorBadgeForeground,
-    ( localize(13210, "Text color of test error messages shown inline in the editor."))
+    ( localize(14060, "Text color of test error messages shown inline in the editor."))
 );
-registerColor("testing.message.error.lineBackground", null, ( localize(13211, "Margin color beside error messages shown inline in the editor.")));
-registerColor("testing.message.info.decorationForeground", ( transparent(editorForeground, 0.5)), ( localize(13212, "Text color of test info messages shown inline in the editor.")));
-registerColor("testing.message.info.lineBackground", null, ( localize(13213, "Margin color beside info messages shown inline in the editor.")));
+registerColor("testing.message.error.lineBackground", null, ( localize(14061, "Margin color beside error messages shown inline in the editor.")));
+registerColor("testing.message.info.decorationForeground", ( transparent(editorForeground, 0.5)), ( localize(14062, "Text color of test info messages shown inline in the editor.")));
+registerColor("testing.message.info.lineBackground", null, ( localize(14063, "Margin color beside info messages shown inline in the editor.")));
 const testStatesToIconColors = {
     [TestResultState.Errored]: testingColorIconErrored,
     [TestResultState.Failed]: testingColorIconFailed,
@@ -139,12 +139,12 @@ const testStatesToIconColors = {
     [TestResultState.Unset]: testingColorIconUnset,
     [TestResultState.Skipped]: testingColorIconSkipped
 };
-const testingRetiredColorIconErrored = registerColor("testing.iconErrored.retired", ( transparent(testingColorIconErrored, 0.7)), ( localize(13214, "Retired color for the 'Errored' icon in the test explorer.")));
-const testingRetiredColorIconFailed = registerColor("testing.iconFailed.retired", ( transparent(testingColorIconFailed, 0.7)), ( localize(13215, "Retired color for the 'failed' icon in the test explorer.")));
-const testingRetiredColorIconPassed = registerColor("testing.iconPassed.retired", ( transparent(testingColorIconPassed, 0.7)), ( localize(13216, "Retired color for the 'passed' icon in the test explorer.")));
-const testingRetiredColorIconQueued = registerColor("testing.iconQueued.retired", ( transparent(testingColorIconQueued, 0.7)), ( localize(13217, "Retired color for the 'Queued' icon in the test explorer.")));
-const testingRetiredColorIconUnset = registerColor("testing.iconUnset.retired", ( transparent(testingColorIconUnset, 0.7)), ( localize(13218, "Retired color for the 'Unset' icon in the test explorer.")));
-const testingRetiredColorIconSkipped = registerColor("testing.iconSkipped.retired", ( transparent(testingColorIconSkipped, 0.7)), ( localize(13219, "Retired color for the 'Skipped' icon in the test explorer.")));
+const testingRetiredColorIconErrored = registerColor("testing.iconErrored.retired", ( transparent(testingColorIconErrored, 0.7)), ( localize(14064, "Retired color for the 'Errored' icon in the test explorer.")));
+const testingRetiredColorIconFailed = registerColor("testing.iconFailed.retired", ( transparent(testingColorIconFailed, 0.7)), ( localize(14065, "Retired color for the 'failed' icon in the test explorer.")));
+const testingRetiredColorIconPassed = registerColor("testing.iconPassed.retired", ( transparent(testingColorIconPassed, 0.7)), ( localize(14066, "Retired color for the 'passed' icon in the test explorer.")));
+const testingRetiredColorIconQueued = registerColor("testing.iconQueued.retired", ( transparent(testingColorIconQueued, 0.7)), ( localize(14067, "Retired color for the 'Queued' icon in the test explorer.")));
+const testingRetiredColorIconUnset = registerColor("testing.iconUnset.retired", ( transparent(testingColorIconUnset, 0.7)), ( localize(14068, "Retired color for the 'Unset' icon in the test explorer.")));
+const testingRetiredColorIconSkipped = registerColor("testing.iconSkipped.retired", ( transparent(testingColorIconSkipped, 0.7)), ( localize(14069, "Retired color for the 'Skipped' icon in the test explorer.")));
 const testStatesToRetiredIconColors = {
     [TestResultState.Errored]: testingRetiredColorIconErrored,
     [TestResultState.Failed]: testingRetiredColorIconFailed,

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

@@ -64,46 +64,46 @@ var TestingResultsViewLayout;
 const testingConfiguration = {
     id: "testing",
     order: 21,
-    title: ( localize(13220, "Testing")),
+    title: ( localize(14070, "Testing")),
     type: "object",
     properties: {
         [TestingConfigKeys.AutoOpenPeekView]: {
-            description: ( localize(13221, "Configures when the error Peek view is automatically opened.")),
+            description: ( localize(14071, "Configures when the error Peek view is automatically opened.")),
             enum: [
                 AutoOpenPeekViewWhen.FailureAnywhere,
                 AutoOpenPeekViewWhen.FailureVisible,
                 AutoOpenPeekViewWhen.Never
             ],
             default: AutoOpenPeekViewWhen.Never,
-            enumDescriptions: [( localize(13222, "Open automatically no matter where the failure is.")), ( localize(13223, "Open automatically when a test fails in a visible document.")), ( localize(13224, "Never automatically open."))]
+            enumDescriptions: [( localize(14072, "Open automatically no matter where the failure is.")), ( localize(14073, "Open automatically when a test fails in a visible document.")), ( localize(14074, "Never automatically open."))]
         },
         [TestingConfigKeys.ShowAllMessages]: {
-            description: ( localize(13225, "Controls whether to show messages from all test runs.")),
+            description: ( localize(14075, "Controls whether to show messages from all test runs.")),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.AutoOpenPeekViewDuringContinuousRun]: {
             description: ( localize(
-                13226,
+                14076,
                 "Controls whether to automatically open the Peek view during continuous run mode."
             )),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.CountBadge]: {
-            description: ( localize(13227, "Controls the count badge on the Testing icon on the Activity Bar.")),
+            description: ( localize(14077, "Controls the count badge on the Testing icon on the Activity Bar.")),
             enum: [
                 TestingCountBadge.Failed,
                 TestingCountBadge.Off,
                 TestingCountBadge.Passed,
                 TestingCountBadge.Skipped
             ],
-            enumDescriptions: [( localize(13228, "Show the number of failed tests")), ( localize(13229, "Disable the testing count badge")), ( localize(13230, "Show the number of passed tests")), ( localize(13231, "Show the number of skipped tests"))],
+            enumDescriptions: [( localize(14078, "Show the number of failed tests")), ( localize(14079, "Disable the testing count badge")), ( localize(14080, "Show the number of passed tests")), ( localize(14081, "Show the number of skipped tests"))],
             default: TestingCountBadge.Failed
         },
         [TestingConfigKeys.FollowRunningTest]: {
             description: ( localize(
-                13232,
+                14082,
                 "Controls whether the running test should be followed in the Test Explorer view."
             )),
             type: "boolean",
@@ -111,7 +111,7 @@ const testingConfiguration = {
         },
         [TestingConfigKeys.DefaultGutterClickAction]: {
             description: ( localize(
-                13233,
+                14083,
                 "Controls the action to take when left-clicking on a test decoration in the gutter."
             )),
             enum: [
@@ -120,16 +120,16 @@ const testingConfiguration = {
                 DefaultGutterClickAction.Coverage,
                 DefaultGutterClickAction.ContextMenu
             ],
-            enumDescriptions: [( localize(13234, "Run the test.")), ( localize(13235, "Debug the test.")), ( localize(13236, "Run the test with coverage.")), ( localize(13237, "Open the context menu for more options."))],
+            enumDescriptions: [( localize(14084, "Run the test.")), ( localize(14085, "Debug the test.")), ( localize(14086, "Run the test with coverage.")), ( localize(14087, "Open the context menu for more options."))],
             default: DefaultGutterClickAction.Run
         },
         [TestingConfigKeys.GutterEnabled]: {
-            description: ( localize(13238, "Controls whether test decorations are shown in the editor gutter.")),
+            description: ( localize(14088, "Controls whether test decorations are shown in the editor gutter.")),
             type: "boolean",
             default: true
         },
         [TestingConfigKeys.SaveBeforeTest]: {
-            description: ( localize(13239, "Control whether save all dirty editors before running a test.")),
+            description: ( localize(14089, "Control whether save all dirty editors before running a test.")),
             type: "boolean",
             default: true
         },
@@ -140,13 +140,13 @@ const testingConfiguration = {
                 AutoOpenTesting.OpenOnTestFailure,
                 AutoOpenTesting.OpenExplorerOnTestStart
             ],
-            enumDescriptions: [( localize(13240, "Never automatically open the testing views")), ( localize(13241, "Open the test results view when tests start")), ( localize(13242, "Open the test result view on any test failure")), ( localize(13243, "Open the test explorer when tests start"))],
+            enumDescriptions: [( localize(14090, "Never automatically open the testing views")), ( localize(14091, "Open the test results view when tests start")), ( localize(14092, "Open the test result view on any test failure")), ( localize(14093, "Open the test explorer when tests start"))],
             default: "openOnTestStart",
-            description: ( localize(13244, "Controls when the testing view should open."))
+            description: ( localize(14094, "Controls when the testing view should open."))
         },
         [TestingConfigKeys.AlwaysRevealTestOnStateChange]: {
             markdownDescription: ( localize(
-                13245,
+                14095,
                 "Always reveal the executed test when {0} is on. If this setting is turned off, only failed tests will be revealed.",
                 "`#testing.followRunningTest#`"
             )),
@@ -154,13 +154,13 @@ const testingConfiguration = {
             default: false
         },
         [TestingConfigKeys.ShowCoverageInExplorer]: {
-            description: ( localize(13246, "Whether test coverage should be down in the File Explorer view.")),
+            description: ( localize(14096, "Whether test coverage should be down in the File Explorer view.")),
             type: "boolean",
             default: true
         },
         [TestingConfigKeys.CoveragePercent]: {
             markdownDescription: ( localize(
-                13247,
+                14097,
                 "Configures what percentage is displayed by default for test coverage."
             )),
             default: TestingDisplayedCoveragePercent.TotalCoverage,
@@ -170,12 +170,12 @@ const testingConfiguration = {
                 TestingDisplayedCoveragePercent.Minimum
             ],
             enumDescriptions: [( localize(
-                13248,
+                14098,
                 "A calculation of the combined statement, function, and branch coverage."
-            )), ( localize(13249, "The statement coverage.")), ( localize(13250, "The minimum of statement, function, and branch coverage."))]
+            )), ( localize(14099, "The statement coverage.")), ( localize(14100, "The minimum of statement, function, and branch coverage."))]
         },
         [TestingConfigKeys.CoverageBarThresholds]: {
-            markdownDescription: ( localize(13251, "Configures the colors used for percentages in test coverage bars.")),
+            markdownDescription: ( localize(14101, "Configures the colors used for percentages in test coverage bars.")),
             default: {
                 red: 0,
                 yellow: 60,
@@ -203,18 +203,18 @@ const testingConfiguration = {
             }
         },
         [TestingConfigKeys.CoverageToolbarEnabled]: {
-            description: ( localize(13252, "Controls whether the coverage toolbar is shown in the editor.")),
+            description: ( localize(14102, "Controls whether the coverage toolbar is shown in the editor.")),
             type: "boolean",
             default: false
         },
         [TestingConfigKeys.ResultsViewLayout]: {
-            description: ( localize(13253, "Controls the layout of the Test Results view.")),
+            description: ( localize(14103, "Controls the layout of the Test Results view.")),
             enum: [TestingResultsViewLayout.TreeRight, TestingResultsViewLayout.TreeLeft],
             enumDescriptions: [( localize(
-                13254,
+                14104,
                 "Show the test run tree on the right side with details on the left."
             )), ( localize(
-                13255,
+                14105,
                 "Show the test run tree on the left side with details on the right."
             ))],
             default: TestingResultsViewLayout.TreeRight

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

@@ -16,7 +16,7 @@ const trimExtraWhitespace = str => str.replace(/\s\s+/g, " ").trim();
 let TestExplorerFilterState = class TestExplorerFilterState extends Disposable {
     constructor(storageService) {
         super();
-        this.focusEmitter = ( new Emitter());
+        this.focusEmitter = this._register(( new Emitter()));
         this.termFilterState = {};
         this.globList = [];
         this.includeTags = ( new Set());

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

@@ -38,7 +38,7 @@ let TestResultService = class TestResultService extends Disposable {
                 this.push(loaded[i]);
             }
         }));
-        this.persistScheduler = ( new RunOnceScheduler(() => this.persistImmediately(), 500));
+        this.persistScheduler = this._register(( new RunOnceScheduler(() => this.persistImmediately(), 500)));
         this._register(toDisposable(() => dispose(this._resultsDisposables)));
         this.isRunning = TestingContextKeys.isRunning.bindTo(contextKeyService);
         this.hasAnyResults = TestingContextKeys.hasAnyResults.bindTo(contextKeyService);

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

@@ -53,9 +53,9 @@ let TestService = class TestService extends Disposable {
         this.workspaceTrustRequestService = workspaceTrustRequestService;
         this.testControllers = observableValue("testControllers", ( new Map()));
         this.testExtHosts = ( new Set());
-        this.cancelExtensionTestRunEmitter = ( new Emitter());
-        this.willProcessDiffEmitter = ( new Emitter());
-        this.didProcessDiffEmitter = ( new Emitter());
+        this.cancelExtensionTestRunEmitter = this._register(( new Emitter()));
+        this.willProcessDiffEmitter = this._register(( new Emitter()));
+        this.didProcessDiffEmitter = this._register(( new Emitter()));
         this.testRefreshCancellations = ( new Set());
         this.uiRunningTests = ( new Map());
         this.onWillProcessDiff = this.willProcessDiffEmitter.event;
@@ -164,7 +164,7 @@ let TestService = class TestService extends Disposable {
             req.exclude = [...this.excluded.all];
         }
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(13269, "Running tests may execute code in your workspace."))
+            message: ( localize(14119, "Running tests may execute code in your workspace."))
         });
         if (!trust) {
             return;
@@ -179,7 +179,7 @@ let TestService = class TestService extends Disposable {
             }))), token).then(result => {
                 const errs = ( result.map(r => r.error)).filter(isDefined);
                 if (errs.length) {
-                    this.notificationService.error(( localize(13270, "An error occurred attempting to run tests: {0}", errs.join(" "))));
+                    this.notificationService.error(( localize(14120, "An error occurred attempting to run tests: {0}", errs.join(" "))));
                 }
             })
         ));
@@ -191,7 +191,7 @@ let TestService = class TestService extends Disposable {
         }
         const result = this.testResults.createLiveResult(req);
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( localize(13269, "Running tests may execute code in your workspace."))
+            message: ( localize(14119, "Running tests may execute code in your workspace."))
         });
         if (!trust) {
             result.markComplete();
@@ -211,7 +211,7 @@ let TestService = class TestService extends Disposable {
                 }))), cancelSource.token).then(result => {
                     const errs = ( result.map(r => r.error)).filter(isDefined);
                     if (errs.length) {
-                        this.notificationService.error(( localize(13270, "An error occurred attempting to run tests: {0}", errs.join(" "))));
+                        this.notificationService.error(( localize(14120, "An error occurred attempting to run tests: {0}", errs.join(" "))));
                     }
                 })
             ));

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

@@ -84,7 +84,7 @@ let RunTestTool = class RunTestTool {
                     }
                 }
             },
-            userDescription: ( localize(13274, "Run unit tests (optionally with coverage)")),
+            userDescription: ( localize(14124, "Run unit tests (optionally with coverage)")),
             source: ToolDataSource.Internal,
             tags: [
                 "vscode_editing_with_tests",
@@ -123,11 +123,11 @@ let RunTestTool = class RunTestTool {
                     kind: "text",
                     value: "No tests found in the files. Ensure the correct absolute paths are passed to the tool."
                 }],
-                toolResultError: ( localize(13275, "No tests found in the files"))
+                toolResultError: ( localize(14125, "No tests found in the files"))
             };
         }
         progress.report({
-            message: ( localize(13276, "Starting test run..."))
+            message: ( localize(14126, "Starting test run..."))
         });
         if (group === TestRunProfileBitset.Coverage) {
             if (!( testCases.some(
@@ -144,7 +144,7 @@ let RunTestTool = class RunTestTool {
                     value: "No test run was started. Instruct the user to ensure their test runner is correctly configured"
                 }],
                 toolResultError: ( localize(
-                    13277,
+                    14127,
                     "No test run was started. This may be an issue with your test runner or extension."
                 ))
             };
@@ -155,9 +155,9 @@ let RunTestTool = class RunTestTool {
             return {
                 content: [{
                     kind: "text",
-                    value: ( localize(13278, "Test run was cancelled."))
+                    value: ( localize(14128, "Test run was cancelled."))
                 }],
-                toolResultMessage: ( localize(13278, "Test run was cancelled."))
+                toolResultMessage: ( localize(14128, "Test run was cancelled."))
             };
         }
         const summary = await this._buildSummary(result, mode, coverageFiles);
@@ -339,7 +339,7 @@ let RunTestTool = class RunTestTool {
             return tests;
         }
         progress.report({
-            message: ( localize(13279, "Filtering tests..."))
+            message: ( localize(14129, "Filtering tests..."))
         });
         const testNames = ( params.testNames.map(t => t.toLowerCase().trim()));
         const filtered = [];
@@ -368,7 +368,7 @@ let RunTestTool = class RunTestTool {
             return [...this._testService.collection.rootItems];
         }
         progress.report({
-            message: ( localize(13280, "Discovering tests..."))
+            message: ( localize(14130, "Discovering tests..."))
         });
         const firstWorkspaceFolder = this._workspaceContextService.getWorkspace().folders.at(0)?.uri;
         const uris = ( params.files.map(f => {
@@ -392,13 +392,13 @@ let RunTestTool = class RunTestTool {
     }
     prepareToolInvocation(context, token) {
         const params = context.parameters;
-        const title = ( localize(13281, "Allow test run?"));
+        const title = ( localize(14131, "Allow test run?"));
         const inFiles = params.files?.map(f => "`" + basename(f) + "`");
         return Promise.resolve({
-            invocationMessage: ( localize(13282, "Running tests...")),
+            invocationMessage: ( localize(14132, "Running tests...")),
             confirmationMessages: {
                 title,
-                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(13283, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(13284, "The model wants to run all tests.")),
+                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(14133, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(14134, "The model wants to run all tests.")),
                 allowAutoConfirm: true
             }
         });

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

@@ -59,11 +59,11 @@ let TestingContentProvider = class TestingContentProvider {
                     return;
                 }
                 if (!hadContent) {
-                    append(( localize(13285, "The test run did not record any output.")));
+                    append(( localize(14135, "The test run did not record any output.")));
                     dispose.dispose();
                 }
             });
-            model.onWillDispose(() => dispose.dispose());
+            dispose.add(model.onWillDispose(() => dispose.dispose()));
             return model;
         }
         const test = result?.getStateById(parsed.testExtId);