src/vs/workbench/api/common/extHostTestItem.ts
197 LOC · 70 covered · 127 uncovered · 11 ranges · 47 concepts · 1 introducers · 42 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
extHostTerminalService.ts ×109
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import type * as vscode from 'vscode';
7
>
import { URI } from '../../../base/common/uri.js';
8
>
import * as editorRange from '../../../editor/common/core/range.js';
9
>
import { TestId, TestIdPathParts } from '../../contrib/testing/common/testId.js';
10
>
import { createTestItemChildren, ExtHostTestItemEvent, ITestChildrenLike, ITestItemApi, ITestItemChildren, TestItemCollection, TestItemEventOp } from '../../contrib/testing/common/testItemCollection.js';
11
>
import { denamespaceTestTag, ITestItem, ITestItemContext } from '../../contrib/testing/common/testTypes.js';
12
>
import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors.js';
13
>
import { createPrivateApiFor, getPrivateApiFor, IExtHostTestItemApi } from './extHostTestingPrivateApi.js';
14
>
import * as Convert from './extHostTypeConverters.js';
15
>
16
>
const testItemPropAccessor = <K extends keyof vscode.TestItem>(
17
api: IExtHostTestItemApi,
18
defaultValue: vscode.TestItem[K],
19
equals: (a: vscode.TestItem[K], b: vscode.TestItem[K]) => boolean,
20
toUpdate: (newValue: vscode.TestItem[K], oldValue: vscode.TestItem[K]) => ExtHostTestItemEvent,
21
) => {
22
let value = defaultValue;
23
return {
24
enumerable: true,
25
configurable: false,
26
get() {
27
return value;
28
},
29
set(newValue: vscode.TestItem[K]) {
30
if (!equals(value, newValue)) {
31
const oldValue = value;
32
value = newValue;
33
api.listener?.(toUpdate(newValue, oldValue));
34
}
35
},
36
};
37
};
39
>
type WritableProps = Pick<vscode.TestItem, 'range' | 'label' | 'description' | 'sortText' | 'canResolveChildren' | 'busy' | 'error' | 'tags'>;
40
>
41
>
const strictEqualComparator = <T>(a: T, b: T) => a === b;
42
>
43
>
const propComparators: { [K in keyof Required<WritableProps>]: (a: vscode.TestItem[K], b: vscode.TestItem[K]) => boolean } = {
44
>
range: (a, b) => {
45
if (a === b) { return true; }
46
if (!a || !b) { return false; }
47
return a.isEqual(b);
48
},
50
>
description: strictEqualComparator,
51
>
sortText: strictEqualComparator,
52
>
busy: strictEqualComparator,
53
>
error: strictEqualComparator,
54
>
canResolveChildren: strictEqualComparator,
55
>
tags: (a, b) => {
56
if (a.length !== b.length) {
57
return false;
58
}
59
60
if (a.some(t1 => !b.find(t2 => t1.id === t2.id))) {
61
return false;
62
}
63
64
return true;
65
},
67
>
68
>
const evSetProps = <T>(fn: (newValue: T) => Partial<ITestItem>): (newValue: T) => ExtHostTestItemEvent =>
69
v => ({ op: TestItemEventOp.SetProp, update: fn(v) });
71
>
const makePropDescriptors = (api: IExtHostTestItemApi, label: string): { [K in keyof Required<WritableProps>]: PropertyDescriptor } => ({
72
range: (() => {
73
let value: vscode.Range | undefined;
74
const updateProps = evSetProps<vscode.Range | undefined>(r => ({ range: editorRange.Range.lift(Convert.Range.from(r)) }));
75
return {
76
enumerable: true,
77
configurable: false,
78
get() {
79
return value;
80
},
81
set(newValue: vscode.Range | undefined) {
82
api.listener?.({ op: TestItemEventOp.DocumentSynced });
83
if (!propComparators.range(value, newValue)) {
84
value = newValue;
85
api.listener?.(updateProps(newValue));
86
}
87
},
88
};
89
})(),
90
label: testItemPropAccessor<'label'>(api, label, propComparators.label, evSetProps(label => ({ label }))),
91
description: testItemPropAccessor<'description'>(api, undefined, propComparators.description, evSetProps(description => ({ description }))),
92
sortText: testItemPropAccessor<'sortText'>(api, undefined, propComparators.sortText, evSetProps(sortText => ({ sortText }))),
93
canResolveChildren: testItemPropAccessor<'canResolveChildren'>(api, false, propComparators.canResolveChildren, state => ({
94
op: TestItemEventOp.UpdateCanResolveChildren,
95
state,
96
})),
97
busy: testItemPropAccessor<'busy'>(api, false, propComparators.busy, evSetProps(busy => ({ busy }))),
98
error: testItemPropAccessor<'error'>(api, undefined, propComparators.error, evSetProps(error => ({ error: Convert.MarkdownString.fromStrict(error) || null }))),
99
tags: testItemPropAccessor<'tags'>(api, [], propComparators.tags, (current, previous) => ({
100
op: TestItemEventOp.SetTags,
101
new: current.map(Convert.TestTag.from),
102
old: previous.map(Convert.TestTag.from),
103
})),
104
});
106
>
const toItemFromPlain = (item: ITestItem.Serialized): TestItemImpl => {
107
const testId = TestId.fromString(item.extId);
108
const testItem = new TestItemImpl(testId.controllerId, testId.localId, item.label, URI.revive(item.uri) || undefined);
109
testItem.range = Convert.Range.to(item.range || undefined);
110
testItem.description = item.description || undefined;
111
testItem.sortText = item.sortText || undefined;
112
testItem.tags = item.tags.map(t => Convert.TestTag.to({ id: denamespaceTestTag(t).tagId }));
113
return testItem;
114
};
116
>
export const toItemFromContext = (context: ITestItemContext): TestItemImpl => {
117
let node: TestItemImpl | undefined;
118
for (const test of context.tests) {
119
const next = toItemFromPlain(test.item);
120
getPrivateApiFor(next).parent = node;
121
node = next;
122
}
123
124
return node!;
125
};
127
>
export class TestItemImpl implements vscode.TestItem {
128
>
public readonly id!: string;
129
>
public readonly uri!: vscode.Uri | undefined;
130
>
public readonly children!: ITestItemChildren<vscode.TestItem>;
131
>
public readonly parent!: TestItemImpl | undefined;
132
>
133
>
public range!: vscode.Range | undefined;
134
>
public description!: string | undefined;
135
>
public sortText!: string | undefined;
136
>
public label!: string;
137
>
public error!: string | vscode.MarkdownString;
138
>
public busy!: boolean;
139
>
public canResolveChildren!: boolean;
140
>
public tags!: readonly vscode.TestTag[];
141
>
142
>
/**
143
>
* Note that data is deprecated and here for back-compat only
144
>
*/
145
>
constructor(controllerId: string, id: string, label: string, uri: vscode.Uri | undefined) {
146
if (id.includes(TestIdPathParts.Delimiter)) {
147
throw new Error(`Test IDs may not include the ${JSON.stringify(id)} symbol`);
148
}
149
150
const api = createPrivateApiFor(this, controllerId);
151
Object.defineProperties(this, {
152
id: {
153
value: id,
154
enumerable: true,
155
writable: false,
156
},
157
uri: {
158
value: uri,
159
enumerable: true,
160
writable: false,
161
},
162
parent: {
163
enumerable: false,
164
get() {
165
return api.parent instanceof TestItemRootImpl ? undefined : api.parent;
166
},
167
},
168
children: {
169
value: createTestItemChildren(api, getPrivateApiFor, TestItemImpl),
170
enumerable: true,
171
writable: false,
172
},
173
...makePropDescriptors(api, label),
174
});
175
}
177
>
178
>
export class TestItemRootImpl extends TestItemImpl {
179
>
public readonly _isRoot = true;
180
>
181
>
constructor(controllerId: string, label: string) {
182
super(controllerId, controllerId, label, undefined);
183
}
185
>
186
>
export class ExtHostTestItemCollection extends TestItemCollection<TestItemImpl> {
187
>
constructor(controllerId: string, controllerLabel: string, editors: ExtHostDocumentsAndEditors) {
188
super({
189
controllerId,
190
getDocumentVersion: uri => uri && editors.getDocument(uri)?.version,
191
getApiFor: getPrivateApiFor as (impl: TestItemImpl) => ITestItemApi<TestItemImpl>,
192
getChildren: (item) => item.children as ITestChildrenLike<TestItemImpl>,
193
root: new TestItemRootImpl(controllerId, controllerLabel),
194
toITestItem: Convert.TestItem.from,
195
});
196
}