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

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

@@ -0,0 +1,384 @@
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { removeAnsiEscapeCodes } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { refreshComputedState } from './getComputedState.js';
+import { MutableObservableValue, staticObservableValue } from './observableValue.js';
+import { TestId } from './testId.js';
+import { makeEmptyCounts, terminalStatePriorities, maxPriority, statesInOrder } from './testingStates.js';
+import { TestResultItem, getMarkId } from './testTypes.js';
+const emptyRawOutput = {
+    buffers: [],
+    length: 0,
+    onDidWriteData: Event.None,
+    endPromise: Promise.resolve(),
+    getRange: () => VSBuffer.alloc(0),
+    getRangeIter: () => [],
+};
+class TaskRawOutput {
+    constructor() {
+        this.writeDataEmitter = ( new Emitter());
+        this.endDeferred = ( new DeferredPromise());
+        this.offset = 0;
+        this.onDidWriteData = this.writeDataEmitter.event;
+        this.endPromise = this.endDeferred.p;
+        this.buffers = [];
+    }
+    get length() {
+        return this.offset;
+    }
+    getRange(start, length) {
+        const buf = VSBuffer.alloc(length);
+        let bufLastWrite = 0;
+        for (const chunk of this.getRangeIter(start, length)) {
+            buf.buffer.set(chunk.buffer, bufLastWrite);
+            bufLastWrite += chunk.byteLength;
+        }
+        return bufLastWrite < length ? buf.slice(0, bufLastWrite) : buf;
+    }
+    *getRangeIter(start, length) {
+        let soFar = 0;
+        let internalLastRead = 0;
+        for (const b of this.buffers) {
+            if (internalLastRead + b.byteLength <= start) {
+                internalLastRead += b.byteLength;
+                continue;
+            }
+            const bstart = Math.max(0, start - internalLastRead);
+            const bend = Math.min(b.byteLength, bstart + length - soFar);
+            yield b.slice(bstart, bend);
+            soFar += bend - bstart;
+            internalLastRead += b.byteLength;
+            if (soFar === length) {
+                break;
+            }
+        }
+    }
+    append(data, marker) {
+        const offset = this.offset;
+        let length = data.byteLength;
+        if (marker === undefined) {
+            this.push(data);
+            return { offset, length };
+        }
+        const start = VSBuffer.fromString(getMarkCode(marker, true));
+        const end = VSBuffer.fromString(getMarkCode(marker, false));
+        length += start.byteLength + end.byteLength;
+        this.push(start);
+        let trimLen = data.byteLength;
+        for (; trimLen > 0; trimLen--) {
+            const last = data.buffer[trimLen - 1];
+            if (last !== 13  && last !== 10 ) {
+                break;
+            }
+        }
+        this.push(data.slice(0, trimLen));
+        this.push(end);
+        this.push(data.slice(trimLen));
+        return { offset, length };
+    }
+    push(data) {
+        if (data.byteLength === 0) {
+            return;
+        }
+        this.buffers.push(data);
+        this.writeDataEmitter.fire(data);
+        this.offset += data.byteLength;
+    }
+    end() {
+        this.endDeferred.complete();
+    }
+}
+const resultItemParents = function* (results, item) {
+    for (const id of TestId.fromString(item.item.extId).idsToRoot()) {
+        yield results.getStateById(( id.toString()));
+    }
+};
+const maxCountPriority = (counts) => {
+    for (const state of statesInOrder) {
+        if (counts[state] > 0) {
+            return state;
+        }
+    }
+    return 0 ;
+};
+const getMarkCode = (marker, start) => `\x1b]633;SetMark;Id=${getMarkId(marker, start)};Hidden\x07`;
+const itemToNode = (controllerId, item, parent) => ({
+    controllerId,
+    expand: 0 ,
+    item: { ...item },
+    children: [],
+    tasks: [],
+    ownComputedState: 0 ,
+    computedState: 0 ,
+});
+class LiveTestResult extends Disposable {
+    get completedAt() {
+        return this._completedAt;
+    }
+    get tests() {
+        return ( this.testById.values());
+    }
+    constructor(id, persist, request) {
+        super();
+        this.id = id;
+        this.persist = persist;
+        this.request = request;
+        this.completeEmitter = this._register(( new Emitter()));
+        this.newTaskEmitter = this._register(( new Emitter()));
+        this.endTaskEmitter = this._register(( new Emitter()));
+        this.changeEmitter = this._register(( new Emitter()));
+        this.testById = ( new Map());
+        this.testMarkerCounter = 0;
+        this.startedAt = Date.now();
+        this.onChange = this.changeEmitter.event;
+        this.onComplete = this.completeEmitter.event;
+        this.onNewTask = this.newTaskEmitter.event;
+        this.onEndTask = this.endTaskEmitter.event;
+        this.tasks = [];
+        this.name = ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testResult',
+            'runFinished',
+            'Test run at {0}',
+            ( new Date()).toLocaleString(language)
+        ));
+        this.counts = makeEmptyCounts();
+        this.computedStateAccessor = {
+            getOwnState: i => i.ownComputedState,
+            getCurrentComputedState: i => i.computedState,
+            setComputedState: (i, s) => i.computedState = s,
+            getChildren: i => i.children,
+            getParents: i => {
+                const { testById: testByExtId } = this;
+                return (function* () {
+                    const parentId = TestId.fromString(i.item.extId).parentId;
+                    if (parentId) {
+                        for (const id of parentId.idsToRoot()) {
+                            yield testByExtId.get(( id.toString()));
+                        }
+                    }
+                })();
+            },
+        };
+        this.doSerialize = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serializeWithoutMessages)),
+        })));
+        this.doSerializeWithMessages = ( new Lazy(() => ({
+            id: this.id,
+            completedAt: this.completedAt,
+            tasks: ( this.tasks.map(t => ({ id: t.id, name: t.name }))),
+            name: this.name,
+            request: this.request,
+            items: ( [...( this.testById.values())].map(TestResultItem.serialize)),
+        })));
+    }
+    getStateById(extTestId) {
+        return this.testById.get(extTestId);
+    }
+    appendOutput(output, taskId, location, testId) {
+        const preview = output.byteLength > 100 ? ( output.slice(0, 100).toString()) + '…' : ( output.toString());
+        let marker;
+        if (testId || location) {
+            marker = this.testMarkerCounter++;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        const { offset, length } = task.output.append(output, marker);
+        const message = {
+            location,
+            message: removeAnsiEscapeCodes(preview),
+            offset,
+            length,
+            marker,
+            type: 1 ,
+        };
+        const test = testId && this.testById.get(testId);
+        if (test) {
+            test.tasks[index].messages.push(message);
+            this.changeEmitter.fire({ item: test, result: this, reason: 2 , message });
+        }
+        else {
+            task.otherMessages.push(message);
+        }
+    }
+    addTask(task) {
+        this.tasks.push({ ...task, coverage: this._register(( new MutableObservableValue(undefined))), otherMessages: [], output: ( new TaskRawOutput()) });
+        for (const test of this.tests) {
+            test.tasks.push({ duration: undefined, messages: [], state: 0  });
+        }
+        this.newTaskEmitter.fire(this.tasks.length - 1);
+    }
+    addTestChainToRun(controllerId, chain) {
+        let parent = this.testById.get(chain[0].extId);
+        if (!parent) {
+            parent = this.addTestToRun(controllerId, chain[0], null);
+        }
+        for (let i = 1; i < chain.length; i++) {
+            parent = this.addTestToRun(controllerId, chain[i], parent.item.extId);
+        }
+        return undefined;
+    }
+    updateState(testId, taskId, state, duration) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        const index = this.mustGetTaskIndex(taskId);
+        const oldTerminalStatePrio = terminalStatePriorities[entry.tasks[index].state];
+        const newTerminalStatePrio = terminalStatePriorities[state];
+        if (oldTerminalStatePrio !== undefined &&
+            (newTerminalStatePrio === undefined || newTerminalStatePrio < oldTerminalStatePrio)) {
+            return;
+        }
+        this.fireUpdateAndRefresh(entry, index, state, duration);
+    }
+    appendMessage(testId, taskId, message) {
+        const entry = this.testById.get(testId);
+        if (!entry) {
+            return;
+        }
+        entry.tasks[this.mustGetTaskIndex(taskId)].messages.push(message);
+        this.changeEmitter.fire({ item: entry, result: this, reason: 2 , message });
+    }
+    markTaskComplete(taskId) {
+        const index = this.mustGetTaskIndex(taskId);
+        const task = this.tasks[index];
+        task.running = false;
+        task.output.end();
+        this.setAllToState(0 , taskId, t => t.state === 1  || t.state === 2 );
+        this.endTaskEmitter.fire(index);
+    }
+    markComplete() {
+        if (this._completedAt !== undefined) {
+            throw new Error('cannot complete a test result multiple times');
+        }
+        for (const task of this.tasks) {
+            if (task.running) {
+                this.markTaskComplete(task.id);
+            }
+        }
+        this._completedAt = Date.now();
+        this.completeEmitter.fire();
+    }
+    markRetired(testIds) {
+        for (const [id, test] of this.testById) {
+            if (!test.retired && (!testIds || testIds.hasKeyOrParent(TestId.fromString(id).path))) {
+                test.retired = true;
+                this.changeEmitter.fire({ reason: 0 , item: test, result: this });
+            }
+        }
+    }
+    toJSON() {
+        return this.completedAt && this.persist ? this.doSerialize.value : undefined;
+    }
+    toJSONWithMessages() {
+        return this.completedAt && this.persist ? this.doSerializeWithMessages.value : undefined;
+    }
+    setAllToState(state, taskId, when) {
+        const index = this.mustGetTaskIndex(taskId);
+        for (const test of ( this.testById.values())) {
+            if (when(test.tasks[index], test)) {
+                this.fireUpdateAndRefresh(test, index, state);
+            }
+        }
+    }
+    fireUpdateAndRefresh(entry, taskIndex, newState, newOwnDuration) {
+        const previousOwnComputed = entry.ownComputedState;
+        const previousOwnDuration = entry.ownDuration;
+        const changeEvent = {
+            item: entry,
+            result: this,
+            reason: 1 ,
+            previousState: previousOwnComputed,
+            previousOwnDuration: previousOwnDuration,
+        };
+        entry.tasks[taskIndex].state = newState;
+        if (newOwnDuration !== undefined) {
+            entry.tasks[taskIndex].duration = newOwnDuration;
+            entry.ownDuration = Math.max(entry.ownDuration || 0, newOwnDuration);
+        }
+        const newOwnComputed = maxPriority(...( entry.tasks.map(t => t.state)));
+        if (newOwnComputed === previousOwnComputed) {
+            if (newOwnDuration !== previousOwnDuration) {
+                this.changeEmitter.fire(changeEvent);
+            }
+            return;
+        }
+        entry.ownComputedState = newOwnComputed;
+        this.counts[previousOwnComputed]--;
+        this.counts[newOwnComputed]++;
+        refreshComputedState(this.computedStateAccessor, entry).forEach(t => this.changeEmitter.fire(t === entry ? changeEvent : {
+            item: t,
+            result: this,
+            reason: 0 ,
+        }));
+    }
+    addTestToRun(controllerId, item, parent) {
+        const node = itemToNode(controllerId, item);
+        this.testById.set(item.extId, node);
+        this.counts[0 ]++;
+        if (parent) {
+            this.testById.get(parent)?.children.push(node);
+        }
+        if (this.tasks.length) {
+            for (let i = 0; i < this.tasks.length; i++) {
+                node.tasks.push({ duration: undefined, messages: [], state: 0  });
+            }
+        }
+        return node;
+    }
+    mustGetTaskIndex(taskId) {
+        const index = this.tasks.findIndex(t => t.id === taskId);
+        if (index === -1) {
+            throw new Error(`Unknown task ${taskId} in updateState`);
+        }
+        return index;
+    }
+}
+class HydratedTestResult {
+    get tests() {
+        return ( this.testById.values());
+    }
+    constructor(serialized, persist = true) {
+        this.serialized = serialized;
+        this.persist = persist;
+        this.counts = makeEmptyCounts();
+        this.testById = ( new Map());
+        this.id = serialized.id;
+        this.completedAt = serialized.completedAt;
+        this.tasks = ( serialized.tasks.map((task, i) => ({
+            id: task.id,
+            name: task.name,
+            running: false,
+            coverage: staticObservableValue(undefined),
+            output: emptyRawOutput,
+            otherMessages: []
+        })));
+        this.name = serialized.name;
+        this.request = serialized.request;
+        for (const item of serialized.items) {
+            const de = TestResultItem.deserialize(item);
+            this.counts[de.ownComputedState]++;
+            this.testById.set(item.item.extId, de);
+        }
+    }
+    getStateById(extTestId) {
+        return this.testById.get(extTestId);
+    }
+    toJSON() {
+        return this.persist ? this.serialized : undefined;
+    }
+    toJSONWithMessages() {
+        return this.toJSON();
+    }
+}
+export { HydratedTestResult, LiveTestResult, TaskRawOutput, maxCountPriority, resultItemParents };

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 };