@codingame/monaco-vscode-testing-service-override 3.2.3 → 4.1.0

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

@@ -1,273 +0,0 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
-
-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" ,
-                "runWithCoverage" ,
-                "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.coverage',
-                    'Run the test with coverage.'
-                )),
-                ( 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,
-        },
-        ["testing.showCoverageInExplorer" ]: {
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/testing/common/configuration',
-                'testing.ShowCoverageInExplorer',
-                "Whether test coverage should be down in the File Explorer view."
-            )),
-            type: 'boolean',
-            default: true,
-        },
-        ["testing.displayedCoveragePercent" ]: {
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/testing/common/configuration',
-                'testing.displayedCoveragePercent',
-                "Configures what percentage is displayed by default for test coverage."
-            )),
-            default: "totalCoverage" ,
-            enum: [
-                "totalCoverage" ,
-                "statement" ,
-                "minimum" ,
-            ],
-            enumDescriptions: [
-                ( localizeWithPath(
-                    'vs/workbench/contrib/testing/common/configuration',
-                    'testing.displayedCoveragePercent.totalCoverage',
-                    'A calculation of the combined statement, function, and branch coverage.'
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/testing/common/configuration',
-                    'testing.displayedCoveragePercent.statement',
-                    'The statement coverage.'
-                )),
-                ( localizeWithPath(
-                    'vs/workbench/contrib/testing/common/configuration',
-                    'testing.displayedCoveragePercent.minimum',
-                    'The minimum of statement, function, and branch coverage.'
-                )),
-            ],
-        },
-        ["testing.coverageBarThresholds" ]: {
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/testing/common/configuration',
-                'testing.coverageBarThresholds',
-                "Configures the colors used for percentages in test coverage bars."
-            )),
-            default: { red: 0, yellow: 60, green: 90 },
-            properties: {
-                red: { type: 'number', minimum: 0, maximum: 100, default: 0 },
-                yellow: { type: 'number', minimum: 0, maximum: 100, default: 60 },
-                green: { type: 'number', minimum: 0, maximum: 100, default: 90 },
-            },
-        },
-    }
-};
-const getTestingConfiguration = (config, key) => config.getValue(key);
-const observeTestingConfiguration = (config, key) => observableFromEvent(config.onDidChangeConfiguration, () => getTestingConfiguration(config, key));
-
-export { getTestingConfiguration, observeTestingConfiguration, testingConfiguration };

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

@@ -1,59 +0,0 @@
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-
-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 };

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

@@ -1,129 +0,0 @@
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { AbstractIncrementalTestCollection } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
-
-class MainThreadTestCollection extends AbstractIncrementalTestCollection {
-    get busyProviders() {
-        return this.busyControllerCount;
-    }
-    get rootItems() {
-        return this.roots;
-    }
-    get all() {
-        return this.getIterator();
-    }
-    get rootIds() {
-        return ( Iterable.map(( this.roots.values()), r => r.item.extId));
-    }
-    constructor(uriIdentityService, expandActual) {
-        super(uriIdentityService);
-        this.expandActual = expandActual;
-        this.testsByUrl = ( new ResourceMap());
-        this.busyProvidersChangeEmitter = ( new Emitter());
-        this.expandPromises = ( new WeakMap());
-        this.onBusyProvidersChange = this.busyProvidersChangeEmitter.event;
-        this.changeCollector = {
-            add: node => {
-                if (!node.item.uri) {
-                    return;
-                }
-                const s = this.testsByUrl.get(node.item.uri);
-                if (!s) {
-                    this.testsByUrl.set(node.item.uri, ( new Set([node])));
-                }
-                else {
-                    s.add(node);
-                }
-            },
-            remove: node => {
-                if (!node.item.uri) {
-                    return;
-                }
-                const s = this.testsByUrl.get(node.item.uri);
-                if (!s) {
-                    return;
-                }
-                s.delete(node);
-                if (s.size === 0) {
-                    this.testsByUrl.delete(node.item.uri);
-                }
-            },
-        };
-    }
-    expand(testId, levels) {
-        const test = this.items.get(testId);
-        if (!test) {
-            return Promise.resolve();
-        }
-        const existing = this.expandPromises.get(test);
-        if (existing && existing.pendingLvl >= levels) {
-            return existing.prom;
-        }
-        const prom = this.expandActual(test.item.extId, levels);
-        const record = { doneLvl: existing ? existing.doneLvl : -1, pendingLvl: levels, prom };
-        this.expandPromises.set(test, record);
-        return prom.then(() => {
-            record.doneLvl = levels;
-        });
-    }
-    getNodeById(id) {
-        return this.items.get(id);
-    }
-    getNodeByUrl(uri) {
-        return this.testsByUrl.get(uri) || Iterable.empty();
-    }
-    getReviverDiff() {
-        const ops = [{ op: 4 , amount: this.pendingRootCount }];
-        const queue = [this.rootIds];
-        while (queue.length) {
-            for (const child of queue.pop()) {
-                const item = this.items.get(child);
-                ops.push({
-                    op: 0 ,
-                    item: {
-                        controllerId: item.controllerId,
-                        expand: item.expand,
-                        item: item.item,
-                    }
-                });
-                queue.push(item.children);
-            }
-        }
-        return ops;
-    }
-    apply(diff) {
-        const prevBusy = this.busyControllerCount;
-        super.apply(diff);
-        if (prevBusy !== this.busyControllerCount) {
-            this.busyProvidersChangeEmitter.fire(this.busyControllerCount);
-        }
-    }
-    clear() {
-        const ops = [];
-        for (const root of this.roots) {
-            ops.push({ op: 3 , itemId: root.item.extId });
-        }
-        this.roots.clear();
-        this.items.clear();
-        return ops;
-    }
-    createItem(internal) {
-        return { ...internal, children: ( new Set()) };
-    }
-    createChangeCollector() {
-        return this.changeCollector;
-    }
-    *getIterator() {
-        const queue = [this.rootIds];
-        while (queue.length) {
-            for (const id of queue.pop()) {
-                const node = this.getNodeById(id);
-                yield node;
-                queue.push(node.children);
-            }
-        }
-    }
-}
-
-export { MainThreadTestCollection };

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

@@ -1,48 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { MutableObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
-import { StoredValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/storedValue';
-
-let TestExclusions = class TestExclusions extends Disposable {
-    constructor(storageService) {
-        super();
-        this.storageService = storageService;
-        this.excluded = this._register(MutableObservableValue.stored(this._register(( new StoredValue({
-            key: 'excludedTestItems',
-            scope: 1 ,
-            target: 1 ,
-            serialization: {
-                deserialize: v => ( new Set(JSON.parse(v))),
-                serialize: v => JSON.stringify([...v])
-            },
-        }, this.storageService))), ( new Set())));
-        this.onTestExclusionsChanged = this.excluded.onDidChange;
-    }
-    get hasAny() {
-        return this.excluded.value.size > 0;
-    }
-    get all() {
-        return this.excluded.value;
-    }
-    toggle(test, exclude) {
-        if (exclude !== true && ( this.excluded.value.has(test.item.extId))) {
-            this.excluded.value = ( new Set(Iterable.filter(this.excluded.value, e => e !== test.item.extId)));
-        }
-        else if (exclude !== false && !( this.excluded.value.has(test.item.extId))) {
-            this.excluded.value = ( new Set([...this.excluded.value, test.item.extId]));
-        }
-    }
-    contains(test) {
-        return ( this.excluded.value.has(test.item.extId));
-    }
-    clear() {
-        this.excluded.value = ( new Set());
-    }
-};
-TestExclusions = ( __decorate([
-    ( __param(0, IStorageService))
-], TestExclusions));
-
-export { TestExclusions };