@codingame/monaco-vscode-testing-service-override 28.4.1 → 29.1.0

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

@@ -23,7 +23,7 @@ import { isFailedState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/
 import { ITestResultService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testResultService.service';
 import { waitForTestToBeIdle, testsInFile } from './testService.js';
 import { ITestService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testService.service';
-import { TestRunProfileBitset, TestResultState, TestMessageType, TestItemExpandState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testTypes';
+import { TestRunProfileBitset, TestItemExpandState, TestResultState, DetailType, TestMessageType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
 import { ITestProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/testing/common/testProfileService.service';
 
@@ -80,11 +80,11 @@ let RunTestTool = class RunTestTool {
                         items: {
                             type: "string"
                         },
-                        description: "When mode=\"coverage\": absolute file paths to include detailed coverage info for. Only the first matching file will be summarized."
+                        description: "When mode=\"coverage\": absolute file paths to include detailed coverage info for. If not provided, a file-level summary of all files with incomplete coverage is shown."
                     }
                 }
             },
-            userDescription: ( localize(14321, "Run unit tests (optionally with coverage)")),
+            userDescription: ( localize(14583, "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(14322, "No tests found in the files"))
+                toolResultError: ( localize(14584, "No tests found in the files"))
             };
         }
         progress.report({
-            message: ( localize(14323, "Starting test run..."))
+            message: ( localize(14585, "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(
-                    14324,
+                    14586,
                     "No test run was started. This may be an issue with your test runner or extension."
                 ))
             };
@@ -155,12 +155,12 @@ let RunTestTool = class RunTestTool {
             return {
                 content: [{
                     kind: "text",
-                    value: ( localize(14325, "Test run was cancelled."))
+                    value: ( localize(14587, "Test run was cancelled."))
                 }],
-                toolResultMessage: ( localize(14325, "Test run was cancelled."))
+                toolResultMessage: ( localize(14587, "Test run was cancelled."))
             };
         }
-        const summary = await this._buildSummary(result, mode, coverageFiles);
+        const summary = await buildTestRunSummary(result, mode, coverageFiles);
         const content = [{
             kind: "text",
             value: summary
@@ -170,117 +170,6 @@ let RunTestTool = class RunTestTool {
             toolResultMessage: getTestProgressText(collectTestStateCounts(false, [result]))
         };
     }
-    async _buildSummary(result, mode, coverageFiles) {
-        const failures = result.counts[TestResultState.Errored] + result.counts[TestResultState.Failed];
-        let str = `<summary passed=${result.counts[TestResultState.Passed]} failed=${failures} />\n`;
-        if (failures !== 0) {
-            str += await this._getFailureDetails(result);
-        }
-        if (mode === "coverage") {
-            str += await this._getCoverageSummary(result, coverageFiles);
-        }
-        return str;
-    }
-    async _getCoverageSummary(result, coverageFiles) {
-        if (!coverageFiles || !coverageFiles.length) {
-            return "";
-        }
-        for (const task of result.tasks) {
-            const coverage = task.coverage.get();
-            if (!coverage) {
-                continue;
-            }
-            const normalized = ( coverageFiles.map(file => URI.file(file).fsPath));
-            const coveredFilesMap = ( new Map());
-            for (const file of ( coverage.getAllFiles().values())) {
-                coveredFilesMap.set(file.uri.fsPath, file);
-            }
-            for (const path of normalized) {
-                const file = coveredFilesMap.get(path);
-                if (!file) {
-                    continue;
-                }
-                let summary = `<coverage task=${JSON.stringify(task.name || "")}>\n`;
-                const pct = getTotalCoveragePercent(file.statement, file.branch, file.declaration) * 100;
-                summary += `<firstUncoveredFile path=${JSON.stringify(path)} statementsCovered=${file.statement.covered} statementsTotal=${file.statement.total}`;
-                if (file.branch) {
-                    summary += ` branchesCovered=${file.branch.covered} branchesTotal=${file.branch.total}`;
-                }
-                if (file.declaration) {
-                    summary += ` declarationsCovered=${file.declaration.covered} declarationsTotal=${file.declaration.total}`;
-                }
-                summary += ` percent=${pct.toFixed(2)}`;
-                try {
-                    const details = await file.details();
-                    for (const detail of details) {
-                        if (detail.count || !detail.location) {
-                            continue;
-                        }
-                        let startLine;
-                        let endLine;
-                        if (Position.isIPosition(detail.location)) {
-                            startLine = endLine = detail.location.lineNumber;
-                        } else {
-                            startLine = detail.location.startLineNumber;
-                            endLine = detail.location.endLineNumber;
-                        }
-                        summary += ` firstUncoveredStart=${startLine} firstUncoveredEnd=${endLine}`;
-                        break;
-                    }
-                } catch {}
-                summary += ` />\n`;
-                summary += `</coverage>\n`;
-                return summary;
-            }
-        }
-        return "";
-    }
-    async _getFailureDetails(result) {
-        let str = "";
-        let hadMessages = false;
-        for (const failure of result.tests) {
-            if (!isFailedState(failure.ownComputedState)) {
-                continue;
-            }
-            const [, ...testPath] = TestId.split(failure.item.extId);
-            const testName = testPath.pop();
-            str += `<testFailure name=${JSON.stringify(testName)} path=${JSON.stringify(testPath.join(" > "))}>\n`;
-            for (const task of failure.tasks) {
-                for (const message of task.messages.filter(m => m.type === TestMessageType.Error)) {
-                    hadMessages = true;
-                    if (message.expected !== undefined && message.actual !== undefined) {
-                        str += `<expectedOutput>\n${message.expected}\n</expectedOutput>\n`;
-                        str += `<actualOutput>\n${message.actual}\n</actualOutput>\n`;
-                    } else {
-                        const messageText = typeof message.message === "string" ? message.message : message.message.value;
-                        str += `<message>\n${messageText}\n</message>\n`;
-                    }
-                    if (message.stackTrace && message.stackTrace.length > 0) {
-                        for (const frame of message.stackTrace.slice(0, 10)) {
-                            if (frame.uri && frame.position) {
-                                str += `<stackFrame path="${frame.uri.fsPath}" line="${frame.position.lineNumber}" col="${frame.position.column}" />\n`;
-                            } else if (frame.uri) {
-                                str += `<stackFrame path="${frame.uri.fsPath}">${frame.label}</stackFrame>\n`;
-                            } else {
-                                str += `<stackFrame>${frame.label}</stackFrame>\n`;
-                            }
-                        }
-                    }
-                    if (message.location) {
-                        str += `<location path="${message.location.uri.fsPath}" line="${message.location.range.startLineNumber}" col="${message.location.range.startColumn}" />\n`;
-                    }
-                }
-            }
-            str += `</testFailure>\n`;
-        }
-        if (!hadMessages) {
-            const output = ( result.tasks.map(t => ( t.output.getRange(0, t.output.length).toString()).trim())).join("\n");
-            if (output) {
-                str += `<output>\n${output}\n</output>\n`;
-            }
-        }
-        return str;
-    }
     async _monitorRunProgress(result, progress, token) {
         const store = ( new DisposableStore());
         const update = () => {
@@ -339,7 +228,7 @@ let RunTestTool = class RunTestTool {
             return tests;
         }
         progress.report({
-            message: ( localize(14326, "Filtering tests..."))
+            message: ( localize(14588, "Filtering tests..."))
         });
         const testNames = ( params.testNames.map(t => t.toLowerCase().trim()));
         const filtered = [];
@@ -368,7 +257,7 @@ let RunTestTool = class RunTestTool {
             return [...this._testService.collection.rootItems];
         }
         progress.report({
-            message: ( localize(14327, "Discovering tests..."))
+            message: ( localize(14589, "Discovering tests..."))
         });
         const firstWorkspaceFolder = this._workspaceContextService.getWorkspace().folders.at(0)?.uri;
         const uris = ( params.files.map(f => {
@@ -392,18 +281,194 @@ let RunTestTool = class RunTestTool {
     }
     prepareToolInvocation(context, token) {
         const params = context.parameters;
-        const title = ( localize(14328, "Allow test run?"));
+        const title = ( localize(14590, "Allow test run?"));
         const inFiles = params.files?.map(f => "`" + basename(f) + "`");
         return Promise.resolve({
-            invocationMessage: ( localize(14329, "Running tests...")),
+            invocationMessage: ( localize(14591, "Running tests...")),
             confirmationMessages: {
                 title,
-                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(14330, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(14331, "The model wants to run all tests.")),
+                message: inFiles?.length ? ( new MarkdownString()).appendMarkdown(( localize(14592, "The model wants to run tests in {0}.", inFiles.join(", ")))) : ( localize(14593, "The model wants to run all tests.")),
                 allowAutoConfirm: true
             }
         });
     }
 };
 RunTestTool = ( __decorate([( __param(0, ITestService)), ( __param(1, IUriIdentityService)), ( __param(2, IWorkspaceContextService)), ( __param(3, ITestResultService)), ( __param(4, ITestProfileService))], RunTestTool));
+async function buildTestRunSummary(result, mode, coverageFiles) {
+    const failures = result.counts[TestResultState.Errored] + result.counts[TestResultState.Failed];
+    let str = `<summary passed=${result.counts[TestResultState.Passed]} failed=${failures} />\n`;
+    if (failures !== 0) {
+        str += await getFailureDetails(result);
+    }
+    if (mode === "coverage") {
+        str += await getCoverageSummary(result, coverageFiles);
+    }
+    return str;
+}
+async function getCoverageSummary(result, coverageFiles) {
+    let str = "";
+    for (const task of result.tasks) {
+        const coverage = task.coverage.get();
+        if (!coverage) {
+            continue;
+        }
+        if (!coverageFiles || !coverageFiles.length) {
+            str += getOverallCoverageSummary(coverage);
+            continue;
+        }
+        const normalized = ( coverageFiles.map(file => URI.file(file).fsPath));
+        const coveredFilesMap = ( new Map());
+        for (const file of ( coverage.getAllFiles().values())) {
+            coveredFilesMap.set(file.uri.fsPath, file);
+        }
+        for (const path of normalized) {
+            const file = coveredFilesMap.get(path);
+            if (!file) {
+                continue;
+            }
+            str += await getFileCoverageDetails(file, path);
+        }
+    }
+    return str;
+}
+function getOverallCoverageSummary(coverage) {
+    const files = ( [...( coverage.getAllFiles().values())].map(f => ({
+        path: f.uri.fsPath,
+        pct: getTotalCoveragePercent(f.statement, f.branch, f.declaration) * 100
+    }))).filter(f => f.pct < 100).sort((a, b) => a.pct - b.pct);
+    if (!files.length) {
+        return "<coverageSummary>All files have 100% coverage.</coverageSummary>\n";
+    }
+    let str = "<coverageSummary>\n";
+    for (const f of files) {
+        str += `<file path="${f.path}" percent=${f.pct.toFixed(1)} />\n`;
+    }
+    str += "</coverageSummary>\n";
+    return str;
+}
+async function getFileCoverageDetails(file, path) {
+    const pct = getTotalCoveragePercent(file.statement, file.branch, file.declaration) * 100;
+    let str = `<coverage path="${path}" percent=${pct.toFixed(1)} statements=${file.statement.covered}/${file.statement.total}`;
+    if (file.branch) {
+        str += ` branches=${file.branch.covered}/${file.branch.total}`;
+    }
+    if (file.declaration) {
+        str += ` declarations=${file.declaration.covered}/${file.declaration.total}`;
+    }
+    str += ">\n";
+    try {
+        const details = await file.details();
+        const uncoveredDeclarations = [];
+        const uncoveredBranches = [];
+        const uncoveredLines = [];
+        for (const detail of details) {
+            if (detail.type === DetailType.Declaration) {
+                if (!detail.count) {
+                    const line = Position.isIPosition(detail.location) ? detail.location.lineNumber : detail.location.startLineNumber;
+                    uncoveredDeclarations.push({
+                        name: detail.name,
+                        line
+                    });
+                }
+            } else {
+                if (!detail.count) {
+                    const startLine = Position.isIPosition(detail.location) ? detail.location.lineNumber : detail.location.startLineNumber;
+                    const endLine = Position.isIPosition(detail.location) ? detail.location.lineNumber : detail.location.endLineNumber;
+                    uncoveredLines.push([startLine, endLine]);
+                }
+                if (detail.branches) {
+                    for (const branch of detail.branches) {
+                        if (!branch.count) {
+                            let line;
+                            if (branch.location) {
+                                line = Position.isIPosition(branch.location) ? branch.location.lineNumber : branch.location.startLineNumber;
+                            } else {
+                                line = Position.isIPosition(detail.location) ? detail.location.lineNumber : detail.location.startLineNumber;
+                            }
+                            uncoveredBranches.push({
+                                line,
+                                label: branch.label
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (uncoveredDeclarations.length) {
+            str += "uncovered functions: " + ( uncoveredDeclarations.map(d => `${d.name}(L${d.line})`)).join(", ") + "\n";
+        }
+        if (uncoveredBranches.length) {
+            str += "uncovered branches: " + ( uncoveredBranches.map(b => b.label ? `L${b.line}(${b.label})` : `L${b.line}`)).join(", ") + "\n";
+        }
+        if (uncoveredLines.length) {
+            str += "uncovered lines: " + mergeLineRanges(uncoveredLines) + "\n";
+        }
+    } catch {}
+    str += "</coverage>\n";
+    return str;
+}
+function mergeLineRanges(ranges) {
+    if (!ranges.length) {
+        return "";
+    }
+    ranges.sort((a, b) => a[0] - b[0]);
+    const merged = [ranges[0]];
+    for (let i = 1; i < ranges.length; i++) {
+        const last = merged[merged.length - 1];
+        const [start, end] = ranges[i];
+        if (start <= last[1] + 1) {
+            last[1] = Math.max(last[1], end);
+        } else {
+            merged.push([start, end]);
+        }
+    }
+    return ( merged.map(([s, e]) => s === e ? `${s}` : `${s}-${e}`)).join(", ");
+}
+async function getFailureDetails(result) {
+    let str = "";
+    let hadMessages = false;
+    for (const failure of result.tests) {
+        if (!isFailedState(failure.ownComputedState)) {
+            continue;
+        }
+        const [, ...testPath] = TestId.split(failure.item.extId);
+        const testName = testPath.pop();
+        str += `<testFailure name=${JSON.stringify(testName)} path=${JSON.stringify(testPath.join(" > "))}>\n`;
+        for (const task of failure.tasks) {
+            for (const message of task.messages.filter(m => m.type === TestMessageType.Error)) {
+                hadMessages = true;
+                if (message.expected !== undefined && message.actual !== undefined) {
+                    str += `<expectedOutput>\n${message.expected}\n</expectedOutput>\n`;
+                    str += `<actualOutput>\n${message.actual}\n</actualOutput>\n`;
+                } else {
+                    const messageText = typeof message.message === "string" ? message.message : message.message.value;
+                    str += `<message>\n${messageText}\n</message>\n`;
+                }
+                if (message.stackTrace && message.stackTrace.length > 0) {
+                    for (const frame of message.stackTrace.slice(0, 10)) {
+                        if (frame.uri && frame.position) {
+                            str += `<stackFrame path="${frame.uri.fsPath}" line="${frame.position.lineNumber}" col="${frame.position.column}" />\n`;
+                        } else if (frame.uri) {
+                            str += `<stackFrame path="${frame.uri.fsPath}">${frame.label}</stackFrame>\n`;
+                        } else {
+                            str += `<stackFrame>${frame.label}</stackFrame>\n`;
+                        }
+                    }
+                }
+                if (message.location) {
+                    str += `<location path="${message.location.uri.fsPath}" line="${message.location.range.startLineNumber}" col="${message.location.range.startColumn}" />\n`;
+                }
+            }
+        }
+        str += `</testFailure>\n`;
+    }
+    if (!hadMessages) {
+        const output = ( result.tasks.map(t => ( t.output.getRange(0, t.output.length).toString()).trim())).join("\n");
+        if (output) {
+            str += `<output>\n${output}\n</output>\n`;
+        }
+    }
+    return str;
+}
 
-export { TestingChatAgentToolContribution };
+export { RunTestTool, TestingChatAgentToolContribution, buildTestRunSummary, getCoverageSummary, getFailureDetails, getFileCoverageDetails, getOverallCoverageSummary, mergeLineRanges };

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

@@ -59,7 +59,7 @@ let TestingContentProvider = class TestingContentProvider {
                     return;
                 }
                 if (!hadContent) {
-                    append(( localize(14332, "The test run did not record any output.")));
+                    append(( localize(14594, "The test run did not record any output.")));
                     dispose.dispose();
                 }
             });

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

@@ -10,120 +10,120 @@ var TestingContextKeys;
     TestingContextKeys.canRefreshTests = ( new RawContextKey("testing.canRefresh", false, {
         type: "boolean",
         description: ( localize(
-            14333,
+            14595,
             "Indicates whether any test controller has an attached refresh handler."
         ))
     }));
     TestingContextKeys.isRefreshingTests = ( new RawContextKey("testing.isRefreshing", false, {
         type: "boolean",
         description: ( localize(
-            14334,
+            14596,
             "Indicates whether any test controller is currently refreshing tests."
         ))
     }));
     TestingContextKeys.isContinuousModeOn = ( new RawContextKey("testing.isContinuousModeOn", false, {
         type: "boolean",
-        description: ( localize(14335, "Indicates whether continuous test mode is on."))
+        description: ( localize(14597, "Indicates whether continuous test mode is on."))
     }));
     TestingContextKeys.hasDebuggableTests = ( new RawContextKey("testing.hasDebuggableTests", false, {
         type: "boolean",
         description: ( localize(
-            14336,
+            14598,
             "Indicates whether any test controller has registered a debug configuration"
         ))
     }));
     TestingContextKeys.hasRunnableTests = ( new RawContextKey("testing.hasRunnableTests", false, {
         type: "boolean",
         description: ( localize(
-            14337,
+            14599,
             "Indicates whether any test controller has registered a run configuration"
         ))
     }));
     TestingContextKeys.hasCoverableTests = ( new RawContextKey("testing.hasCoverableTests", false, {
         type: "boolean",
         description: ( localize(
-            14338,
+            14600,
             "Indicates whether any test controller has registered a coverage configuration"
         ))
     }));
     TestingContextKeys.hasNonDefaultProfile = ( new RawContextKey("testing.hasNonDefaultProfile", false, {
         type: "boolean",
         description: ( localize(
-            14339,
+            14601,
             "Indicates whether any test controller has registered a non-default configuration"
         ))
     }));
     TestingContextKeys.hasConfigurableProfile = ( new RawContextKey("testing.hasConfigurableProfile", false, {
         type: "boolean",
-        description: ( localize(14340, "Indicates whether any test configuration can be configured"))
+        description: ( localize(14602, "Indicates whether any test configuration can be configured"))
     }));
     TestingContextKeys.supportsContinuousRun = ( new RawContextKey("testing.supportsContinuousRun", false, {
         type: "boolean",
-        description: ( localize(14341, "Indicates whether continous test running is supported"))
+        description: ( localize(14603, "Indicates whether continous test running is supported"))
     }));
     TestingContextKeys.isParentRunningContinuously = ( new RawContextKey("testing.isParentRunningContinuously", false, {
         type: "boolean",
         description: ( localize(
-            14342,
+            14604,
             "Indicates whether the parent of a test is continuously running, set in the menu context of test items"
         ))
     }));
     TestingContextKeys.activeEditorHasTests = ( new RawContextKey("testing.activeEditorHasTests", false, {
         type: "boolean",
-        description: ( localize(14343, "Indicates whether any tests are present in the current editor"))
+        description: ( localize(14605, "Indicates whether any tests are present in the current editor"))
     }));
     TestingContextKeys.cursorInsideTestRange = ( new RawContextKey("testing.cursorInsideTestRange", false, {
         type: "boolean",
-        description: ( localize(14344, "Whether the cursor is currently inside a test range"))
+        description: ( localize(14606, "Whether the cursor is currently inside a test range"))
     }));
     TestingContextKeys.isTestCoverageOpen = ( new RawContextKey("testing.isTestCoverageOpen", false, {
         type: "boolean",
-        description: ( localize(14345, "Indicates whether a test coverage report is open"))
+        description: ( localize(14607, "Indicates whether a test coverage report is open"))
     }));
     TestingContextKeys.hasCoverageInFile = ( new RawContextKey("testing.hasCoverageInFile", false, {
         type: "boolean",
-        description: ( localize(14346, "Indicates coverage has been reported in the curent editor."))
+        description: ( localize(14608, "Indicates coverage has been reported in the curent editor."))
     }));
     TestingContextKeys.hasPerTestCoverage = ( new RawContextKey("testing.hasPerTestCoverage", false, {
         type: "boolean",
-        description: ( localize(14347, "Indicates whether per-test coverage is available"))
+        description: ( localize(14609, "Indicates whether per-test coverage is available"))
     }));
     TestingContextKeys.hasInlineCoverageDetails = ( new RawContextKey("testing.hasInlineCoverageDetails", false, {
         type: "boolean",
         description: ( localize(
-            14348,
+            14610,
             "Indicates whether detailed per-line coverage is available for inline display"
         ))
     }));
     TestingContextKeys.isCoverageFilteredToTest = ( new RawContextKey("testing.isCoverageFilteredToTest", false, {
         type: "boolean",
-        description: ( localize(14349, "Indicates whether coverage has been filterd to a single test"))
+        description: ( localize(14611, "Indicates whether coverage has been filterd to a single test"))
     }));
     TestingContextKeys.coverageToolbarEnabled = ( new RawContextKey("testing.coverageToolbarEnabled", true, {
         type: "boolean",
-        description: ( localize(14350, "Indicates whether the coverage toolbar is enabled"))
+        description: ( localize(14612, "Indicates whether the coverage toolbar is enabled"))
     }));
     TestingContextKeys.inlineCoverageEnabled = ( new RawContextKey("testing.inlineCoverageEnabled", false, {
         type: "boolean",
-        description: ( localize(14351, "Indicates whether inline coverage is shown"))
+        description: ( localize(14613, "Indicates whether inline coverage is shown"))
     }));
     TestingContextKeys.canGoToRelatedCode = ( new RawContextKey("testing.canGoToRelatedCode", false, {
         type: "boolean",
         description: ( localize(
-            14352,
+            14614,
             "Whether a controller implements a capability to find code related to a test"
         ))
     }));
     TestingContextKeys.canGoToRelatedTest = ( new RawContextKey("testing.canGoToRelatedTest", false, {
         type: "boolean",
         description: ( localize(
-            14353,
+            14615,
             "Whether a controller implements a capability to find tests related to code"
         ))
     }));
     TestingContextKeys.peekHasStack = ( new RawContextKey("testing.peekHasStack", false, {
         type: "boolean",
-        description: ( localize(14354, "Whether the message shown in a peek view has a stack trace"))
+        description: ( localize(14616, "Whether the message shown in a peek view has a stack trace"))
     }));
     TestingContextKeys.capabilityToContextKey = {
         [TestRunProfileBitset.Run]: TestingContextKeys.hasRunnableTests,
@@ -142,54 +142,54 @@ var TestingContextKeys;
     TestingContextKeys.peekItemType = ( new RawContextKey("peekItemType", undefined, {
         type: "string",
         description: ( localize(
-            14355,
+            14617,
             "Type of the item in the output peek view. Either a \"test\", \"message\", \"task\", or \"result\"."
         ))
     }));
     TestingContextKeys.controllerId = ( new RawContextKey("controllerId", undefined, {
         type: "string",
-        description: ( localize(14356, "Controller ID of the current test item"))
+        description: ( localize(14618, "Controller ID of the current test item"))
     }));
     TestingContextKeys.testItemExtId = ( new RawContextKey("testId", undefined, {
         type: "string",
         description: ( localize(
-            14357,
+            14619,
             "ID of the current test item, set when creating or opening menus on test items"
         ))
     }));
     TestingContextKeys.testItemHasUri = ( new RawContextKey("testing.testItemHasUri", false, {
         type: "boolean",
-        description: ( localize(14358, "Boolean indicating whether the test item has a URI defined"))
+        description: ( localize(14620, "Boolean indicating whether the test item has a URI defined"))
     }));
     TestingContextKeys.testItemIsHidden = ( new RawContextKey("testing.testItemIsHidden", false, {
         type: "boolean",
-        description: ( localize(14359, "Boolean indicating whether the test item is hidden"))
+        description: ( localize(14621, "Boolean indicating whether the test item is hidden"))
     }));
     TestingContextKeys.testMessageContext = ( new RawContextKey("testMessage", undefined, {
         type: "string",
         description: ( localize(
-            14360,
+            14622,
             "Value set in `testMessage.contextValue`, available in editor/content and testing/message/context"
         ))
     }));
     TestingContextKeys.testResultOutdated = ( new RawContextKey("testResultOutdated", undefined, {
         type: "boolean",
         description: ( localize(
-            14361,
+            14623,
             "Value available in editor/content and testing/message/context when the result is outdated"
         ))
     }));
     TestingContextKeys.testResultState = ( new RawContextKey("testResultState", undefined, {
         type: "string",
         description: ( localize(
-            14362,
+            14624,
             "Value available testing/item/result indicating the state of the item."
         ))
     }));
     TestingContextKeys.testProfileContextGroup = ( new RawContextKey("testing.profile.context.group", undefined, {
         type: "string",
         description: ( localize(
-            14363,
+            14625,
             "Type of menu where the configure testing profile submenu exists. Either \"run\", \"debug\", or \"coverage\""
         ))
     }));

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

@@ -43,10 +43,10 @@ const getTestProgressText = (
     }
     if (isRunning) {
         if (runSoFar === 0) {
-            return localize(14364, "Running tests...");
+            return localize(14626, "Running tests...");
         } else if (skipped === 0) {
             return localize(
-                14365,
+                14627,
                 "Running tests, {0}/{1} passed ({2}%)",
                 passed,
                 totalWillBeRun,
@@ -54,7 +54,7 @@ const getTestProgressText = (
             );
         } else {
             return localize(
-                14366,
+                14628,
                 "Running tests, {0}/{1} tests passed ({2}%, {3} skipped)",
                 passed,
                 totalWillBeRun,
@@ -65,7 +65,7 @@ const getTestProgressText = (
     } else {
         if (skipped === 0) {
             return localize(
-                14367,
+                14629,
                 "{0}/{1} tests passed ({2}%)",
                 passed,
                 runSoFar,
@@ -73,7 +73,7 @@ const getTestProgressText = (
             );
         } else {
             return localize(
-                14368,
+                14630,
                 "{0}/{1} tests passed ({2}%, {3} skipped)",
                 passed,
                 runSoFar,