CoCalc -- languagesRegistry.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/editor/test/common/services/languagesRegistry.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 { URI } from '../../../../base/common/uri.js';
8
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
9
import { LanguagesRegistry } from '../../../common/services/languagesRegistry.js';
10

11
suite('LanguagesRegistry', () => {
12

13
	ensureNoDisposablesAreLeakedInTestSuite();
14

15
	test('output language does not have a name', () => {
16
		const registry = new LanguagesRegistry(false);
17

18
		registry._registerLanguages([{
19
			id: 'outputLangId',
20
			extensions: [],
21
			aliases: [],
22
			mimetypes: ['outputLanguageMimeType'],
23
		}]);
24

25
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), []);
26

27
		registry.dispose();
28
	});
29

30
	test('language with alias does have a name', () => {
31
		const registry = new LanguagesRegistry(false);
32

33
		registry._registerLanguages([{
34
			id: 'langId',
35
			extensions: [],
36
			aliases: ['LangName'],
37
			mimetypes: ['bla'],
38
		}]);
39

40
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'LangName', languageId: 'langId' }]);
41
		assert.deepStrictEqual(registry.getLanguageName('langId'), 'LangName');
42

43
		registry.dispose();
44
	});
45

46
	test('language without alias gets a name', () => {
47
		const registry = new LanguagesRegistry(false);
48

49
		registry._registerLanguages([{
50
			id: 'langId',
51
			extensions: [],
52
			mimetypes: ['bla'],
53
		}]);
54

55
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'langId', languageId: 'langId' }]);
56
		assert.deepStrictEqual(registry.getLanguageName('langId'), 'langId');
57

58
		registry.dispose();
59
	});
60

61
	test('bug #4360: f# not shown in status bar', () => {
62
		const registry = new LanguagesRegistry(false);
63

64
		registry._registerLanguages([{
65
			id: 'langId',
66
			extensions: ['.ext1'],
67
			aliases: ['LangName'],
68
			mimetypes: ['bla'],
69
		}]);
70

71
		registry._registerLanguages([{
72
			id: 'langId',
73
			extensions: ['.ext2'],
74
			aliases: [],
75
			mimetypes: ['bla'],
76
		}]);
77

78
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'LangName', languageId: 'langId' }]);
79
		assert.deepStrictEqual(registry.getLanguageName('langId'), 'LangName');
80

81
		registry.dispose();
82
	});
83

84
	test('issue #5278: Extension cannot override language name anymore', () => {
85
		const registry = new LanguagesRegistry(false);
86

87
		registry._registerLanguages([{
88
			id: 'langId',
89
			extensions: ['.ext1'],
90
			aliases: ['LangName'],
91
			mimetypes: ['bla'],
92
		}]);
93

94
		registry._registerLanguages([{
95
			id: 'langId',
96
			extensions: ['.ext2'],
97
			aliases: ['BetterLanguageName'],
98
			mimetypes: ['bla'],
99
		}]);
100

101
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'BetterLanguageName', languageId: 'langId' }]);
102
		assert.deepStrictEqual(registry.getLanguageName('langId'), 'BetterLanguageName');
103

104
		registry.dispose();
105
	});
106

107
	test('mimetypes are generated if necessary', () => {
108
		const registry = new LanguagesRegistry(false);
109

110
		registry._registerLanguages([{
111
			id: 'langId'
112
		}]);
113

114
		assert.deepStrictEqual(registry.getMimeType('langId'), 'text/x-langId');
115

116
		registry.dispose();
117
	});
118

119
	test('first mimetype wins', () => {
120
		const registry = new LanguagesRegistry(false);
121

122
		registry._registerLanguages([{
123
			id: 'langId',
124
			mimetypes: ['text/langId', 'text/langId2']
125
		}]);
126

127
		assert.deepStrictEqual(registry.getMimeType('langId'), 'text/langId');
128

129
		registry.dispose();
130
	});
131

132
	test('first mimetype wins 2', () => {
133
		const registry = new LanguagesRegistry(false);
134

135
		registry._registerLanguages([{
136
			id: 'langId'
137
		}]);
138

139
		registry._registerLanguages([{
140
			id: 'langId',
141
			mimetypes: ['text/langId']
142
		}]);
143

144
		assert.deepStrictEqual(registry.getMimeType('langId'), 'text/x-langId');
145

146
		registry.dispose();
147
	});
148

149
	test('aliases', () => {
150
		const registry = new LanguagesRegistry(false);
151

152
		registry._registerLanguages([{
153
			id: 'a'
154
		}]);
155

156
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'a', languageId: 'a' }]);
157
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a'), 'a');
158
		assert.deepStrictEqual(registry.getLanguageName('a'), 'a');
159

160
		registry._registerLanguages([{
161
			id: 'a',
162
			aliases: ['A1', 'A2']
163
		}]);
164

165
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'A1', languageId: 'a' }]);
166
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a'), 'a');
167
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a1'), 'a');
168
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a2'), 'a');
169
		assert.deepStrictEqual(registry.getLanguageName('a'), 'A1');
170

171
		registry._registerLanguages([{
172
			id: 'a',
173
			aliases: ['A3', 'A4']
174
		}]);
175

176
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'A3', languageId: 'a' }]);
177
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a'), 'a');
178
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a1'), 'a');
179
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a2'), 'a');
180
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a3'), 'a');
181
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a4'), 'a');
182
		assert.deepStrictEqual(registry.getLanguageName('a'), 'A3');
183

184
		registry.dispose();
185
	});
186

187
	test('empty aliases array means no alias', () => {
188
		const registry = new LanguagesRegistry(false);
189

190
		registry._registerLanguages([{
191
			id: 'a'
192
		}]);
193

194
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'a', languageId: 'a' }]);
195
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a'), 'a');
196
		assert.deepStrictEqual(registry.getLanguageName('a'), 'a');
197

198
		registry._registerLanguages([{
199
			id: 'b',
200
			aliases: []
201
		}]);
202

203
		assert.deepStrictEqual(registry.getSortedRegisteredLanguageNames(), [{ languageName: 'a', languageId: 'a' }]);
204
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('a'), 'a');
205
		assert.deepStrictEqual(registry.getLanguageIdByLanguageName('b'), 'b');
206
		assert.deepStrictEqual(registry.getLanguageName('a'), 'a');
207
		assert.deepStrictEqual(registry.getLanguageName('b'), null);
208

209
		registry.dispose();
210
	});
211

212
	test('extensions', () => {
213
		const registry = new LanguagesRegistry(false);
214

215
		registry._registerLanguages([{
216
			id: 'a',
217
			aliases: ['aName'],
218
			extensions: ['aExt']
219
		}]);
220

221
		assert.deepStrictEqual(registry.getExtensions('a'), ['aExt']);
222

223
		registry._registerLanguages([{
224
			id: 'a',
225
			extensions: ['aExt2']
226
		}]);
227

228
		assert.deepStrictEqual(registry.getExtensions('a'), ['aExt', 'aExt2']);
229

230
		registry.dispose();
231
	});
232

233
	test('extensions of primary language registration come first', () => {
234
		const registry = new LanguagesRegistry(false);
235

236
		registry._registerLanguages([{
237
			id: 'a',
238
			extensions: ['aExt3']
239
		}]);
240

241
		assert.deepStrictEqual(registry.getExtensions('a')[0], 'aExt3');
242

243
		registry._registerLanguages([{
244
			id: 'a',
245
			configuration: URI.file('conf.json'),
246
			extensions: ['aExt']
247
		}]);
248

249
		assert.deepStrictEqual(registry.getExtensions('a')[0], 'aExt');
250

251
		registry._registerLanguages([{
252
			id: 'a',
253
			extensions: ['aExt2']
254
		}]);
255

256
		assert.deepStrictEqual(registry.getExtensions('a')[0], 'aExt');
257

258
		registry.dispose();
259
	});
260

261
	test('filenames', () => {
262
		const registry = new LanguagesRegistry(false);
263

264
		registry._registerLanguages([{
265
			id: 'a',
266
			aliases: ['aName'],
267
			filenames: ['aFilename']
268
		}]);
269

270
		assert.deepStrictEqual(registry.getFilenames('a'), ['aFilename']);
271

272
		registry._registerLanguages([{
273
			id: 'a',
274
			filenames: ['aFilename2']
275
		}]);
276

277
		assert.deepStrictEqual(registry.getFilenames('a'), ['aFilename', 'aFilename2']);
278

279
		registry.dispose();
280
	});
281

282
	test('configuration', () => {
283
		const registry = new LanguagesRegistry(false);
284

285
		registry._registerLanguages([{
286
			id: 'a',
287
			aliases: ['aName'],
288
			configuration: URI.file('/path/to/aFilename')
289
		}]);
290

291
		assert.deepStrictEqual(registry.getConfigurationFiles('a'), [URI.file('/path/to/aFilename')]);
292
		assert.deepStrictEqual(registry.getConfigurationFiles('aname'), []);
293
		assert.deepStrictEqual(registry.getConfigurationFiles('aName'), []);
294

295
		registry._registerLanguages([{
296
			id: 'a',
297
			configuration: URI.file('/path/to/aFilename2')
298
		}]);
299

300
		assert.deepStrictEqual(registry.getConfigurationFiles('a'), [URI.file('/path/to/aFilename'), URI.file('/path/to/aFilename2')]);
301
		assert.deepStrictEqual(registry.getConfigurationFiles('aname'), []);
302
		assert.deepStrictEqual(registry.getConfigurationFiles('aName'), []);
303

304
		registry.dispose();
305
	});
306
});
307

308
Product

Resources

Company
