@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

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

@@ -1,3 +1,158 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { findFirstIdxMonotonousOrArrLen } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+import { ITestProfileService } from './testProfileService.js';
+import { LiveTestResult } from './testResult.js';
+import { RETAIN_MAX_RESULTS, ITestResultStorage } from './testResultStorage.js';
+const isRunningTests = (service) => service.results.length > 0 && service.results[0].completedAt === undefined;
 const ITestResultService = ( createDecorator('testResultService'));
-export { ITestResultService };
+let TestResultService = class TestResultService extends Disposable {
+    get results() {
+        this.loadResults();
+        return this._results;
+    }
+    constructor(contextKeyService, storage, testProfiles) {
+        super();
+        this.storage = storage;
+        this.testProfiles = testProfiles;
+        this.changeResultEmitter = this._register(( new Emitter()));
+        this._results = [];
+        this._resultsDisposables = [];
+        this.testChangeEmitter = this._register(( new Emitter()));
+        this.onResultsChanged = this.changeResultEmitter.event;
+        this.onTestChanged = this.testChangeEmitter.event;
+        this.loadResults = createSingleCallFunction(() => this.storage.read().then(loaded => {
+            for (let i = loaded.length - 1; i >= 0; i--) {
+                this.push(loaded[i]);
+            }
+        }));
+        this.persistScheduler = ( new RunOnceScheduler(() => this.persistImmediately(), 500));
+        this._register(toDisposable(() => dispose(this._resultsDisposables)));
+        this.isRunning = TestingContextKeys.isRunning.bindTo(contextKeyService);
+        this.hasAnyResults = TestingContextKeys.hasAnyResults.bindTo(contextKeyService);
+    }
+    getStateById(extId) {
+        for (const result of this.results) {
+            const lookup = result.getStateById(extId);
+            if (lookup && lookup.computedState !== 0 ) {
+                return [result, lookup];
+            }
+        }
+        return undefined;
+    }
+    createLiveResult(req) {
+        if ('targets' in req) {
+            const id = generateUuid();
+            return this.push(( new LiveTestResult(id, true, req)));
+        }
+        let profile;
+        if (req.profile) {
+            const profiles = this.testProfiles.getControllerProfiles(req.controllerId);
+            profile = profiles.find(c => c.profileId === req.profile.id);
+        }
+        const resolved = {
+            isUiTriggered: false,
+            targets: [],
+            exclude: req.exclude,
+            continuous: req.continuous,
+        };
+        if (profile) {
+            resolved.targets.push({
+                profileGroup: profile.group,
+                profileId: profile.profileId,
+                controllerId: req.controllerId,
+                testIds: req.include,
+            });
+        }
+        return this.push(( new LiveTestResult(req.id, req.persist, resolved)));
+    }
+    push(result) {
+        if (result.completedAt === undefined) {
+            this.results.unshift(result);
+        }
+        else {
+            const index = findFirstIdxMonotonousOrArrLen(this.results, r => r.completedAt !== undefined && r.completedAt <= result.completedAt);
+            this.results.splice(index, 0, result);
+            this.persistScheduler.schedule();
+        }
+        this.hasAnyResults.set(true);
+        if (this.results.length > RETAIN_MAX_RESULTS) {
+            this.results.pop();
+            this._resultsDisposables.pop()?.dispose();
+        }
+        const ds = ( new DisposableStore());
+        this._resultsDisposables.push(ds);
+        if (result instanceof LiveTestResult) {
+            ds.add(result);
+            ds.add(result.onComplete(() => this.onComplete(result)));
+            ds.add(result.onChange(this.testChangeEmitter.fire, this.testChangeEmitter));
+            this.isRunning.set(true);
+            this.changeResultEmitter.fire({ started: result });
+        }
+        else {
+            this.changeResultEmitter.fire({ inserted: result });
+            for (const item of result.tests) {
+                for (const otherResult of this.results) {
+                    if (otherResult === result) {
+                        this.testChangeEmitter.fire({ item, result, reason: 0  });
+                        break;
+                    }
+                    else if (otherResult.getStateById(item.item.extId) !== undefined) {
+                        break;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    getResult(id) {
+        return this.results.find(r => r.id === id);
+    }
+    clear() {
+        const keep = [];
+        const removed = [];
+        for (const result of this.results) {
+            if (result.completedAt !== undefined) {
+                removed.push(result);
+            }
+            else {
+                keep.push(result);
+            }
+        }
+        this._results = keep;
+        this.persistScheduler.schedule();
+        if (keep.length === 0) {
+            this.hasAnyResults.set(false);
+        }
+        this.changeResultEmitter.fire({ removed });
+    }
+    onComplete(result) {
+        this.resort();
+        this.updateIsRunning();
+        this.persistScheduler.schedule();
+        this.changeResultEmitter.fire({ completed: result });
+    }
+    resort() {
+        this.results.sort((a, b) => (b.completedAt ?? Number.MAX_SAFE_INTEGER) - (a.completedAt ?? Number.MAX_SAFE_INTEGER));
+    }
+    updateIsRunning() {
+        this.isRunning.set(isRunningTests(this));
+    }
+    async persistImmediately() {
+        await this.loadResults();
+        this.storage.persist(this.results);
+    }
+};
+TestResultService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ITestResultStorage)),
+    ( __param(2, ITestProfileService))
+], TestResultService));
+export { ITestResultService, TestResultService };

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

@@ -0,0 +1,156 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer, bufferToStream, newWriteableBufferStream } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { StoredValue } from './storedValue.js';
+import { HydratedTestResult } from './testResult.js';
+const RETAIN_MAX_RESULTS = 128;
+const RETAIN_MIN_RESULTS = 16;
+const RETAIN_MAX_BYTES = 1024 * 128;
+const CLEANUP_PROBABILITY = 0.2;
+const ITestResultStorage = ( createDecorator('ITestResultStorage'));
+const currentRevision = 1;
+let BaseTestResultStorage = class BaseTestResultStorage extends Disposable {
+    constructor(storageService, logService) {
+        super();
+        this.storageService = storageService;
+        this.logService = logService;
+        this.stored = this._register(( new StoredValue({
+            key: 'storedTestResults',
+            scope: 1 ,
+            target: 1
+        }, this.storageService)));
+    }
+    async read() {
+        const results = await Promise.all(( this.stored.get([]).map(async ({ id, rev }) => {
+            if (rev !== currentRevision) {
+                return undefined;
+            }
+            try {
+                const contents = await this.readForResultId(id);
+                if (!contents) {
+                    return undefined;
+                }
+                return ( new HydratedTestResult(contents));
+            }
+            catch (e) {
+                this.logService.warn(`Error deserializing stored test result ${id}`, e);
+                return undefined;
+            }
+        })));
+        return results.filter(isDefined);
+    }
+    getResultOutputWriter(resultId) {
+        const stream = newWriteableBufferStream();
+        this.storeOutputForResultId(resultId, stream);
+        return stream;
+    }
+    async persist(results) {
+        const toDelete = ( new Map(( this.stored.get([]).map(({ id, bytes }) => [id, bytes]))));
+        const toStore = [];
+        const todo = [];
+        let budget = RETAIN_MAX_BYTES;
+        for (let i = 0; i < results.length && i < RETAIN_MAX_RESULTS && (budget > 0 || toStore.length < RETAIN_MIN_RESULTS); i++) {
+            const result = results[i];
+            const existingBytes = toDelete.get(result.id);
+            if (existingBytes !== undefined) {
+                toDelete.delete(result.id);
+                toStore.push({ id: result.id, rev: currentRevision, bytes: existingBytes });
+                budget -= existingBytes;
+                continue;
+            }
+            const obj = result.toJSON();
+            if (!obj) {
+                continue;
+            }
+            const contents = VSBuffer.fromString(JSON.stringify(obj));
+            todo.push(this.storeForResultId(result.id, obj));
+            toStore.push({ id: result.id, rev: currentRevision, bytes: contents.byteLength });
+            budget -= contents.byteLength;
+        }
+        for (const id of ( toDelete.keys())) {
+            todo.push(this.deleteForResultId(id).catch(() => undefined));
+        }
+        this.stored.store(toStore);
+        await Promise.all(todo);
+    }
+};
+BaseTestResultStorage = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ILogService))
+], BaseTestResultStorage));
+let TestResultStorage = class TestResultStorage extends BaseTestResultStorage {
+    constructor(storageService, logService, workspaceContext, fileService, environmentService) {
+        super(storageService, logService);
+        this.fileService = fileService;
+        this.directory = URI.joinPath(environmentService.workspaceStorageHome, workspaceContext.getWorkspace().id, 'testResults');
+    }
+    async readForResultId(id) {
+        const contents = await this.fileService.readFile(this.getResultJsonPath(id));
+        return JSON.parse(( contents.value.toString()));
+    }
+    storeForResultId(id, contents) {
+        return this.fileService.writeFile(this.getResultJsonPath(id), VSBuffer.fromString(JSON.stringify(contents)));
+    }
+    deleteForResultId(id) {
+        return this.fileService.del(this.getResultJsonPath(id)).catch(() => undefined);
+    }
+    async readOutputRangeForResultId(id, offset, length) {
+        try {
+            const { value } = await this.fileService.readFile(this.getResultOutputPath(id), { position: offset, length });
+            return value;
+        }
+        catch {
+            return VSBuffer.alloc(0);
+        }
+    }
+    async readOutputForResultId(id) {
+        try {
+            const { value } = await this.fileService.readFileStream(this.getResultOutputPath(id));
+            return value;
+        }
+        catch {
+            return bufferToStream(VSBuffer.alloc(0));
+        }
+    }
+    async storeOutputForResultId(id, input) {
+        await this.fileService.createFile(this.getResultOutputPath(id), input);
+    }
+    async persist(results) {
+        await super.persist(results);
+        if (Math.random() < CLEANUP_PROBABILITY) {
+            await this.cleanupDereferenced();
+        }
+    }
+    async cleanupDereferenced() {
+        const { children } = await this.fileService.resolve(this.directory);
+        if (!children) {
+            return;
+        }
+        const stored = ( new Set(( this.stored.get([]).filter(s => s.rev === currentRevision).map(s => s.id))));
+        await Promise.all(( children
+            .filter(child => !( stored.has(child.name.replace(/\.[a-z]+$/, ''))))
+            .map(child => this.fileService.del(child.resource).catch(() => undefined))));
+    }
+    getResultJsonPath(id) {
+        return URI.joinPath(this.directory, `${id}.json`);
+    }
+    getResultOutputPath(id) {
+        return URI.joinPath(this.directory, `${id}.output`);
+    }
+};
+TestResultStorage = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IEnvironmentService))
+], TestResultStorage));
+export { BaseTestResultStorage, ITestResultStorage, RETAIN_MAX_RESULTS, TestResultStorage };

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

@@ -1,3 +1,77 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { TestId } from './testId.js';
 const ITestService = ( createDecorator('testService'));
-export { ITestService };
+const testCollectionIsEmpty = (collection) => !( Iterable.some(collection.rootItems, r => r.children.size > 0));
+const getContextForTestItem = (collection, id) => {
+    if (typeof id === 'string') {
+        id = TestId.fromString(id);
+    }
+    if (id.isRoot) {
+        return { controller: ( id.toString()) };
+    }
+    const context = { $mid: 16 , tests: [] };
+    for (const i of id.idsFromRoot()) {
+        if (!i.isRoot) {
+            const test = collection.getNodeById(( i.toString()));
+            if (test) {
+                context.tests.push(test);
+            }
+        }
+    }
+    return context;
+};
+const expandAndGetTestById = async (collection, id, ct = CancellationToken.None) => {
+    const idPath = [...TestId.fromString(id).idsFromRoot()];
+    let expandToLevel = 0;
+    for (let i = idPath.length - 1; !ct.isCancellationRequested && i >= expandToLevel;) {
+        const id = ( idPath[i].toString());
+        const existing = collection.getNodeById(id);
+        if (!existing) {
+            i--;
+            continue;
+        }
+        if (i === idPath.length - 1) {
+            return existing;
+        }
+        if (!( existing.children.has(( idPath[i + 1].toString())))) {
+            await collection.expand(id, 0);
+        }
+        expandToLevel = i + 1;
+        i = idPath.length - 1;
+    }
+    return undefined;
+};
+const waitForTestToBeIdle = (testService, test) => {
+    if (!test.item.busy) {
+        return;
+    }
+    return ( new Promise(resolve => {
+        const l = testService.onDidProcessDiff(() => {
+            if (testService.collection.getNodeById(test.item.extId)?.item.busy !== true) {
+                resolve();
+                l.dispose();
+            }
+        });
+    }));
+};
+const testsInFile = async function* (testService, ident, uri, waitForIdle = true) {
+    for (const test of testService.collection.all) {
+        if (!test.item.uri) {
+            continue;
+        }
+        if (ident.extUri.isEqual(uri, test.item.uri)) {
+            yield test;
+        }
+        if (ident.extUri.isEqualOrParent(uri, test.item.uri)) {
+            if (test.expand === 1 ) {
+                await testService.collection.expand(test.item.extId, 1);
+            }
+            if (waitForIdle) {
+                await waitForTestToBeIdle(testService, test);
+            }
+        }
+    }
+};
+export { ITestService, expandAndGetTestById, getContextForTestItem, testCollectionIsEmpty, testsInFile };

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

@@ -1,6 +1,15 @@
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { TestId } from './testId.js';
+const testRunProfileBitsetList = [
+    2 ,
+    4 ,
+    8 ,
+    16 ,
+    32 ,
+    64 ,
+];
 const isStartControllerTests = (t) => 'runId' in t;
 var IRichLocation;
 ( (function(IRichLocation) {
@@ -210,6 +219,68 @@ var TestResultItem;
         retired: true,
     });
 })(TestResultItem || (TestResultItem = {})));
+var ICoveredCount;
+( (function(ICoveredCount) {
+    ICoveredCount.empty = () => ({ covered: 0, total: 0 });
+    ICoveredCount.sum = (target, src) => {
+        target.covered += src.covered;
+        target.total += src.total;
+    };
+})(ICoveredCount || (ICoveredCount = {})));
+var IFileCoverage;
+( (function(IFileCoverage) {
+    IFileCoverage.serialize = (original) => ({
+        statement: original.statement,
+        branch: original.branch,
+        function: original.function,
+        details: original.details?.map(CoverageDetails.serialize),
+        uri: original.uri.toJSON(),
+    });
+    IFileCoverage.deserialize = (serialized) => ({
+        statement: serialized.statement,
+        branch: serialized.branch,
+        function: serialized.function,
+        details: serialized.details?.map(CoverageDetails.deserialize),
+        uri: ( URI.from(serialized.uri)),
+    });
+})(IFileCoverage || (IFileCoverage = {})));
+function serializeThingWithLocation(serialized) {
+    return {
+        ...serialized,
+        location: serialized.location?.toJSON(),
+    };
+}
+function deserializeThingWithLocation(serialized) {
+    serialized.location = serialized.location ? (Position.isIPosition(serialized.location) ? Position.lift(serialized.location) : Range.lift(serialized.location)) : undefined;
+    return serialized;
+}
+const KEEP_N_LAST_COVERAGE_REPORTS = 3;
+var CoverageDetails;
+( (function(CoverageDetails) {
+    CoverageDetails.serialize = (original) => original.type === 0  ? IFunctionCoverage.serialize(original) : IStatementCoverage.serialize(original);
+    CoverageDetails.deserialize = (serialized) => serialized.type === 0  ? IFunctionCoverage.deserialize(serialized) : IStatementCoverage.deserialize(serialized);
+})(CoverageDetails || (CoverageDetails = {})));
+var IBranchCoverage;
+( (function(IBranchCoverage) {
+    IBranchCoverage.serialize = serializeThingWithLocation;
+    IBranchCoverage.deserialize = deserializeThingWithLocation;
+})(IBranchCoverage || (IBranchCoverage = {})));
+var IFunctionCoverage;
+( (function(IFunctionCoverage) {
+    IFunctionCoverage.serialize = serializeThingWithLocation;
+    IFunctionCoverage.deserialize = deserializeThingWithLocation;
+})(IFunctionCoverage || (IFunctionCoverage = {})));
+var IStatementCoverage;
+( (function(IStatementCoverage) {
+    IStatementCoverage.serialize = (original) => ({
+        ...serializeThingWithLocation(original),
+        branches: original.branches?.map(IBranchCoverage.serialize),
+    });
+    IStatementCoverage.deserialize = (serialized) => ({
+        ...deserializeThingWithLocation(serialized),
+        branches: serialized.branches?.map(IBranchCoverage.deserialize),
+    });
+})(IStatementCoverage || (IStatementCoverage = {})));
 var TestsDiffOp;
 ( (function(TestsDiffOp) {
     TestsDiffOp.deserialize = (u) => {
@@ -354,4 +425,4 @@ class AbstractIncrementalTestCollection {
         return {};
     }
 }
-export { AbstractIncrementalTestCollection, IRichLocation, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag };
+export { AbstractIncrementalTestCollection, CoverageDetails, IBranchCoverage, ICoveredCount, IFileCoverage, IFunctionCoverage, IRichLocation, IStatementCoverage, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, KEEP_N_LAST_COVERAGE_REPORTS, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testRunProfileBitsetList };

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

@@ -0,0 +1,188 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+var TestingContextKeys;
+( (function(TestingContextKeys) {
+    TestingContextKeys.providerCount = ( new RawContextKey('testing.providerCount', 0));
+    TestingContextKeys.canRefreshTests = ( new RawContextKey(
+        'testing.canRefresh',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.canRefresh',
+            'Indicates whether any test controller has an attached refresh handler.'
+        )) }
+    ));
+    TestingContextKeys.isRefreshingTests = ( new RawContextKey(
+        'testing.isRefreshing',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isRefreshing',
+            'Indicates whether any test controller is currently refreshing tests.'
+        )) }
+    ));
+    TestingContextKeys.isContinuousModeOn = ( new RawContextKey(
+        'testing.isContinuousModeOn',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isContinuousModeOn',
+            'Indicates whether continuous test mode is on.'
+        )) }
+    ));
+    TestingContextKeys.hasDebuggableTests = ( new RawContextKey(
+        'testing.hasDebuggableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasDebuggableTests',
+            'Indicates whether any test controller has registered a debug configuration'
+        )) }
+    ));
+    TestingContextKeys.hasRunnableTests = ( new RawContextKey(
+        'testing.hasRunnableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasRunnableTests',
+            'Indicates whether any test controller has registered a run configuration'
+        )) }
+    ));
+    TestingContextKeys.hasCoverableTests = ( new RawContextKey(
+        'testing.hasCoverableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasCoverableTests',
+            'Indicates whether any test controller has registered a coverage configuration'
+        )) }
+    ));
+    TestingContextKeys.hasNonDefaultProfile = ( new RawContextKey(
+        'testing.hasNonDefaultProfile',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasNonDefaultConfig',
+            'Indicates whether any test controller has registered a non-default configuration'
+        )) }
+    ));
+    TestingContextKeys.hasConfigurableProfile = ( new RawContextKey(
+        'testing.hasConfigurableProfile',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasConfigurableConfig',
+            'Indicates whether any test configuration can be configured'
+        )) }
+    ));
+    TestingContextKeys.supportsContinuousRun = ( new RawContextKey(
+        'testing.supportsContinuousRun',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.supportsContinuousRun',
+            'Indicates whether continous test running is supported'
+        )) }
+    ));
+    TestingContextKeys.isParentRunningContinuously = ( new RawContextKey(
+        'testing.isParentRunningContinuously',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isParentRunningContinuously',
+            '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: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.activeEditorHasTests',
+            'Indicates whether any tests are present in the current editor'
+        )) }
+    ));
+    TestingContextKeys.isTestCoverageOpen = ( new RawContextKey(
+        'testing.isTestCoverageOpen',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isTestCoverageOpen',
+            'Indicates whether a test coverage report is open'
+        )) }
+    ));
+    TestingContextKeys.capabilityToContextKey = {
+        [2 ]: TestingContextKeys.hasRunnableTests,
+        [8 ]: TestingContextKeys.hasCoverableTests,
+        [4 ]: TestingContextKeys.hasDebuggableTests,
+        [16 ]: TestingContextKeys.hasNonDefaultProfile,
+        [32 ]: TestingContextKeys.hasConfigurableProfile,
+        [64 ]: TestingContextKeys.supportsContinuousRun,
+    };
+    TestingContextKeys.hasAnyResults = ( new RawContextKey('testing.hasAnyResults', false));
+    TestingContextKeys.viewMode = ( new RawContextKey('testing.explorerViewMode', "list" ));
+    TestingContextKeys.viewSorting = ( new RawContextKey(
+        'testing.explorerViewSorting',
+        "location"
+    ));
+    TestingContextKeys.isRunning = ( new RawContextKey('testing.isRunning', false));
+    TestingContextKeys.isInPeek = ( new RawContextKey('testing.isInPeek', false));
+    TestingContextKeys.isPeekVisible = ( new RawContextKey('testing.isPeekVisible', false));
+    TestingContextKeys.peekItemType = ( new RawContextKey('peekItemType', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.peekItemType',
+            '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: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.controllerId',
+            'Controller ID of the current test item'
+        ))
+    }));
+    TestingContextKeys.testItemExtId = ( new RawContextKey('testId', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testId',
+            '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: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testItemHasUri',
+            'Boolean indicating whether the test item has a URI defined'
+        ))
+    }));
+    TestingContextKeys.testItemIsHidden = ( new RawContextKey('testing.testItemIsHidden', false, {
+        type: 'boolean',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testItemIsHidden',
+            'Boolean indicating whether the test item is hidden'
+        ))
+    }));
+    TestingContextKeys.testMessageContext = ( new RawContextKey('testMessage', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testMessage',
+            'Value set in `testMessage.contextValue`, available in editor/content and testing/message/context'
+        ))
+    }));
+    TestingContextKeys.testResultOutdated = ( new RawContextKey('testResultOutdated', undefined, {
+        type: 'boolean',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testResultOutdated',
+            'Value available in editor/content and testing/message/context when the result is outdated'
+        ))
+    }));
+})(TestingContextKeys || (TestingContextKeys = {})));
+export { TestingContextKeys };