@codingame/monaco-vscode-testing-service-override 1.83.16

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

@@ -0,0 +1,142 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { getTestingConfiguration } from '../common/configuration.js';
+import { isFailedState } from 'vscode/vscode/vs/workbench/contrib/testing/common/testingStates';
+import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
+
+let TestingProgressTrigger = class TestingProgressTrigger extends Disposable {
+    constructor(resultService, configurationService, viewsService) {
+        super();
+        this.configurationService = configurationService;
+        this.viewsService = viewsService;
+        this._register(resultService.onResultsChanged((e) => {
+            if ('started' in e) {
+                this.attachAutoOpenForNewResults(e.started);
+            }
+        }));
+    }
+    attachAutoOpenForNewResults(result) {
+        if (result.request.isUiTriggered === false) {
+            return;
+        }
+        const cfg = getTestingConfiguration(this.configurationService, "testing.openTesting" );
+        if (cfg === "neverOpen" ) {
+            return;
+        }
+        if (cfg === "openExplorerOnTestStart" ) {
+            return this.openExplorerView();
+        }
+        if (cfg === "openOnTestStart" ) {
+            return this.openResultsView();
+        }
+        const disposable = ( new DisposableStore());
+        disposable.add(result.onComplete(() => disposable.dispose()));
+        disposable.add(result.onChange(e => {
+            if (e.reason === 1  && isFailedState(e.item.ownComputedState)) {
+                this.openResultsView();
+                disposable.dispose();
+            }
+        }));
+    }
+    openExplorerView() {
+        this.viewsService.openView("workbench.view.testing" , false);
+    }
+    openResultsView() {
+        this.viewsService.openView("workbench.panel.testResults.view" , false);
+    }
+};
+TestingProgressTrigger = ( __decorate([
+    ( __param(0, ITestResultService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IViewsService))
+], TestingProgressTrigger));
+const collectTestStateCounts = (isRunning, results) => {
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let running = 0;
+    let queued = 0;
+    for (const result of results) {
+        const count = result.counts;
+        failed += count[6 ] + count[4 ];
+        passed += count[3 ];
+        skipped += count[5 ];
+        running += count[2 ];
+        queued += count[1 ];
+    }
+    return {
+        isRunning,
+        passed,
+        failed,
+        runSoFar: passed + failed,
+        totalWillBeRun: passed + failed + queued + running,
+        skipped,
+    };
+};
+const getTestProgressText = ({ isRunning, passed, runSoFar, totalWillBeRun, skipped, failed }) => {
+    let percent = passed / runSoFar * 100;
+    if (failed > 0) {
+        percent = Math.min(percent, 99.9);
+    }
+    else if (runSoFar === 0) {
+        percent = 0;
+    }
+    if (isRunning) {
+        if (runSoFar === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingProgressUiService',
+                'testProgress.runningInitial',
+                'Running tests...'
+            ));
+        }
+        else if (skipped === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingProgressUiService',
+                'testProgress.running',
+                'Running tests, {0}/{1} passed ({2}%)',
+                passed,
+                totalWillBeRun,
+                percent.toPrecision(3)
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingProgressUiService',
+                'testProgressWithSkip.running',
+                'Running tests, {0}/{1} tests passed ({2}%, {3} skipped)',
+                passed,
+                totalWillBeRun,
+                percent.toPrecision(3),
+                skipped
+            ));
+        }
+    }
+    else {
+        if (skipped === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingProgressUiService',
+                'testProgress.completed',
+                '{0}/{1} tests passed ({2}%)',
+                passed,
+                runSoFar,
+                percent.toPrecision(3)
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testingProgressUiService',
+                'testProgressWithSkip.completed',
+                '{0}/{1} tests passed ({2}%, {3} skipped)',
+                passed,
+                runSoFar,
+                percent.toPrecision(3),
+                skipped
+            ));
+        }
+    }
+};
+
+export { TestingProgressTrigger, collectTestStateCounts, getTestProgressText };

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

@@ -0,0 +1,47 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+
+let TestingViewPaneContainer = class TestingViewPaneContainer extends ViewPaneContainer {
+    constructor(layoutService, telemetryService, instantiationService, contextMenuService, themeService, storageService, configurationService, extensionService, contextService, viewDescriptorService) {
+        super("workbench.view.extension.test" , { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
+    }
+    create(parent) {
+        super.create(parent);
+        parent.classList.add('testing-view-pane');
+    }
+    getOptimalWidth() {
+        return 400;
+    }
+    getTitle() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testingViewPaneContainer',
+            'testing',
+            "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))
+], TestingViewPaneContainer));
+
+export { TestingViewPaneContainer };

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

@@ -0,0 +1,130 @@
+import { Color, RGBA } from 'monaco-editor/esm/vs/base/common/color.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, editorErrorForeground, contrastBorder, transparent, editorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+
+const testingColorIconFailed = registerColor('testing.iconFailed', {
+    dark: '#f14c4c',
+    light: '#f14c4c',
+    hcDark: '#f14c4c',
+    hcLight: '#B5200D'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconFailed',
+    "Color for the 'failed' icon in the test explorer."
+)));
+const testingColorIconErrored = registerColor('testing.iconErrored', {
+    dark: '#f14c4c',
+    light: '#f14c4c',
+    hcDark: '#f14c4c',
+    hcLight: '#B5200D'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconErrored',
+    "Color for the 'Errored' icon in the test explorer."
+)));
+const testingColorIconPassed = registerColor('testing.iconPassed', {
+    dark: '#73c991',
+    light: '#73c991',
+    hcDark: '#73c991',
+    hcLight: '#007100'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconPassed',
+    "Color for the 'passed' icon in the test explorer."
+)));
+const testingColorRunAction = registerColor('testing.runAction', {
+    dark: testingColorIconPassed,
+    light: testingColorIconPassed,
+    hcDark: testingColorIconPassed,
+    hcLight: testingColorIconPassed
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.runAction',
+    "Color for 'run' icons in the editor."
+)));
+const testingColorIconQueued = registerColor('testing.iconQueued', {
+    dark: '#cca700',
+    light: '#cca700',
+    hcDark: '#cca700',
+    hcLight: '#cca700'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconQueued',
+    "Color for the 'Queued' icon in the test explorer."
+)));
+const testingColorIconUnset = registerColor('testing.iconUnset', {
+    dark: '#848484',
+    light: '#848484',
+    hcDark: '#848484',
+    hcLight: '#848484'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconUnset',
+    "Color for the 'Unset' icon in the test explorer."
+)));
+const testingColorIconSkipped = registerColor('testing.iconSkipped', {
+    dark: '#848484',
+    light: '#848484',
+    hcDark: '#848484',
+    hcLight: '#848484'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.iconSkipped',
+    "Color for the 'Skipped' icon in the test explorer."
+)));
+const testingPeekBorder = registerColor('testing.peekBorder', {
+    dark: editorErrorForeground,
+    light: editorErrorForeground,
+    hcDark: contrastBorder,
+    hcLight: contrastBorder
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.peekBorder',
+    'Color of the peek view borders and arrow.'
+)));
+const testingPeekHeaderBackground = registerColor('testing.peekHeaderBackground', {
+    dark: ( transparent(editorErrorForeground, 0.1)),
+    light: ( transparent(editorErrorForeground, 0.1)),
+    hcDark: null,
+    hcLight: null
+}, ( localizeWithPath(
+    'vs/workbench/contrib/testing/browser/theme',
+    'testing.peekBorder',
+    'Color of the peek view borders and arrow.'
+)));
+({
+    [0 ]: {
+        decorationForeground: registerColor('testing.message.error.decorationForeground', { dark: editorErrorForeground, light: editorErrorForeground, hcDark: editorForeground, hcLight: editorForeground }, ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/theme',
+            'testing.message.error.decorationForeground',
+            'Text color of test error messages shown inline in the editor.'
+        ))),
+        marginBackground: registerColor('testing.message.error.lineBackground', { dark: ( new Color(( new RGBA(255, 0, 0, 0.2)))), light: ( new Color(( new RGBA(255, 0, 0, 0.2)))), hcDark: null, hcLight: null }, ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/theme',
+            'testing.message.error.marginBackground',
+            'Margin color beside error messages shown inline in the editor.'
+        ))),
+    },
+    [1 ]: {
+        decorationForeground: registerColor('testing.message.info.decorationForeground', { dark: ( transparent(editorForeground, 0.5)), light: ( transparent(editorForeground, 0.5)), hcDark: ( transparent(editorForeground, 0.5)), hcLight: ( transparent(editorForeground, 0.5)) }, ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/theme',
+            'testing.message.info.decorationForeground',
+            'Text color of test info messages shown inline in the editor.'
+        ))),
+        marginBackground: registerColor('testing.message.info.lineBackground', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/theme',
+            'testing.message.info.marginBackground',
+            'Margin color beside info messages shown inline in the editor.'
+        ))),
+    },
+});
+const testStatesToIconColors = {
+    [6 ]: testingColorIconErrored,
+    [4 ]: testingColorIconFailed,
+    [3 ]: testingColorIconPassed,
+    [1 ]: testingColorIconQueued,
+    [0 ]: testingColorIconUnset,
+    [5 ]: testingColorIconSkipped,
+};
+
+export { testStatesToIconColors, testingColorIconErrored, testingColorIconFailed, testingColorIconPassed, testingColorIconQueued, testingColorIconSkipped, testingColorIconUnset, testingColorRunAction, testingPeekBorder, testingPeekHeaderBackground };

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

@@ -0,0 +1,213 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+const testingConfiguration = {
+    id: 'testing',
+    order: 21,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/configuration',
+        'testConfigurationTitle',
+        "Testing"
+    )),
+    type: 'object',
+    properties: {
+        ["testing.autoRun.delay" ]: {
+            type: 'integer',
+            minimum: 0,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.autoRun.delay',
+                "How long to wait, in milliseconds, after a test is marked as outdated and starting a new run."
+            )),
+            default: 1000,
+        },
+        ["testing.automaticallyOpenPeekView" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.automaticallyOpenPeekView',
+                "Configures when the error Peek view is automatically opened."
+            )),
+            enum: [
+                "failureAnywhere" ,
+                "failureInVisibleDocument" ,
+                "never" ,
+            ],
+            default: "failureInVisibleDocument" ,
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.automaticallyOpenPeekView.failureAnywhere',
+                    "Open automatically no matter where the failure is."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.automaticallyOpenPeekView.failureInVisibleDocument',
+                    "Open automatically when a test fails in a visible document."
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.automaticallyOpenPeekView.never',
+                    "Never automatically open."
+                )),
+            ],
+        },
+        ["testing.showAllMessages" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.showAllMessages',
+                "Controls whether to show messages from all test runs."
+            )),
+            type: 'boolean',
+            default: false,
+        },
+        ["testing.automaticallyOpenPeekViewDuringAutoRun" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.automaticallyOpenPeekViewDuringContinuousRun',
+                "Controls whether to automatically open the Peek view during continuous run mode."
+            )),
+            type: 'boolean',
+            default: false,
+        },
+        ["testing.countBadge" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.countBadge',
+                'Controls the count badge on the Testing icon on the Activity Bar.'
+            )),
+            enum: [
+                "failed" ,
+                "off" ,
+                "passed" ,
+                "skipped" ,
+            ],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.countBadge.failed',
+                    'Show the number of failed tests'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.countBadge.off',
+                    'Disable the testing count badge'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.countBadge.passed',
+                    'Show the number of passed tests'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.countBadge.skipped',
+                    'Show the number of skipped tests'
+                )),
+            ],
+            default: "failed" ,
+        },
+        ["testing.followRunningTest" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.followRunningTest',
+                'Controls whether the running test should be followed in the Test Explorer view.'
+            )),
+            type: 'boolean',
+            default: true,
+        },
+        ["testing.defaultGutterClickAction" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.defaultGutterClickAction',
+                'Controls the action to take when left-clicking on a test decoration in the gutter.'
+            )),
+            enum: [
+                "run" ,
+                "debug" ,
+                "contextMenu" ,
+            ],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.defaultGutterClickAction.run',
+                    'Run the test.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.defaultGutterClickAction.debug',
+                    'Debug the test.'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.defaultGutterClickAction.contextMenu',
+                    'Open the context menu for more options.'
+                )),
+            ],
+            default: "run" ,
+        },
+        ["testing.gutterEnabled" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.gutterEnabled',
+                'Controls whether test decorations are shown in the editor gutter.'
+            )),
+            type: 'boolean',
+            default: true,
+        },
+        ["testing.saveBeforeTest" ]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.saveBeforeTest',
+                'Control whether save all dirty editors before running a test.'
+            )),
+            type: 'boolean',
+            default: true,
+        },
+        ["testing.openTesting" ]: {
+            enum: [
+                "neverOpen" ,
+                "openOnTestStart" ,
+                "openOnTestFailure" ,
+                "openExplorerOnTestStart" ,
+            ],
+            enumDescriptions: [
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.openTesting.neverOpen',
+                    'Never automatically open the testing views'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.openTesting.openOnTestStart',
+                    'Open the test results view when tests start'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.openTesting.openOnTestFailure',
+                    'Open the test result view on any test failure'
+                )),
+                ( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/configuration',
+                    'testing.openTesting.openExplorerOnTestStart',
+                    'Open the test explorer when tests start'
+                )),
+            ],
+            default: 'openOnTestStart',
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.openTesting',
+                "Controls when the testing view should open."
+            ))
+        },
+        ["testing.alwaysRevealTestOnStateChange" ]: {
+            markdownDescription: ( localizeWithPath(
+                'vs/workbench/contrib/testing/common/configuration',
+                'testing.alwaysRevealTestOnStateChange',
+                "Always reveal the executed test when `#testing.followRunningTest#` is on. If this setting is turned off, only failed tests will be revealed."
+            )),
+            type: 'boolean',
+            default: false,
+        },
+    }
+};
+const getTestingConfiguration = (config, key) => config.getValue(key);
+
+export { getTestingConfiguration, testingConfiguration };

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

@@ -0,0 +1,59 @@
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+const testStateNames = {
+    [6 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.errored',
+        'Errored'
+    )),
+    [4 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.failed',
+        'Failed'
+    )),
+    [3 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.passed',
+        'Passed'
+    )),
+    [1 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.queued',
+        'Queued'
+    )),
+    [2 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.running',
+        'Running'
+    )),
+    [5 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.skipped',
+        'Skipped'
+    )),
+    [0 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testState.unset',
+        'Not yet run'
+    )),
+};
+const labelForTestInState = (label, state) => ( localizeWithPath('vs/workbench/contrib/testing/common/constants', {
+    key: 'testing.treeElementLabel',
+    comment: ['label then the unit tests state, for example "Addition Tests (Running)"'],
+}, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const testConfigurationGroupNames = {
+    [4 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testGroup.debug',
+        'Debug'
+    )),
+    [2 ]: ( localizeWithPath('vs/workbench/contrib/testing/common/constants', 'testGroup.run', 'Run')),
+    [8 ]: ( localizeWithPath(
+        'vs/workbench/contrib/testing/common/constants',
+        'testGroup.coverage',
+        'Coverage'
+    )),
+};
+
+export { labelForTestInState, testConfigurationGroupNames };