@codingame/monaco-vscode-api 5.2.0 → 6.0.0

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

@@ -1,3 +1,4 @@
+import { assert } from '../../../../base/common/assert.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { deepClone } from '../../../../base/common/objects.js';
@@ -7,9 +8,11 @@ import '../../../../base/common/observableInternal/autorun.js';
 import { observableSignal } from '../../../../base/common/observableInternal/utils.js';
 import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
 import { URI } from '../../../../base/common/uri.js';
+import { IFileCoverage } from './testTypes.js';
 let incId = 0;
 class TestCoverage {
-    constructor(fromTaskId, uriIdentityService, accessor) {
+    constructor(result, fromTaskId, uriIdentityService, accessor) {
+        this.result = result;
         this.fromTaskId = fromTaskId;
         this.uriIdentityService = uriIdentityService;
         this.accessor = accessor;
@@ -17,10 +20,11 @@ class TestCoverage {
         this.didAddCoverage = observableSignal(this);
         this.tree = ( new WellDefinedPrefixTree());
         this.associatedData = ( new Map());
+        this.perTestCoverageIDs = ( new Set());
     }
-    append(rawCoverage, tx) {
-        const coverage = ( new FileCoverage(rawCoverage, this.accessor));
+    append(coverage, tx) {
         const previous = this.getComputedForUri(coverage.uri);
+        const result = this.result;
         const applyDelta = (kind, node) => {
             if (!node[kind]) {
                 if (coverage[kind]) {
@@ -34,29 +38,76 @@ class TestCoverage {
         };
         const canonical = [...this.treePathForUri(coverage.uri,  true)];
         const chain = [];
-        this.tree.insert(this.treePathForUri(coverage.uri,  false), coverage, node => {
+        const isPerTestCoverage = !!coverage.testId;
+        if (coverage.testId) {
+            this.perTestCoverageIDs.add(( coverage.testId.toString()));
+        }
+        this.tree.mutatePath(this.treePathForUri(coverage.uri,  false), node => {
             chain.push(node);
             if (chain.length === canonical.length) {
-                node.value = coverage;
-            }
-            else if (!node.value) {
-                const intermediate = deepClone(rawCoverage);
-                intermediate.id = String(incId++);
-                intermediate.uri = this.treePathToUri(canonical.slice(0, chain.length));
-                node.value = ( new ComputedFileCoverage(intermediate));
+                if (isPerTestCoverage) {
+                    const v = node.value ??= ( new FileCoverage(IFileCoverage.empty(String(incId++), coverage.uri), result, this.accessor));
+                    assert(v instanceof FileCoverage, 'coverage is unexpectedly computed');
+                    v.perTestData ??= ( new Map());
+                    const perTest = ( new FileCoverage(coverage, result, this.accessor));
+                    perTest.isForTest = { id: coverage.testId, parent: v };
+                    v.perTestData.set(( coverage.testId.toString()), perTest);
+                    this.fileCoverage.set(coverage.uri, v);
+                }
+                else if (node.value) {
+                    const v = node.value;
+                    v.id = coverage.id;
+                    v.statement = coverage.statement;
+                    v.branch = coverage.branch;
+                    v.declaration = coverage.declaration;
+                }
+                else {
+                    const v = node.value = ( new FileCoverage(coverage, result, this.accessor));
+                    this.fileCoverage.set(coverage.uri, v);
+                }
             }
-            else {
-                applyDelta('statement', node.value);
-                applyDelta('branch', node.value);
-                applyDelta('declaration', node.value);
-                node.value.didChange.trigger(tx);
+            else if (!isPerTestCoverage) {
+                if (!node.value) {
+                    const intermediate = deepClone(coverage);
+                    intermediate.id = String(incId++);
+                    intermediate.uri = this.treePathToUri(canonical.slice(0, chain.length));
+                    node.value = ( new ComputedFileCoverage(intermediate, result));
+                }
+                else {
+                    applyDelta('statement', node.value);
+                    applyDelta('branch', node.value);
+                    applyDelta('declaration', node.value);
+                    node.value.didChange.trigger(tx);
+                }
             }
         });
-        this.fileCoverage.set(coverage.uri, coverage);
-        if (chain) {
+        if (chain && !isPerTestCoverage) {
             this.didAddCoverage.trigger(tx, chain);
         }
     }
+    filterTreeForTest(testId) {
+        const tree = ( new WellDefinedPrefixTree());
+        for (const node of ( this.tree.values())) {
+            if (node instanceof FileCoverage) {
+                const fileData = node.perTestData?.get(( testId.toString()));
+                if (!fileData) {
+                    continue;
+                }
+                const canonical = [...this.treePathForUri(fileData.uri,  true)];
+                const chain = [];
+                tree.mutatePath(this.treePathForUri(fileData.uri,  false), node => {
+                    chain.push(node);
+                    if (chain.length === canonical.length) {
+                        node.value = fileData;
+                    }
+                    else {
+                        node.value ??= ( new BypassedFileCoverage(this.treePathToUri(canonical.slice(0, chain.length)), fileData.fromResult));
+                    }
+                });
+            }
+        }
+        return tree;
+    }
     getAllFiles() {
         return this.fileCoverage;
     }
@@ -93,7 +144,8 @@ class AbstractFileCoverage {
     get tpc() {
         return getTotalCoveragePercent(this.statement, this.branch, this.declaration);
     }
-    constructor(coverage) {
+    constructor(coverage, fromResult) {
+        this.fromResult = fromResult;
         this.didChange = observableSignal(this);
         this.id = coverage.id;
         this.uri = coverage.uri;
@@ -104,12 +156,17 @@ class AbstractFileCoverage {
 }
 class ComputedFileCoverage extends AbstractFileCoverage {
 }
+class BypassedFileCoverage extends ComputedFileCoverage {
+    constructor(uri, result) {
+        super({ id: String(incId++), uri, statement: { covered: 0, total: 0 } }, result);
+    }
+}
 class FileCoverage extends AbstractFileCoverage {
     get hasSynchronousDetails() {
         return this._details instanceof Array || this.resolved;
     }
-    constructor(coverage, accessor) {
-        super(coverage);
+    constructor(coverage, fromResult, accessor) {
+        super(coverage, fromResult);
         this.accessor = accessor;
     }
     async details(token = CancellationToken.None) {
@@ -125,4 +182,4 @@ class FileCoverage extends AbstractFileCoverage {
         }
     }
 }
-export { AbstractFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage, getTotalCoveragePercent };
+export { AbstractFileCoverage, BypassedFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage, getTotalCoveragePercent };

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

@@ -1,3 +1,14 @@
+var TestIdPathParts;
+( (function(TestIdPathParts) {
+    TestIdPathParts["Delimiter"] = "\0";
+})(TestIdPathParts || (TestIdPathParts = {})));
+var TestPosition;
+( (function(TestPosition) {
+    TestPosition[TestPosition["IsSame"] = 0] = "IsSame";
+    TestPosition[TestPosition["Disconnected"] = 1] = "Disconnected";
+    TestPosition[TestPosition["IsChild"] = 2] = "IsChild";
+    TestPosition[TestPosition["IsParent"] = 3] = "IsParent";
+})(TestPosition || (TestPosition = {})));
 class TestId {
     static fromExtHostTestItem(item, rootId, parent = item.parent) {
         if (item._isRoot) {
@@ -11,43 +22,60 @@ class TestId {
         return ( new TestId(path.reverse()));
     }
     static isRoot(idString) {
-        return !idString.includes("\0" );
+        return !idString.includes(TestIdPathParts.Delimiter);
     }
     static root(idString) {
-        const idx = idString.indexOf("\0" );
+        const idx = idString.indexOf(TestIdPathParts.Delimiter);
         return idx === -1 ? idString : idString.slice(0, idx);
     }
     static fromString(idString) {
-        return ( new TestId(idString.split("\0" )));
+        return ( new TestId(idString.split(TestIdPathParts.Delimiter)));
     }
     static join(base, b) {
         return ( new TestId([...base.path, b]));
     }
     static joinToString(base, b) {
-        return ( base.toString()) + "\0"  + b;
+        return ( base.toString()) + TestIdPathParts.Delimiter + b;
     }
     static parentId(idString) {
-        const idx = idString.lastIndexOf("\0" );
+        const idx = idString.lastIndexOf(TestIdPathParts.Delimiter);
         return idx === -1 ? undefined : idString.slice(0, idx);
     }
     static localId(idString) {
-        const idx = idString.lastIndexOf("\0" );
-        return idx === -1 ? idString : idString.slice(idx + "\0" .length);
+        const idx = idString.lastIndexOf(TestIdPathParts.Delimiter);
+        return idx === -1 ? idString : idString.slice(idx + TestIdPathParts.Delimiter.length);
     }
     static isChild(maybeParent, maybeChild) {
-        return maybeChild.startsWith(maybeParent) && maybeChild[maybeParent.length] === "\0" ;
+        return maybeChild.startsWith(maybeParent) && maybeChild[maybeParent.length] === TestIdPathParts.Delimiter;
     }
     static compare(a, b) {
         if (a === b) {
-            return 0 ;
+            return TestPosition.IsSame;
         }
         if (TestId.isChild(a, b)) {
-            return 2 ;
+            return TestPosition.IsChild;
         }
         if (TestId.isChild(b, a)) {
-            return 3 ;
+            return TestPosition.IsParent;
         }
-        return 1 ;
+        return TestPosition.Disconnected;
+    }
+    static getLengthOfCommonPrefix(length, getId) {
+        if (length === 0) {
+            return 0;
+        }
+        let commonPrefix = 0;
+        while (commonPrefix < length - 1) {
+            for (let i = 1; i < length; i++) {
+                const a = getId(i - 1);
+                const b = getId(i);
+                if (a.path[commonPrefix] !== b.path[commonPrefix]) {
+                    return commonPrefix;
+                }
+            }
+            commonPrefix++;
+        }
+        return commonPrefix;
     }
     constructor(path, viewEnd = path.length) {
         this.path = path;
@@ -87,16 +115,16 @@ class TestId {
         }
         for (let i = 0; i < other.viewEnd && i < this.viewEnd; i++) {
             if (other.path[i] !== this.path[i]) {
-                return 1 ;
+                return TestPosition.Disconnected;
             }
         }
         if (other.viewEnd > this.viewEnd) {
-            return 2 ;
+            return TestPosition.IsChild;
         }
         if (other.viewEnd < this.viewEnd) {
-            return 3 ;
+            return TestPosition.IsParent;
         }
-        return 0 ;
+        return TestPosition.IsSame;
     }
     toJSON() {
         return ( this.toString());
@@ -105,11 +133,11 @@ class TestId {
         if (!this.stringifed) {
             this.stringifed = this.path[0];
             for (let i = 1; i < this.viewEnd; i++) {
-                this.stringifed += "\0" ;
+                this.stringifed += TestIdPathParts.Delimiter;
                 this.stringifed += this.path[i];
             }
         }
         return this.stringifed;
     }
 }
-export { TestId };
+export { TestId, TestIdPathParts, TestPosition };

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

@@ -2,8 +2,18 @@ import { RunOnceScheduler, Barrier, isThenable } from '../../../../base/common/a
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { assertNever } from '../../../../base/common/assert.js';
-import { applyTestItemUpdate, namespaceTestTag } from './testTypes.js';
+import { TestDiffOpType, applyTestItemUpdate, TestItemExpandState, namespaceTestTag } from './testTypes.js';
 import { TestId } from './testId.js';
+var TestItemEventOp;
+( (function(TestItemEventOp) {
+    TestItemEventOp[TestItemEventOp["Upsert"] = 0] = "Upsert";
+    TestItemEventOp[TestItemEventOp["SetTags"] = 1] = "SetTags";
+    TestItemEventOp[TestItemEventOp["UpdateCanResolveChildren"] = 2] = "UpdateCanResolveChildren";
+    TestItemEventOp[TestItemEventOp["RemoveChild"] = 3] = "RemoveChild";
+    TestItemEventOp[TestItemEventOp["SetProp"] = 4] = "SetProp";
+    TestItemEventOp[TestItemEventOp["Bulk"] = 5] = "Bulk";
+    TestItemEventOp[TestItemEventOp["DocumentSynced"] = 6] = "DocumentSynced";
+})(TestItemEventOp || (TestItemEventOp = {})));
 const strictEqualComparator = (a, b) => a === b;
 const diffableProps = {
     range: (a, b) => {
@@ -77,23 +87,23 @@ class TestItemCollection extends Disposable {
     }
     pushDiff(diff) {
         switch (diff.op) {
-            case 2 : {
+            case TestDiffOpType.DocumentSynced: {
                 for (const existing of this.diff) {
-                    if (existing.op === 2  && existing.uri === diff.uri) {
+                    if (existing.op === TestDiffOpType.DocumentSynced && existing.uri === diff.uri) {
                         existing.docv = diff.docv;
                         return;
                     }
                 }
                 break;
             }
-            case 1 : {
+            case TestDiffOpType.Update: {
                 const last = this.diff[this.diff.length - 1];
                 if (last) {
-                    if (last.op === 1  && last.item.extId === diff.item.extId) {
+                    if (last.op === TestDiffOpType.Update && last.item.extId === diff.item.extId) {
                         applyTestItemUpdate(last.item, diff.item);
                         return;
                     }
-                    if (last.op === 0  && last.item.item.extId === diff.item.extId) {
+                    if (last.op === TestDiffOpType.Add && last.item.item.extId === diff.item.extId) {
                         applyTestItemUpdate(last.item, diff.item);
                         return;
                     }
@@ -114,13 +124,13 @@ class TestItemCollection extends Disposable {
         if (internal.expandLevels === undefined || levels > internal.expandLevels) {
             internal.expandLevels = levels;
         }
-        if (internal.expand === 1 ) {
+        if (internal.expand === TestItemExpandState.Expandable) {
             const r = this.resolveChildren(internal);
             return !r.isOpen()
                 ? r.wait().then(() => this.expandChildren(internal, levels - 1))
                 : this.expandChildren(internal, levels - 1);
         }
-        else if (internal.expand === 3 ) {
+        else if (internal.expand === TestItemExpandState.Expanded) {
             return internal.resolveBarrier?.isOpen() === false
                 ? internal.resolveBarrier.wait().then(() => this.expandChildren(internal, levels - 1))
                 : this.expandChildren(internal, levels - 1);
@@ -136,33 +146,33 @@ class TestItemCollection extends Disposable {
     }
     onTestItemEvent(internal, evt) {
         switch (evt.op) {
-            case 3 :
+            case TestItemEventOp.RemoveChild:
                 this.removeItem(TestId.joinToString(internal.fullId, evt.id));
                 break;
-            case 0 :
+            case TestItemEventOp.Upsert:
                 this.upsertItem(evt.item, internal);
                 break;
-            case 5 :
+            case TestItemEventOp.Bulk:
                 for (const op of evt.ops) {
                     this.onTestItemEvent(internal, op);
                 }
                 break;
-            case 1 :
+            case TestItemEventOp.SetTags:
                 this.diffTagRefs(evt.new, evt.old, ( internal.fullId.toString()));
                 break;
-            case 2 :
+            case TestItemEventOp.UpdateCanResolveChildren:
                 this.updateExpandability(internal);
                 break;
-            case 4 :
+            case TestItemEventOp.SetProp:
                 this.pushDiff({
-                    op: 1 ,
+                    op: TestDiffOpType.Update,
                     item: {
                         extId: ( internal.fullId.toString()),
                         item: evt.update,
                     }
                 });
                 break;
-            case 6 :
+            case TestItemEventOp.DocumentSynced:
                 this.documentSynced(internal.actual.uri);
                 break;
             default:
@@ -172,7 +182,7 @@ class TestItemCollection extends Disposable {
     documentSynced(uri) {
         if (uri) {
             this.pushDiff({
-                op: 2 ,
+                op: TestDiffOpType.DocumentSynced,
                 uri,
                 docv: this.options.getDocumentVersion(uri)
             });
@@ -190,13 +200,13 @@ class TestItemCollection extends Disposable {
                 fullId,
                 actual,
                 expandLevels: parent?.expandLevels  ? parent.expandLevels - 1 : undefined,
-                expand: 0 ,
+                expand: TestItemExpandState.NotExpandable,
             };
             actual.tags.forEach(this.incrementTagRefs, this);
             this.tree.set(( internal.fullId.toString()), internal);
             this.setItemParent(actual, parent);
             this.pushDiff({
-                op: 0 ,
+                op: TestDiffOpType.Add,
                 item: {
                     controllerId: this.options.controllerId,
                     expand: internal.expand,
@@ -220,13 +230,13 @@ class TestItemCollection extends Disposable {
         this.options.getApiFor(oldActual).listener = undefined;
         internal.actual = actual;
         internal.resolveBarrier = undefined;
-        internal.expand = 0 ;
+        internal.expand = TestItemExpandState.NotExpandable;
         if (update) {
             if (update.hasOwnProperty('tags')) {
                 this.diffTagRefs(actual.tags, oldActual.tags, ( fullId.toString()));
                 delete update.tags;
             }
-            this.onTestItemEvent(internal, { op: 4 , update });
+            this.onTestItemEvent(internal, { op: TestItemEventOp.SetProp, update });
         }
         this.connectItemAndChildren(actual, internal, parent);
         for (const [_, child] of oldChildren) {
@@ -237,7 +247,7 @@ class TestItemCollection extends Disposable {
         const expandLevels = internal.expandLevels;
         if (expandLevels !== undefined) {
             queueMicrotask(() => {
-                if (internal.expand === 1 ) {
+                if (internal.expand === TestItemExpandState.Expandable) {
                     internal.expandLevels = undefined;
                     this.expand(( fullId.toString()), expandLevels);
                 }
@@ -253,7 +263,7 @@ class TestItemCollection extends Disposable {
             }
         }
         this.pushDiff({
-            op: 1 ,
+            op: TestDiffOpType.Update,
             item: { extId, item: { tags: ( newTags.map(v => namespaceTestTag(this.options.controllerId, v.id))) } }
         });
         toDelete.forEach(this.decrementTagRefs, this);
@@ -266,7 +276,7 @@ class TestItemCollection extends Disposable {
         else {
             this.tags.set(tag.id, { refCount: 1 });
             this.pushDiff({
-                op: 6 , tag: {
+                op: TestDiffOpType.AddTag, tag: {
                     id: namespaceTestTag(this.options.controllerId, tag.id),
                 }
             });
@@ -276,7 +286,7 @@ class TestItemCollection extends Disposable {
         const existing = this.tags.get(tagId);
         if (existing && !--existing.refCount) {
             this.tags.delete(tagId);
-            this.pushDiff({ op: 7 , id: namespaceTestTag(this.options.controllerId, tagId) });
+            this.pushDiff({ op: TestDiffOpType.RemoveTag, id: namespaceTestTag(this.options.controllerId, tagId) });
         }
     }
     setItemParent(actual, parent) {
@@ -298,24 +308,24 @@ class TestItemCollection extends Disposable {
     updateExpandability(internal) {
         let newState;
         if (!this._resolveHandler) {
-            newState = 0 ;
+            newState = TestItemExpandState.NotExpandable;
         }
         else if (internal.resolveBarrier) {
             newState = internal.resolveBarrier.isOpen()
-                ? 3
-                : 2 ;
+                ? TestItemExpandState.Expanded
+                : TestItemExpandState.BusyExpanding;
         }
         else {
             newState = internal.actual.canResolveChildren
-                ? 1
-                : 0 ;
+                ? TestItemExpandState.Expandable
+                : TestItemExpandState.NotExpandable;
         }
         if (newState === internal.expand) {
             return;
         }
         internal.expand = newState;
-        this.pushDiff({ op: 1 , item: { extId: ( internal.fullId.toString()), expand: newState } });
-        if (newState === 1  && internal.expandLevels !== undefined) {
+        this.pushDiff({ op: TestDiffOpType.Update, item: { extId: ( internal.fullId.toString()), expand: newState } });
+        if (newState === TestItemExpandState.Expandable && internal.expandLevels !== undefined) {
             this.resolveChildren(internal);
         }
     }
@@ -343,7 +353,7 @@ class TestItemCollection extends Disposable {
             b.open();
             return b;
         }
-        internal.expand = 2 ;
+        internal.expand = TestItemExpandState.BusyExpanding;
         this.pushExpandStateUpdate(internal);
         const barrier = internal.resolveBarrier = ( new Barrier());
         const applyError = (err) => {
@@ -369,14 +379,14 @@ class TestItemCollection extends Disposable {
         return internal.resolveBarrier;
     }
     pushExpandStateUpdate(internal) {
-        this.pushDiff({ op: 1 , item: { extId: ( internal.fullId.toString()), expand: internal.expand } });
+        this.pushDiff({ op: TestDiffOpType.Update, item: { extId: ( internal.fullId.toString()), expand: internal.expand } });
     }
     removeItem(childId) {
         const childItem = this.tree.get(childId);
         if (!childItem) {
             throw ( new Error('attempting to remove non-existent child'));
         }
-        this.pushDiff({ op: 3 , itemId: childId });
+        this.pushDiff({ op: TestDiffOpType.Remove, itemId: childId });
         const queue = [childItem];
         while (queue.length) {
             const item = queue.pop();
@@ -432,7 +442,7 @@ const createTestItemChildren = (api, getApi, checkCtor) => {
         replace(items) {
             const newMapped = ( new Map());
             const toDelete = ( new Set(( mapped.keys())));
-            const bulk = { op: 5 , ops: [] };
+            const bulk = { op: TestItemEventOp.Bulk, ops: [] };
             for (const item of items) {
                 if (!(item instanceof checkCtor)) {
                     throw ( new InvalidTestItemError(item.id));
@@ -446,10 +456,10 @@ const createTestItemChildren = (api, getApi, checkCtor) => {
                 }
                 newMapped.set(item.id, item);
                 toDelete.delete(item.id);
-                bulk.ops.push({ op: 0 , item });
+                bulk.ops.push({ op: TestItemEventOp.Upsert, item });
             }
             for (const id of ( toDelete.keys())) {
-                bulk.ops.push({ op: 3 , id });
+                bulk.ops.push({ op: TestItemEventOp.RemoveChild, id });
             }
             api.listener?.(bulk);
             mapped = newMapped;
@@ -459,11 +469,11 @@ const createTestItemChildren = (api, getApi, checkCtor) => {
                 throw ( new InvalidTestItemError(item.id));
             }
             mapped.set(item.id, item);
-            api.listener?.({ op: 0 , item });
+            api.listener?.({ op: TestItemEventOp.Upsert, item });
         },
         delete(id) {
             if (mapped.delete(id)) {
-                api.listener?.({ op: 3 , id });
+                api.listener?.({ op: TestItemEventOp.RemoveChild, id });
             }
         },
         get(itemId) {
@@ -474,4 +484,4 @@ const createTestItemChildren = (api, getApi, checkCtor) => {
         },
     };
 };
-export { DuplicateTestItemError, InvalidTestItemError, MixedTestItemController, TestItemCollection, createTestItemChildren };
+export { DuplicateTestItemError, InvalidTestItemError, MixedTestItemController, TestItemCollection, TestItemEventOp, createTestItemChildren };