CoCalc -- statusbarModel.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/test/browser/parts/statusbar/statusbarModel.test.ts
⁴⁷⁸⁰ views
1
/*---------------------------------------------------------------------------------------------
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 assert from 'assert';
7
import { IStatusbarViewModelEntry, StatusbarViewModel } from '../../../../browser/parts/statusbar/statusbarModel.js';
8
import { TestStorageService } from '../../../common/workbenchTestServices.js';
9
import { StatusbarAlignment } from '../../../../services/statusbar/browser/statusbar.js';
10
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
11
import { DisposableStore } from '../../../../../base/common/lifecycle.js';
12

13
suite('Workbench status bar model', () => {
14

15
	const disposables = new DisposableStore();
16

17
	teardown(() => {
18
		disposables.clear();
19
	});
20

21
	test('basics', () => {
22
		const container = document.createElement('div');
23
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
24

25
		assert.strictEqual(model.entries.length, 0);
26

27
		const entry1: IStatusbarViewModelEntry = { id: '3', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: 3, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
28
		model.add(entry1);
29
		const entry2: IStatusbarViewModelEntry = { id: '2', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
30
		model.add(entry2);
31
		const entry3: IStatusbarViewModelEntry = { id: '1', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
32
		model.add(entry3);
33
		const entry4: IStatusbarViewModelEntry = { id: '1-right', alignment: StatusbarAlignment.RIGHT, name: '1-right', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
34
		model.add(entry4);
35

36
		assert.strictEqual(model.entries.length, 4);
37

38
		const leftEntries = model.getEntries(StatusbarAlignment.LEFT);
39
		assert.strictEqual(leftEntries.length, 3);
40
		assert.strictEqual(model.getEntries(StatusbarAlignment.RIGHT).length, 1);
41

42
		assert.strictEqual(leftEntries[0].id, '3');
43
		assert.strictEqual(leftEntries[1].id, '2');
44
		assert.strictEqual(leftEntries[2].id, '1');
45

46
		const entries = model.entries;
47
		assert.strictEqual(entries[0].id, '3');
48
		assert.strictEqual(entries[1].id, '2');
49
		assert.strictEqual(entries[2].id, '1');
50
		assert.strictEqual(entries[3].id, '1-right');
51

52
		assert.ok(model.findEntry(container));
53

54
		let didChangeEntryVisibility: { id: string; visible: boolean } = { id: '', visible: false };
55
		disposables.add(model.onDidChangeEntryVisibility(e => {
56
			didChangeEntryVisibility = e;
57
		}));
58

59
		assert.strictEqual(model.isHidden('1'), false);
60
		model.hide('1');
61
		assert.strictEqual(didChangeEntryVisibility.id, '1');
62
		assert.strictEqual(didChangeEntryVisibility.visible, false);
63
		assert.strictEqual(model.isHidden('1'), true);
64

65
		didChangeEntryVisibility = { id: '', visible: false };
66

67
		model.show('1');
68
		assert.strictEqual(didChangeEntryVisibility.id, '1');
69
		assert.strictEqual(didChangeEntryVisibility.visible, true);
70
		assert.strictEqual(model.isHidden('1'), false);
71

72
		model.remove(entry1);
73
		model.remove(entry4);
74
		assert.strictEqual(model.entries.length, 2);
75

76
		model.remove(entry2);
77
		model.remove(entry3);
78
		assert.strictEqual(model.entries.length, 0);
79
	});
80

81
	test('sorting with infinity and max number', () => {
82
		const container = document.createElement('div');
83
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
84

85
		assert.strictEqual(model.entries.length, 0);
86

87
		model.add({ id: '3', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: Number.MAX_VALUE, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
88
		model.add({ id: '2', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: Number.MIN_VALUE, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
89
		model.add({ id: '1', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: Number.POSITIVE_INFINITY, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
90
		model.add({ id: '0', alignment: StatusbarAlignment.LEFT, name: '0', priority: { primary: Number.NEGATIVE_INFINITY, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
91
		model.add({ id: '4', alignment: StatusbarAlignment.LEFT, name: '4', priority: { primary: 100, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
92

93
		const entries = model.entries;
94
		assert.strictEqual(entries[0].id, '1');
95
		assert.strictEqual(entries[1].id, '3');
96
		assert.strictEqual(entries[2].id, '4');
97
		assert.strictEqual(entries[3].id, '2');
98
		assert.strictEqual(entries[4].id, '0');
99
	});
100

101
	test('secondary priority used when primary is same', () => {
102
		const container = document.createElement('div');
103
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
104

105
		assert.strictEqual(model.entries.length, 0);
106

107
		model.add({ id: '1', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
108
		model.add({ id: '2', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 1, secondary: 2 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
109
		model.add({ id: '3', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: 1, secondary: 3 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
110

111
		const entries = model.entries;
112
		assert.strictEqual(entries[0].id, '3');
113
		assert.strictEqual(entries[1].id, '2');
114
		assert.strictEqual(entries[2].id, '1');
115
	});
116

117
	test('insertion order preserved when priorites are the same', () => {
118
		const container = document.createElement('div');
119
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
120

121
		assert.strictEqual(model.entries.length, 0);
122

123
		model.add({ id: '1', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
124
		model.add({ id: '2', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
125
		model.add({ id: '3', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
126

127
		const entries = model.entries;
128
		assert.strictEqual(entries[0].id, '1');
129
		assert.strictEqual(entries[1].id, '2');
130
		assert.strictEqual(entries[2].id, '3');
131
	});
132

133
	test('entry with reference to other entry (existing)', () => {
134
		const container = document.createElement('div');
135
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
136

137
		// Existing reference, Alignment: left
138
		model.add({ id: 'a', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
139
		model.add({ id: 'b', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
140

141
		let entry = { id: 'c', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: { location: { id: 'a', priority: 2 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
142
		model.add(entry);
143

144
		let entries = model.entries;
145
		assert.strictEqual(entries.length, 3);
146
		assert.strictEqual(entries[0].id, 'c');
147
		assert.strictEqual(entries[1].id, 'a');
148
		assert.strictEqual(entries[2].id, 'b');
149

150
		model.remove(entry);
151

152
		// Existing reference, Alignment: right
153
		entry = { id: 'c', alignment: StatusbarAlignment.RIGHT, name: '3', priority: { primary: { location: { id: 'a', priority: 2 }, alignment: StatusbarAlignment.RIGHT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
154
		model.add(entry);
155

156
		entries = model.entries;
157
		assert.strictEqual(entries.length, 3);
158
		assert.strictEqual(entries[0].id, 'a');
159
		assert.strictEqual(entries[1].id, 'c');
160
		assert.strictEqual(entries[2].id, 'b');
161
	});
162

163
	test('entry with reference to other entry (nonexistent)', () => {
164
		const container = document.createElement('div');
165
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
166

167
		// Nonexistent reference, Alignment: left
168
		model.add({ id: 'a', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
169
		model.add({ id: 'b', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
170

171
		let entry = { id: 'c', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: { location: { id: 'not-existing', priority: 0 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
172
		model.add(entry);
173

174
		let entries = model.entries;
175
		assert.strictEqual(entries.length, 3);
176
		assert.strictEqual(entries[0].id, 'a');
177
		assert.strictEqual(entries[1].id, 'b');
178
		assert.strictEqual(entries[2].id, 'c');
179

180
		model.remove(entry);
181

182
		// Nonexistent reference, Alignment: different fallback priority
183
		entry = { id: 'c', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: { location: { id: 'not-existing', priority: 3 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
184
		model.add(entry);
185

186
		entries = model.entries;
187
		assert.strictEqual(entries.length, 3);
188
		assert.strictEqual(entries[0].id, 'c');
189
		assert.strictEqual(entries[1].id, 'a');
190
		assert.strictEqual(entries[2].id, 'b');
191

192
		model.remove(entry);
193

194
		// Nonexistent reference, Alignment: right
195
		entry = { id: 'c', alignment: StatusbarAlignment.RIGHT, name: '3', priority: { primary: { location: { id: 'not-existing', priority: 3 }, alignment: StatusbarAlignment.RIGHT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
196
		model.add(entry);
197

198
		entries = model.entries;
199
		assert.strictEqual(entries.length, 3);
200
		assert.strictEqual(entries[0].id, 'a');
201
		assert.strictEqual(entries[1].id, 'b');
202
		assert.strictEqual(entries[2].id, 'c');
203
	});
204

205
	test('entry with reference to other entry resorts based on other entry being there or not', () => {
206
		const container = document.createElement('div');
207
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
208

209
		model.add({ id: 'a', alignment: StatusbarAlignment.LEFT, name: '1', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
210
		model.add({ id: 'b', alignment: StatusbarAlignment.LEFT, name: '2', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
211
		model.add({ id: 'c', alignment: StatusbarAlignment.LEFT, name: '3', priority: { primary: { location: { id: 'not-existing', priority: 0 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
212

213
		let entries = model.entries;
214
		assert.strictEqual(entries.length, 3);
215
		assert.strictEqual(entries[0].id, 'a');
216
		assert.strictEqual(entries[1].id, 'b');
217
		assert.strictEqual(entries[2].id, 'c');
218

219
		const entry = { id: 'not-existing', alignment: StatusbarAlignment.LEFT, name: 'not-existing', priority: { primary: 3, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
220
		model.add(entry);
221

222
		entries = model.entries;
223
		assert.strictEqual(entries.length, 4);
224
		assert.strictEqual(entries[0].id, 'c');
225
		assert.strictEqual(entries[1].id, 'not-existing');
226
		assert.strictEqual(entries[2].id, 'a');
227
		assert.strictEqual(entries[3].id, 'b');
228

229
		model.remove(entry);
230

231
		entries = model.entries;
232
		assert.strictEqual(entries.length, 3);
233
		assert.strictEqual(entries[0].id, 'a');
234
		assert.strictEqual(entries[1].id, 'b');
235
		assert.strictEqual(entries[2].id, 'c');
236
	});
237

238
	test('entry with reference to other entry but different alignment does not explode', () => {
239
		const container = document.createElement('div');
240
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
241

242
		model.add({ id: '1-left', alignment: StatusbarAlignment.LEFT, name: '1-left', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
243
		model.add({ id: '2-left', alignment: StatusbarAlignment.LEFT, name: '2-left', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
244

245
		model.add({ id: '1-right', alignment: StatusbarAlignment.RIGHT, name: '1-right', priority: { primary: 2, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
246
		model.add({ id: '2-right', alignment: StatusbarAlignment.RIGHT, name: '2-right', priority: { primary: 1, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
247

248
		assert.strictEqual(model.getEntries(StatusbarAlignment.LEFT).length, 2);
249
		assert.strictEqual(model.getEntries(StatusbarAlignment.RIGHT).length, 2);
250

251
		const relativeEntryLeft = { id: 'relative', alignment: StatusbarAlignment.LEFT, name: 'relative', priority: { primary: { location: { id: '1-right', priority: 2 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
252
		model.add(relativeEntryLeft);
253

254
		assert.strictEqual(model.getEntries(StatusbarAlignment.LEFT).length, 3);
255
		assert.strictEqual(model.getEntries(StatusbarAlignment.LEFT)[2], relativeEntryLeft);
256
		assert.strictEqual(model.getEntries(StatusbarAlignment.RIGHT).length, 2);
257

258
		model.remove(relativeEntryLeft);
259

260
		const relativeEntryRight = { id: 'relative', alignment: StatusbarAlignment.RIGHT, name: 'relative', priority: { primary: { location: { id: '1-right', priority: 2 }, alignment: StatusbarAlignment.LEFT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined };
261
		model.add(relativeEntryRight);
262

263
		assert.strictEqual(model.getEntries(StatusbarAlignment.LEFT).length, 2);
264
		assert.strictEqual(model.getEntries(StatusbarAlignment.RIGHT).length, 3);
265
	});
266

267
	test('entry with reference to other entry respects secondary sorting (existent)', () => {
268
		const container = document.createElement('div');
269
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
270

271
		model.add({ id: 'ref', alignment: StatusbarAlignment.LEFT, name: 'ref', priority: { primary: 0, secondary: 0 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
272
		model.add({ id: 'entry2', alignment: StatusbarAlignment.RIGHT, name: '2', priority: { primary: { location: { id: 'ref', priority: 0 }, alignment: StatusbarAlignment.RIGHT }, secondary: 2 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
273
		model.add({ id: 'entry1', alignment: StatusbarAlignment.RIGHT, name: '1', priority: { primary: { location: { id: 'ref', priority: 0 }, alignment: StatusbarAlignment.RIGHT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
274
		model.add({ id: 'entry3', alignment: StatusbarAlignment.RIGHT, name: '3', priority: { primary: { location: { id: 'ref', priority: 0 }, alignment: StatusbarAlignment.RIGHT }, secondary: 3 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
275

276
		const entries = model.entries;
277
		assert.strictEqual(entries.length, 4);
278
		assert.strictEqual(entries[0].id, 'ref');
279
		assert.strictEqual(entries[1].id, 'entry3');
280
		assert.strictEqual(entries[2].id, 'entry2');
281
		assert.strictEqual(entries[3].id, 'entry1');
282
	});
283

284
	test('entry with reference to other entry respects secondary sorting (nonexistent)', () => {
285
		const container = document.createElement('div');
286
		const model = disposables.add(new StatusbarViewModel(disposables.add(new TestStorageService())));
287

288
		model.add({ id: 'entry2', alignment: StatusbarAlignment.RIGHT, name: '2', priority: { primary: { location: { id: 'ref', priority: 1 }, alignment: StatusbarAlignment.RIGHT }, secondary: 2 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
289
		model.add({ id: 'entry1', alignment: StatusbarAlignment.RIGHT, name: '1', priority: { primary: { location: { id: 'ref', priority: 1 }, alignment: StatusbarAlignment.RIGHT }, secondary: 1 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
290
		model.add({ id: 'entry3', alignment: StatusbarAlignment.RIGHT, name: '3', priority: { primary: { location: { id: 'ref', priority: 1 }, alignment: StatusbarAlignment.RIGHT }, secondary: 3 }, container, labelContainer: container, hasCommand: false, extensionId: undefined });
291

292
		const entries = model.entries;
293
		assert.strictEqual(entries.length, 3);
294
		assert.strictEqual(entries[0].id, 'entry3');
295
		assert.strictEqual(entries[1].id, 'entry2');
296
		assert.strictEqual(entries[2].id, 'entry1');
297
	});
298

299
	ensureNoDisposablesAreLeakedInTestSuite();
300
});
301

302
Product

Resources

Company
