CoCalc -- macLinuxKeyboardMapper.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/services/keybinding/test/node/macLinuxKeyboardMapper.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 { KeyChord, KeyCode, KeyMod, ScanCode, ScanCodeUtils } from '../../../../../base/common/keyCodes.js';
8
import { KeyCodeChord, decodeKeybinding, createSimpleKeybinding, ScanCodeChord, Keybinding } from '../../../../../base/common/keybindings.js';
9
import { UserSettingsLabelProvider } from '../../../../../base/common/keybindingLabels.js';
10
import { OperatingSystem } from '../../../../../base/common/platform.js';
11
import { USLayoutResolvedKeybinding } from '../../../../../platform/keybinding/common/usLayoutResolvedKeybinding.js';
12
import { MacLinuxKeyboardMapper } from '../../common/macLinuxKeyboardMapper.js';
13
import { IResolvedKeybinding, assertMapping, assertResolveKeyboardEvent, assertResolveKeybinding, readRawMapping } from './keyboardMapperTestUtils.js';
14
import { IMacLinuxKeyboardMapping } from '../../../../../platform/keyboardLayout/common/keyboardLayout.js';
15
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
16

17
const WRITE_FILE_IF_DIFFERENT = false;
18

19
async function createKeyboardMapper(isUSStandard: boolean, file: string, mapAltGrToCtrlAlt: boolean, OS: OperatingSystem): Promise<MacLinuxKeyboardMapper> {
20
	const rawMappings = await readRawMapping<IMacLinuxKeyboardMapping>(file);
21
	return new MacLinuxKeyboardMapper(isUSStandard, rawMappings, mapAltGrToCtrlAlt, OS);
22
}
23

24
suite('keyboardMapper - MAC de_ch', () => {
25

26
	ensureNoDisposablesAreLeakedInTestSuite();
27

28
	let mapper: MacLinuxKeyboardMapper;
29

30
	suiteSetup(async () => {
31
		const _mapper = await createKeyboardMapper(false, 'mac_de_ch', false, OperatingSystem.Macintosh);
32
		mapper = _mapper;
33
	});
34

35
	test('mapping', () => {
36
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'mac_de_ch.txt');
37
	});
38

39
	function assertKeybindingTranslation(kb: number, expected: string | string[]): void {
40
		_assertKeybindingTranslation(mapper, OperatingSystem.Macintosh, kb, expected);
41
	}
42

43
	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
44
		assertResolveKeybinding(mapper, decodeKeybinding(k, OperatingSystem.Macintosh)!, expected);
45
	}
46

47
	test('kb => hw', () => {
48
		// unchanged
49
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.Digit1, 'cmd+Digit1');
50
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyB, 'cmd+KeyB');
51
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyB, 'shift+cmd+KeyB');
52
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KeyB, 'ctrl+shift+alt+cmd+KeyB');
53

54
		// flips Y and Z
55
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyZ, 'cmd+KeyY');
56
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyY, 'cmd+KeyZ');
57

58
		// Ctrl+/
59
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.Slash, 'shift+cmd+Digit7');
60
	});
61

62
	test('resolveKeybinding Cmd+A', () => {
63
		_assertResolveKeybinding(
64
			KeyMod.CtrlCmd | KeyCode.KeyA,
65
			[{
66
				label: '⌘A',
67
				ariaLabel: 'Command+A',
68
				electronAccelerator: 'Cmd+A',
69
				userSettingsLabel: 'cmd+a',
70
				isWYSIWYG: true,
71
				isMultiChord: false,
72
				dispatchParts: ['meta+[KeyA]'],
73
				singleModifierDispatchParts: [null],
74
			}]
75
		);
76
	});
77

78
	test('resolveKeybinding Cmd+B', () => {
79
		_assertResolveKeybinding(
80
			KeyMod.CtrlCmd | KeyCode.KeyB,
81
			[{
82
				label: '⌘B',
83
				ariaLabel: 'Command+B',
84
				electronAccelerator: 'Cmd+B',
85
				userSettingsLabel: 'cmd+b',
86
				isWYSIWYG: true,
87
				isMultiChord: false,
88
				dispatchParts: ['meta+[KeyB]'],
89
				singleModifierDispatchParts: [null],
90
			}]
91
		);
92
	});
93

94
	test('resolveKeybinding Cmd+Z', () => {
95
		_assertResolveKeybinding(
96
			KeyMod.CtrlCmd | KeyCode.KeyZ,
97
			[{
98
				label: '⌘Z',
99
				ariaLabel: 'Command+Z',
100
				electronAccelerator: 'Cmd+Z',
101
				userSettingsLabel: 'cmd+z',
102
				isWYSIWYG: true,
103
				isMultiChord: false,
104
				dispatchParts: ['meta+[KeyY]'],
105
				singleModifierDispatchParts: [null],
106
			}]
107
		);
108
	});
109

110
	test('resolveKeyboardEvent Cmd+[KeyY]', () => {
111
		assertResolveKeyboardEvent(
112
			mapper,
113
			{
114
				_standardKeyboardEventBrand: true,
115
				ctrlKey: false,
116
				shiftKey: false,
117
				altKey: false,
118
				metaKey: true,
119
				altGraphKey: false,
120
				keyCode: -1,
121
				code: 'KeyY'
122
			},
123
			{
124
				label: '⌘Z',
125
				ariaLabel: 'Command+Z',
126
				electronAccelerator: 'Cmd+Z',
127
				userSettingsLabel: 'cmd+z',
128
				isWYSIWYG: true,
129
				isMultiChord: false,
130
				dispatchParts: ['meta+[KeyY]'],
131
				singleModifierDispatchParts: [null],
132
			}
133
		);
134
	});
135

136
	test('resolveKeybinding Cmd+]', () => {
137
		_assertResolveKeybinding(
138
			KeyMod.CtrlCmd | KeyCode.BracketRight,
139
			[{
140
				label: '⌃⌥⌘6',
141
				ariaLabel: 'Control+Option+Command+6',
142
				electronAccelerator: 'Ctrl+Alt+Cmd+6',
143
				userSettingsLabel: 'ctrl+alt+cmd+6',
144
				isWYSIWYG: true,
145
				isMultiChord: false,
146
				dispatchParts: ['ctrl+alt+meta+[Digit6]'],
147
				singleModifierDispatchParts: [null],
148
			}]
149
		);
150
	});
151

152
	test('resolveKeyboardEvent Cmd+[BracketRight]', () => {
153
		assertResolveKeyboardEvent(
154
			mapper,
155
			{
156
				_standardKeyboardEventBrand: true,
157
				ctrlKey: false,
158
				shiftKey: false,
159
				altKey: false,
160
				metaKey: true,
161
				altGraphKey: false,
162
				keyCode: -1,
163
				code: 'BracketRight'
164
			},
165
			{
166
				label: '⌘¨',
167
				ariaLabel: 'Command+¨',
168
				electronAccelerator: null,
169
				userSettingsLabel: 'cmd+[BracketRight]',
170
				isWYSIWYG: false,
171
				isMultiChord: false,
172
				dispatchParts: ['meta+[BracketRight]'],
173
				singleModifierDispatchParts: [null],
174
			}
175
		);
176
	});
177

178
	test('resolveKeybinding Shift+]', () => {
179
		_assertResolveKeybinding(
180
			KeyMod.Shift | KeyCode.BracketRight,
181
			[{
182
				label: '⌃⌥9',
183
				ariaLabel: 'Control+Option+9',
184
				electronAccelerator: 'Ctrl+Alt+9',
185
				userSettingsLabel: 'ctrl+alt+9',
186
				isWYSIWYG: true,
187
				isMultiChord: false,
188
				dispatchParts: ['ctrl+alt+[Digit9]'],
189
				singleModifierDispatchParts: [null],
190
			}]
191
		);
192
	});
193

194
	test('resolveKeybinding Cmd+/', () => {
195
		_assertResolveKeybinding(
196
			KeyMod.CtrlCmd | KeyCode.Slash,
197
			[{
198
				label: '⇧⌘7',
199
				ariaLabel: 'Shift+Command+7',
200
				electronAccelerator: 'Shift+Cmd+7',
201
				userSettingsLabel: 'shift+cmd+7',
202
				isWYSIWYG: true,
203
				isMultiChord: false,
204
				dispatchParts: ['shift+meta+[Digit7]'],
205
				singleModifierDispatchParts: [null],
206
			}]
207
		);
208
	});
209

210
	test('resolveKeybinding Cmd+Shift+/', () => {
211
		_assertResolveKeybinding(
212
			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Slash,
213
			[{
214
				label: '⇧⌘\'',
215
				ariaLabel: 'Shift+Command+\'',
216
				electronAccelerator: null,
217
				userSettingsLabel: 'shift+cmd+[Minus]',
218
				isWYSIWYG: false,
219
				isMultiChord: false,
220
				dispatchParts: ['shift+meta+[Minus]'],
221
				singleModifierDispatchParts: [null],
222
			}]
223
		);
224
	});
225

226
	test('resolveKeybinding Cmd+K Cmd+\\', () => {
227
		_assertResolveKeybinding(
228
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Backslash),
229
			[{
230
				label: '⌘K ⌃⇧⌥⌘7',
231
				ariaLabel: 'Command+K Control+Shift+Option+Command+7',
232
				electronAccelerator: null,
233
				userSettingsLabel: 'cmd+k ctrl+shift+alt+cmd+7',
234
				isWYSIWYG: true,
235
				isMultiChord: true,
236
				dispatchParts: ['meta+[KeyK]', 'ctrl+shift+alt+meta+[Digit7]'],
237
				singleModifierDispatchParts: [null, null],
238
			}]
239
		);
240
	});
241

242
	test('resolveKeybinding Cmd+K Cmd+=', () => {
243
		_assertResolveKeybinding(
244
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Equal),
245
			[{
246
				label: '⌘K ⇧⌘0',
247
				ariaLabel: 'Command+K Shift+Command+0',
248
				electronAccelerator: null,
249
				userSettingsLabel: 'cmd+k shift+cmd+0',
250
				isWYSIWYG: true,
251
				isMultiChord: true,
252
				dispatchParts: ['meta+[KeyK]', 'shift+meta+[Digit0]'],
253
				singleModifierDispatchParts: [null, null],
254
			}]
255
		);
256
	});
257

258
	test('resolveKeybinding Cmd+DownArrow', () => {
259
		_assertResolveKeybinding(
260
			KeyMod.CtrlCmd | KeyCode.DownArrow,
261
			[{
262
				label: '⌘↓',
263
				ariaLabel: 'Command+DownArrow',
264
				electronAccelerator: 'Cmd+Down',
265
				userSettingsLabel: 'cmd+down',
266
				isWYSIWYG: true,
267
				isMultiChord: false,
268
				dispatchParts: ['meta+[ArrowDown]'],
269
				singleModifierDispatchParts: [null],
270
			}]
271
		);
272
	});
273

274
	test('resolveKeybinding Cmd+NUMPAD_0', () => {
275
		_assertResolveKeybinding(
276
			KeyMod.CtrlCmd | KeyCode.Numpad0,
277
			[{
278
				label: '⌘NumPad0',
279
				ariaLabel: 'Command+NumPad0',
280
				electronAccelerator: null,
281
				userSettingsLabel: 'cmd+numpad0',
282
				isWYSIWYG: true,
283
				isMultiChord: false,
284
				dispatchParts: ['meta+[Numpad0]'],
285
				singleModifierDispatchParts: [null],
286
			}]
287
		);
288
	});
289

290
	test('resolveKeybinding Ctrl+Home', () => {
291
		_assertResolveKeybinding(
292
			KeyMod.CtrlCmd | KeyCode.Home,
293
			[{
294
				label: '⌘Home',
295
				ariaLabel: 'Command+Home',
296
				electronAccelerator: 'Cmd+Home',
297
				userSettingsLabel: 'cmd+home',
298
				isWYSIWYG: true,
299
				isMultiChord: false,
300
				dispatchParts: ['meta+[Home]'],
301
				singleModifierDispatchParts: [null],
302
			}]
303
		);
304
	});
305

306
	test('resolveKeyboardEvent Ctrl+[Home]', () => {
307
		assertResolveKeyboardEvent(
308
			mapper,
309
			{
310
				_standardKeyboardEventBrand: true,
311
				ctrlKey: false,
312
				shiftKey: false,
313
				altKey: false,
314
				metaKey: true,
315
				altGraphKey: false,
316
				keyCode: -1,
317
				code: 'Home'
318
			},
319
			{
320
				label: '⌘Home',
321
				ariaLabel: 'Command+Home',
322
				electronAccelerator: 'Cmd+Home',
323
				userSettingsLabel: 'cmd+home',
324
				isWYSIWYG: true,
325
				isMultiChord: false,
326
				dispatchParts: ['meta+[Home]'],
327
				singleModifierDispatchParts: [null],
328
			}
329
		);
330
	});
331

332
	test('resolveUserBinding Cmd+[Comma] Cmd+/', () => {
333
		assertResolveKeybinding(
334
			mapper,
335
			new Keybinding([
336
				new ScanCodeChord(false, false, false, true, ScanCode.Comma),
337
				new KeyCodeChord(false, false, false, true, KeyCode.Slash),
338
			]),
339
			[{
340
				label: '⌘, ⇧⌘7',
341
				ariaLabel: 'Command+, Shift+Command+7',
342
				electronAccelerator: null,
343
				userSettingsLabel: 'cmd+[Comma] shift+cmd+7',
344
				isWYSIWYG: false,
345
				isMultiChord: true,
346
				dispatchParts: ['meta+[Comma]', 'shift+meta+[Digit7]'],
347
				singleModifierDispatchParts: [null, null],
348
			}]
349
		);
350
	});
351

352
	test('resolveKeyboardEvent Single Modifier MetaLeft+', () => {
353
		assertResolveKeyboardEvent(
354
			mapper,
355
			{
356
				_standardKeyboardEventBrand: true,
357
				ctrlKey: false,
358
				shiftKey: false,
359
				altKey: false,
360
				metaKey: true,
361
				altGraphKey: false,
362
				keyCode: -1,
363
				code: 'MetaLeft'
364
			},
365
			{
366
				label: '⌘',
367
				ariaLabel: 'Command',
368
				electronAccelerator: null,
369
				userSettingsLabel: 'cmd',
370
				isWYSIWYG: true,
371
				isMultiChord: false,
372
				dispatchParts: [null],
373
				singleModifierDispatchParts: ['meta'],
374
			}
375
		);
376
	});
377

378
	test('resolveKeyboardEvent Single Modifier MetaRight+', () => {
379
		assertResolveKeyboardEvent(
380
			mapper,
381
			{
382
				_standardKeyboardEventBrand: true,
383
				ctrlKey: false,
384
				shiftKey: false,
385
				altKey: false,
386
				metaKey: true,
387
				altGraphKey: false,
388
				keyCode: -1,
389
				code: 'MetaRight'
390
			},
391
			{
392
				label: '⌘',
393
				ariaLabel: 'Command',
394
				electronAccelerator: null,
395
				userSettingsLabel: 'cmd',
396
				isWYSIWYG: true,
397
				isMultiChord: false,
398
				dispatchParts: [null],
399
				singleModifierDispatchParts: ['meta'],
400
			}
401
		);
402
	});
403
});
404

405
suite('keyboardMapper - MAC en_us', () => {
406

407
	ensureNoDisposablesAreLeakedInTestSuite();
408

409
	let mapper: MacLinuxKeyboardMapper;
410

411
	suiteSetup(async () => {
412
		const _mapper = await createKeyboardMapper(true, 'mac_en_us', false, OperatingSystem.Macintosh);
413
		mapper = _mapper;
414
	});
415

416
	test('mapping', () => {
417
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'mac_en_us.txt');
418
	});
419

420
	test('resolveUserBinding Cmd+[Comma] Cmd+/', () => {
421
		assertResolveKeybinding(
422
			mapper,
423
			new Keybinding([
424
				new ScanCodeChord(false, false, false, true, ScanCode.Comma),
425
				new KeyCodeChord(false, false, false, true, KeyCode.Slash),
426
			]),
427
			[{
428
				label: '⌘, ⌘/',
429
				ariaLabel: 'Command+, Command+/',
430
				electronAccelerator: null,
431
				userSettingsLabel: 'cmd+, cmd+/',
432
				isWYSIWYG: true,
433
				isMultiChord: true,
434
				dispatchParts: ['meta+[Comma]', 'meta+[Slash]'],
435
				singleModifierDispatchParts: [null, null],
436
			}]
437
		);
438
	});
439

440
	test('resolveKeyboardEvent Single Modifier MetaLeft+', () => {
441
		assertResolveKeyboardEvent(
442
			mapper,
443
			{
444
				_standardKeyboardEventBrand: true,
445
				ctrlKey: false,
446
				shiftKey: false,
447
				altKey: false,
448
				metaKey: true,
449
				altGraphKey: false,
450
				keyCode: -1,
451
				code: 'MetaLeft'
452
			},
453
			{
454
				label: '⌘',
455
				ariaLabel: 'Command',
456
				electronAccelerator: null,
457
				userSettingsLabel: 'cmd',
458
				isWYSIWYG: true,
459
				isMultiChord: false,
460
				dispatchParts: [null],
461
				singleModifierDispatchParts: ['meta'],
462
			}
463
		);
464
	});
465

466
	test('resolveKeyboardEvent Single Modifier MetaRight+', () => {
467
		assertResolveKeyboardEvent(
468
			mapper,
469
			{
470
				_standardKeyboardEventBrand: true,
471
				ctrlKey: false,
472
				shiftKey: false,
473
				altKey: false,
474
				metaKey: true,
475
				altGraphKey: false,
476
				keyCode: -1,
477
				code: 'MetaRight'
478
			},
479
			{
480
				label: '⌘',
481
				ariaLabel: 'Command',
482
				electronAccelerator: null,
483
				userSettingsLabel: 'cmd',
484
				isWYSIWYG: true,
485
				isMultiChord: false,
486
				dispatchParts: [null],
487
				singleModifierDispatchParts: ['meta'],
488
			}
489
		);
490
	});
491

492
	test('resolveKeyboardEvent mapAltGrToCtrlAlt AltGr+Z', async () => {
493
		const mapper = await createKeyboardMapper(true, 'mac_en_us', true, OperatingSystem.Macintosh);
494

495
		assertResolveKeyboardEvent(
496
			mapper,
497
			{
498
				_standardKeyboardEventBrand: true,
499
				ctrlKey: false,
500
				shiftKey: false,
501
				altKey: false,
502
				metaKey: false,
503
				altGraphKey: true,
504
				keyCode: -1,
505
				code: 'KeyZ'
506
			},
507
			{
508
				label: '⌃⌥Z',
509
				ariaLabel: 'Control+Option+Z',
510
				electronAccelerator: 'Ctrl+Alt+Z',
511
				userSettingsLabel: 'ctrl+alt+z',
512
				isWYSIWYG: true,
513
				isMultiChord: false,
514
				dispatchParts: ['ctrl+alt+[KeyZ]'],
515
				singleModifierDispatchParts: [null],
516
			}
517
		);
518
	});
519
});
520

521
suite('keyboardMapper - LINUX de_ch', () => {
522

523
	ensureNoDisposablesAreLeakedInTestSuite();
524

525
	let mapper: MacLinuxKeyboardMapper;
526

527
	suiteSetup(async () => {
528
		const _mapper = await createKeyboardMapper(false, 'linux_de_ch', false, OperatingSystem.Linux);
529
		mapper = _mapper;
530
	});
531

532
	test('mapping', () => {
533
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'linux_de_ch.txt');
534
	});
535

536
	function assertKeybindingTranslation(kb: number, expected: string | string[]): void {
537
		_assertKeybindingTranslation(mapper, OperatingSystem.Linux, kb, expected);
538
	}
539

540
	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
541
		assertResolveKeybinding(mapper, decodeKeybinding(k, OperatingSystem.Linux)!, expected);
542
	}
543

544
	test('kb => hw', () => {
545
		// unchanged
546
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.Digit1, 'ctrl+Digit1');
547
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyB, 'ctrl+KeyB');
548
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyB, 'ctrl+shift+KeyB');
549
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KeyB, 'ctrl+shift+alt+meta+KeyB');
550

551
		// flips Y and Z
552
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyZ, 'ctrl+KeyY');
553
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KeyY, 'ctrl+KeyZ');
554

555
		// Ctrl+/
556
		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.Slash, 'ctrl+shift+Digit7');
557
	});
558

559
	test('resolveKeybinding Ctrl+A', () => {
560
		_assertResolveKeybinding(
561
			KeyMod.CtrlCmd | KeyCode.KeyA,
562
			[{
563
				label: 'Ctrl+A',
564
				ariaLabel: 'Control+A',
565
				electronAccelerator: 'Ctrl+A',
566
				userSettingsLabel: 'ctrl+a',
567
				isWYSIWYG: true,
568
				isMultiChord: false,
569
				dispatchParts: ['ctrl+[KeyA]'],
570
				singleModifierDispatchParts: [null],
571
			}]
572
		);
573
	});
574

575
	test('resolveKeybinding Ctrl+Z', () => {
576
		_assertResolveKeybinding(
577
			KeyMod.CtrlCmd | KeyCode.KeyZ,
578
			[{
579
				label: 'Ctrl+Z',
580
				ariaLabel: 'Control+Z',
581
				electronAccelerator: 'Ctrl+Z',
582
				userSettingsLabel: 'ctrl+z',
583
				isWYSIWYG: true,
584
				isMultiChord: false,
585
				dispatchParts: ['ctrl+[KeyY]'],
586
				singleModifierDispatchParts: [null],
587
			}]
588
		);
589
	});
590

591
	test('resolveKeyboardEvent Ctrl+[KeyY]', () => {
592
		assertResolveKeyboardEvent(
593
			mapper,
594
			{
595
				_standardKeyboardEventBrand: true,
596
				ctrlKey: true,
597
				shiftKey: false,
598
				altKey: false,
599
				metaKey: false,
600
				altGraphKey: false,
601
				keyCode: -1,
602
				code: 'KeyY'
603
			},
604
			{
605
				label: 'Ctrl+Z',
606
				ariaLabel: 'Control+Z',
607
				electronAccelerator: 'Ctrl+Z',
608
				userSettingsLabel: 'ctrl+z',
609
				isWYSIWYG: true,
610
				isMultiChord: false,
611
				dispatchParts: ['ctrl+[KeyY]'],
612
				singleModifierDispatchParts: [null],
613
			}
614
		);
615
	});
616

617
	test('resolveKeybinding Ctrl+]', () => {
618
		_assertResolveKeybinding(
619
			KeyMod.CtrlCmd | KeyCode.BracketRight,
620
			[]
621
		);
622
	});
623

624
	test('resolveKeyboardEvent Ctrl+[BracketRight]', () => {
625
		assertResolveKeyboardEvent(
626
			mapper,
627
			{
628
				_standardKeyboardEventBrand: true,
629
				ctrlKey: true,
630
				shiftKey: false,
631
				altKey: false,
632
				metaKey: false,
633
				altGraphKey: false,
634
				keyCode: -1,
635
				code: 'BracketRight'
636
			},
637
			{
638
				label: 'Ctrl+¨',
639
				ariaLabel: 'Control+¨',
640
				electronAccelerator: null,
641
				userSettingsLabel: 'ctrl+[BracketRight]',
642
				isWYSIWYG: false,
643
				isMultiChord: false,
644
				dispatchParts: ['ctrl+[BracketRight]'],
645
				singleModifierDispatchParts: [null],
646
			}
647
		);
648
	});
649

650
	test('resolveKeybinding Shift+]', () => {
651
		_assertResolveKeybinding(
652
			KeyMod.Shift | KeyCode.BracketRight,
653
			[{
654
				label: 'Ctrl+Alt+0',
655
				ariaLabel: 'Control+Alt+0',
656
				electronAccelerator: 'Ctrl+Alt+0',
657
				userSettingsLabel: 'ctrl+alt+0',
658
				isWYSIWYG: true,
659
				isMultiChord: false,
660
				dispatchParts: ['ctrl+alt+[Digit0]'],
661
				singleModifierDispatchParts: [null],
662
			}, {
663
				label: 'Ctrl+Alt+$',
664
				ariaLabel: 'Control+Alt+$',
665
				electronAccelerator: null,
666
				userSettingsLabel: 'ctrl+alt+[Backslash]',
667
				isWYSIWYG: false,
668
				isMultiChord: false,
669
				dispatchParts: ['ctrl+alt+[Backslash]'],
670
				singleModifierDispatchParts: [null],
671
			}]
672
		);
673
	});
674

675
	test('resolveKeybinding Ctrl+/', () => {
676
		_assertResolveKeybinding(
677
			KeyMod.CtrlCmd | KeyCode.Slash,
678
			[{
679
				label: 'Ctrl+Shift+7',
680
				ariaLabel: 'Control+Shift+7',
681
				electronAccelerator: 'Ctrl+Shift+7',
682
				userSettingsLabel: 'ctrl+shift+7',
683
				isWYSIWYG: true,
684
				isMultiChord: false,
685
				dispatchParts: ['ctrl+shift+[Digit7]'],
686
				singleModifierDispatchParts: [null],
687
			}]
688
		);
689
	});
690

691
	test('resolveKeybinding Ctrl+Shift+/', () => {
692
		_assertResolveKeybinding(
693
			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Slash,
694
			[{
695
				label: 'Ctrl+Shift+\'',
696
				ariaLabel: 'Control+Shift+\'',
697
				electronAccelerator: null,
698
				userSettingsLabel: 'ctrl+shift+[Minus]',
699
				isWYSIWYG: false,
700
				isMultiChord: false,
701
				dispatchParts: ['ctrl+shift+[Minus]'],
702
				singleModifierDispatchParts: [null],
703
			}]
704
		);
705
	});
706

707
	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
708
		_assertResolveKeybinding(
709
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Backslash),
710
			[]
711
		);
712
	});
713

714
	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
715
		_assertResolveKeybinding(
716
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Equal),
717
			[{
718
				label: 'Ctrl+K Ctrl+Shift+0',
719
				ariaLabel: 'Control+K Control+Shift+0',
720
				electronAccelerator: null,
721
				userSettingsLabel: 'ctrl+k ctrl+shift+0',
722
				isWYSIWYG: true,
723
				isMultiChord: true,
724
				dispatchParts: ['ctrl+[KeyK]', 'ctrl+shift+[Digit0]'],
725
				singleModifierDispatchParts: [null, null],
726
			}]
727
		);
728
	});
729

730
	test('resolveKeybinding Ctrl+DownArrow', () => {
731
		_assertResolveKeybinding(
732
			KeyMod.CtrlCmd | KeyCode.DownArrow,
733
			[{
734
				label: 'Ctrl+DownArrow',
735
				ariaLabel: 'Control+DownArrow',
736
				electronAccelerator: 'Ctrl+Down',
737
				userSettingsLabel: 'ctrl+down',
738
				isWYSIWYG: true,
739
				isMultiChord: false,
740
				dispatchParts: ['ctrl+[ArrowDown]'],
741
				singleModifierDispatchParts: [null],
742
			}]
743
		);
744
	});
745

746
	test('resolveKeybinding Ctrl+NUMPAD_0', () => {
747
		_assertResolveKeybinding(
748
			KeyMod.CtrlCmd | KeyCode.Numpad0,
749
			[{
750
				label: 'Ctrl+NumPad0',
751
				ariaLabel: 'Control+NumPad0',
752
				electronAccelerator: null,
753
				userSettingsLabel: 'ctrl+numpad0',
754
				isWYSIWYG: true,
755
				isMultiChord: false,
756
				dispatchParts: ['ctrl+[Numpad0]'],
757
				singleModifierDispatchParts: [null],
758
			}]
759
		);
760
	});
761

762
	test('resolveKeybinding Ctrl+Home', () => {
763
		_assertResolveKeybinding(
764
			KeyMod.CtrlCmd | KeyCode.Home,
765
			[{
766
				label: 'Ctrl+Home',
767
				ariaLabel: 'Control+Home',
768
				electronAccelerator: 'Ctrl+Home',
769
				userSettingsLabel: 'ctrl+home',
770
				isWYSIWYG: true,
771
				isMultiChord: false,
772
				dispatchParts: ['ctrl+[Home]'],
773
				singleModifierDispatchParts: [null],
774
			}]
775
		);
776
	});
777

778
	test('resolveKeyboardEvent Ctrl+[Home]', () => {
779
		assertResolveKeyboardEvent(
780
			mapper,
781
			{
782
				_standardKeyboardEventBrand: true,
783
				ctrlKey: true,
784
				shiftKey: false,
785
				altKey: false,
786
				metaKey: false,
787
				altGraphKey: false,
788
				keyCode: -1,
789
				code: 'Home'
790
			},
791
			{
792
				label: 'Ctrl+Home',
793
				ariaLabel: 'Control+Home',
794
				electronAccelerator: 'Ctrl+Home',
795
				userSettingsLabel: 'ctrl+home',
796
				isWYSIWYG: true,
797
				isMultiChord: false,
798
				dispatchParts: ['ctrl+[Home]'],
799
				singleModifierDispatchParts: [null],
800
			}
801
		);
802
	});
803

804
	test('resolveKeyboardEvent Ctrl+[KeyX]', () => {
805
		assertResolveKeyboardEvent(
806
			mapper,
807
			{
808
				_standardKeyboardEventBrand: true,
809
				ctrlKey: true,
810
				shiftKey: false,
811
				altKey: false,
812
				metaKey: false,
813
				altGraphKey: false,
814
				keyCode: -1,
815
				code: 'KeyX'
816
			},
817
			{
818
				label: 'Ctrl+X',
819
				ariaLabel: 'Control+X',
820
				electronAccelerator: 'Ctrl+X',
821
				userSettingsLabel: 'ctrl+x',
822
				isWYSIWYG: true,
823
				isMultiChord: false,
824
				dispatchParts: ['ctrl+[KeyX]'],
825
				singleModifierDispatchParts: [null],
826
			}
827
		);
828
	});
829

830
	test('resolveUserBinding Ctrl+[Comma] Ctrl+/', () => {
831
		assertResolveKeybinding(
832
			mapper, new Keybinding([
833
				new ScanCodeChord(true, false, false, false, ScanCode.Comma),
834
				new KeyCodeChord(true, false, false, false, KeyCode.Slash),
835
			]),
836
			[{
837
				label: 'Ctrl+, Ctrl+Shift+7',
838
				ariaLabel: 'Control+, Control+Shift+7',
839
				electronAccelerator: null,
840
				userSettingsLabel: 'ctrl+[Comma] ctrl+shift+7',
841
				isWYSIWYG: false,
842
				isMultiChord: true,
843
				dispatchParts: ['ctrl+[Comma]', 'ctrl+shift+[Digit7]'],
844
				singleModifierDispatchParts: [null, null],
845
			}]
846
		);
847
	});
848

849
	test('resolveKeyboardEvent Single Modifier ControlLeft+', () => {
850
		assertResolveKeyboardEvent(
851
			mapper,
852
			{
853
				_standardKeyboardEventBrand: true,
854
				ctrlKey: true,
855
				shiftKey: false,
856
				altKey: false,
857
				metaKey: false,
858
				altGraphKey: false,
859
				keyCode: -1,
860
				code: 'ControlLeft'
861
			},
862
			{
863
				label: 'Ctrl',
864
				ariaLabel: 'Control',
865
				electronAccelerator: null,
866
				userSettingsLabel: 'ctrl',
867
				isWYSIWYG: true,
868
				isMultiChord: false,
869
				dispatchParts: [null],
870
				singleModifierDispatchParts: ['ctrl'],
871
			}
872
		);
873
	});
874

875
	test('resolveKeyboardEvent Single Modifier ControlRight+', () => {
876
		assertResolveKeyboardEvent(
877
			mapper,
878
			{
879
				_standardKeyboardEventBrand: true,
880
				ctrlKey: true,
881
				shiftKey: false,
882
				altKey: false,
883
				metaKey: false,
884
				altGraphKey: false,
885
				keyCode: -1,
886
				code: 'ControlRight'
887
			},
888
			{
889
				label: 'Ctrl',
890
				ariaLabel: 'Control',
891
				electronAccelerator: null,
892
				userSettingsLabel: 'ctrl',
893
				isWYSIWYG: true,
894
				isMultiChord: false,
895
				dispatchParts: [null],
896
				singleModifierDispatchParts: ['ctrl'],
897
			}
898
		);
899
	});
900
});
901

902
suite('keyboardMapper - LINUX en_us', () => {
903

904
	ensureNoDisposablesAreLeakedInTestSuite();
905

906
	let mapper: MacLinuxKeyboardMapper;
907

908
	suiteSetup(async () => {
909
		const _mapper = await createKeyboardMapper(true, 'linux_en_us', false, OperatingSystem.Linux);
910
		mapper = _mapper;
911
	});
912

913
	test('mapping', () => {
914
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'linux_en_us.txt');
915
	});
916

917
	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
918
		assertResolveKeybinding(mapper, decodeKeybinding(k, OperatingSystem.Linux)!, expected);
919
	}
920

921
	test('resolveKeybinding Ctrl+A', () => {
922
		_assertResolveKeybinding(
923
			KeyMod.CtrlCmd | KeyCode.KeyA,
924
			[{
925
				label: 'Ctrl+A',
926
				ariaLabel: 'Control+A',
927
				electronAccelerator: 'Ctrl+A',
928
				userSettingsLabel: 'ctrl+a',
929
				isWYSIWYG: true,
930
				isMultiChord: false,
931
				dispatchParts: ['ctrl+[KeyA]'],
932
				singleModifierDispatchParts: [null],
933
			}]
934
		);
935
	});
936

937
	test('resolveKeybinding Ctrl+Z', () => {
938
		_assertResolveKeybinding(
939
			KeyMod.CtrlCmd | KeyCode.KeyZ,
940
			[{
941
				label: 'Ctrl+Z',
942
				ariaLabel: 'Control+Z',
943
				electronAccelerator: 'Ctrl+Z',
944
				userSettingsLabel: 'ctrl+z',
945
				isWYSIWYG: true,
946
				isMultiChord: false,
947
				dispatchParts: ['ctrl+[KeyZ]'],
948
				singleModifierDispatchParts: [null],
949
			}]
950
		);
951
	});
952

953
	test('resolveKeyboardEvent Ctrl+[KeyZ]', () => {
954
		assertResolveKeyboardEvent(
955
			mapper,
956
			{
957
				_standardKeyboardEventBrand: true,
958
				ctrlKey: true,
959
				shiftKey: false,
960
				altKey: false,
961
				metaKey: false,
962
				altGraphKey: false,
963
				keyCode: -1,
964
				code: 'KeyZ'
965
			},
966
			{
967
				label: 'Ctrl+Z',
968
				ariaLabel: 'Control+Z',
969
				electronAccelerator: 'Ctrl+Z',
970
				userSettingsLabel: 'ctrl+z',
971
				isWYSIWYG: true,
972
				isMultiChord: false,
973
				dispatchParts: ['ctrl+[KeyZ]'],
974
				singleModifierDispatchParts: [null],
975
			}
976
		);
977
	});
978

979
	test('resolveKeybinding Ctrl+]', () => {
980
		_assertResolveKeybinding(
981
			KeyMod.CtrlCmd | KeyCode.BracketRight,
982
			[{
983
				label: 'Ctrl+]',
984
				ariaLabel: 'Control+]',
985
				electronAccelerator: 'Ctrl+]',
986
				userSettingsLabel: 'ctrl+]',
987
				isWYSIWYG: true,
988
				isMultiChord: false,
989
				dispatchParts: ['ctrl+[BracketRight]'],
990
				singleModifierDispatchParts: [null],
991
			}]
992
		);
993
	});
994

995
	test('resolveKeyboardEvent Ctrl+[BracketRight]', () => {
996
		assertResolveKeyboardEvent(
997
			mapper,
998
			{
999
				_standardKeyboardEventBrand: true,
1000
				ctrlKey: true,
1001
				shiftKey: false,
1002
				altKey: false,
1003
				metaKey: false,
1004
				altGraphKey: false,
1005
				keyCode: -1,
1006
				code: 'BracketRight'
1007
			},
1008
			{
1009
				label: 'Ctrl+]',
1010
				ariaLabel: 'Control+]',
1011
				electronAccelerator: 'Ctrl+]',
1012
				userSettingsLabel: 'ctrl+]',
1013
				isWYSIWYG: true,
1014
				isMultiChord: false,
1015
				dispatchParts: ['ctrl+[BracketRight]'],
1016
				singleModifierDispatchParts: [null],
1017
			}
1018
		);
1019
	});
1020

1021
	test('resolveKeybinding Shift+]', () => {
1022
		_assertResolveKeybinding(
1023
			KeyMod.Shift | KeyCode.BracketRight,
1024
			[{
1025
				label: 'Shift+]',
1026
				ariaLabel: 'Shift+]',
1027
				electronAccelerator: 'Shift+]',
1028
				userSettingsLabel: 'shift+]',
1029
				isWYSIWYG: true,
1030
				isMultiChord: false,
1031
				dispatchParts: ['shift+[BracketRight]'],
1032
				singleModifierDispatchParts: [null],
1033
			}]
1034
		);
1035
	});
1036

1037
	test('resolveKeybinding Ctrl+/', () => {
1038
		_assertResolveKeybinding(
1039
			KeyMod.CtrlCmd | KeyCode.Slash,
1040
			[{
1041
				label: 'Ctrl+/',
1042
				ariaLabel: 'Control+/',
1043
				electronAccelerator: 'Ctrl+/',
1044
				userSettingsLabel: 'ctrl+/',
1045
				isWYSIWYG: true,
1046
				isMultiChord: false,
1047
				dispatchParts: ['ctrl+[Slash]'],
1048
				singleModifierDispatchParts: [null],
1049
			}]
1050
		);
1051
	});
1052

1053
	test('resolveKeybinding Ctrl+Shift+/', () => {
1054
		_assertResolveKeybinding(
1055
			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Slash,
1056
			[{
1057
				label: 'Ctrl+Shift+/',
1058
				ariaLabel: 'Control+Shift+/',
1059
				electronAccelerator: 'Ctrl+Shift+/',
1060
				userSettingsLabel: 'ctrl+shift+/',
1061
				isWYSIWYG: true,
1062
				isMultiChord: false,
1063
				dispatchParts: ['ctrl+shift+[Slash]'],
1064
				singleModifierDispatchParts: [null],
1065
			}]
1066
		);
1067
	});
1068

1069
	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
1070
		_assertResolveKeybinding(
1071
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Backslash),
1072
			[{
1073
				label: 'Ctrl+K Ctrl+\\',
1074
				ariaLabel: 'Control+K Control+\\',
1075
				electronAccelerator: null,
1076
				userSettingsLabel: 'ctrl+k ctrl+\\',
1077
				isWYSIWYG: true,
1078
				isMultiChord: true,
1079
				dispatchParts: ['ctrl+[KeyK]', 'ctrl+[Backslash]'],
1080
				singleModifierDispatchParts: [null, null],
1081
			}]
1082
		);
1083
	});
1084

1085
	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
1086
		_assertResolveKeybinding(
1087
			KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.Equal),
1088
			[{
1089
				label: 'Ctrl+K Ctrl+=',
1090
				ariaLabel: 'Control+K Control+=',
1091
				electronAccelerator: null,
1092
				userSettingsLabel: 'ctrl+k ctrl+=',
1093
				isWYSIWYG: true,
1094
				isMultiChord: true,
1095
				dispatchParts: ['ctrl+[KeyK]', 'ctrl+[Equal]'],
1096
				singleModifierDispatchParts: [null, null],
1097
			}]
1098
		);
1099
	});
1100

1101
	test('resolveKeybinding Ctrl+DownArrow', () => {
1102
		_assertResolveKeybinding(
1103
			KeyMod.CtrlCmd | KeyCode.DownArrow,
1104
			[{
1105
				label: 'Ctrl+DownArrow',
1106
				ariaLabel: 'Control+DownArrow',
1107
				electronAccelerator: 'Ctrl+Down',
1108
				userSettingsLabel: 'ctrl+down',
1109
				isWYSIWYG: true,
1110
				isMultiChord: false,
1111
				dispatchParts: ['ctrl+[ArrowDown]'],
1112
				singleModifierDispatchParts: [null],
1113
			}]
1114
		);
1115
	});
1116

1117
	test('resolveKeybinding Ctrl+NUMPAD_0', () => {
1118
		_assertResolveKeybinding(
1119
			KeyMod.CtrlCmd | KeyCode.Numpad0,
1120
			[{
1121
				label: 'Ctrl+NumPad0',
1122
				ariaLabel: 'Control+NumPad0',
1123
				electronAccelerator: null,
1124
				userSettingsLabel: 'ctrl+numpad0',
1125
				isWYSIWYG: true,
1126
				isMultiChord: false,
1127
				dispatchParts: ['ctrl+[Numpad0]'],
1128
				singleModifierDispatchParts: [null],
1129
			}]
1130
		);
1131
	});
1132

1133
	test('resolveKeybinding Ctrl+Home', () => {
1134
		_assertResolveKeybinding(
1135
			KeyMod.CtrlCmd | KeyCode.Home,
1136
			[{
1137
				label: 'Ctrl+Home',
1138
				ariaLabel: 'Control+Home',
1139
				electronAccelerator: 'Ctrl+Home',
1140
				userSettingsLabel: 'ctrl+home',
1141
				isWYSIWYG: true,
1142
				isMultiChord: false,
1143
				dispatchParts: ['ctrl+[Home]'],
1144
				singleModifierDispatchParts: [null],
1145
			}]
1146
		);
1147
	});
1148

1149
	test('resolveKeyboardEvent Ctrl+[Home]', () => {
1150
		assertResolveKeyboardEvent(
1151
			mapper,
1152
			{
1153
				_standardKeyboardEventBrand: true,
1154
				ctrlKey: true,
1155
				shiftKey: false,
1156
				altKey: false,
1157
				metaKey: false,
1158
				altGraphKey: false,
1159
				keyCode: -1,
1160
				code: 'Home'
1161
			},
1162
			{
1163
				label: 'Ctrl+Home',
1164
				ariaLabel: 'Control+Home',
1165
				electronAccelerator: 'Ctrl+Home',
1166
				userSettingsLabel: 'ctrl+home',
1167
				isWYSIWYG: true,
1168
				isMultiChord: false,
1169
				dispatchParts: ['ctrl+[Home]'],
1170
				singleModifierDispatchParts: [null],
1171
			}
1172
		);
1173
	});
1174

1175
	test('resolveKeybinding Ctrl+Shift+,', () => {
1176
		_assertResolveKeybinding(
1177
			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Comma,
1178
			[{
1179
				label: 'Ctrl+Shift+,',
1180
				ariaLabel: 'Control+Shift+,',
1181
				electronAccelerator: 'Ctrl+Shift+,',
1182
				userSettingsLabel: 'ctrl+shift+,',
1183
				isWYSIWYG: true,
1184
				isMultiChord: false,
1185
				dispatchParts: ['ctrl+shift+[Comma]'],
1186
				singleModifierDispatchParts: [null],
1187
			}, {
1188
				label: 'Ctrl+<',
1189
				ariaLabel: 'Control+<',
1190
				electronAccelerator: null,
1191
				userSettingsLabel: 'ctrl+[IntlBackslash]',
1192
				isWYSIWYG: false,
1193
				isMultiChord: false,
1194
				dispatchParts: ['ctrl+[IntlBackslash]'],
1195
				singleModifierDispatchParts: [null],
1196
			}]
1197
		);
1198
	});
1199

1200
	test('issue #23393: resolveKeybinding Ctrl+Enter', () => {
1201
		_assertResolveKeybinding(
1202
			KeyMod.CtrlCmd | KeyCode.Enter,
1203
			[{
1204
				label: 'Ctrl+Enter',
1205
				ariaLabel: 'Control+Enter',
1206
				electronAccelerator: 'Ctrl+Enter',
1207
				userSettingsLabel: 'ctrl+enter',
1208
				isWYSIWYG: true,
1209
				isMultiChord: false,
1210
				dispatchParts: ['ctrl+[Enter]'],
1211
				singleModifierDispatchParts: [null],
1212
			}]
1213
		);
1214
	});
1215

1216
	test('issue #23393: resolveKeyboardEvent Ctrl+[NumpadEnter]', () => {
1217
		assertResolveKeyboardEvent(
1218
			mapper,
1219
			{
1220
				_standardKeyboardEventBrand: true,
1221
				ctrlKey: true,
1222
				shiftKey: false,
1223
				altKey: false,
1224
				metaKey: false,
1225
				altGraphKey: false,
1226
				keyCode: -1,
1227
				code: 'NumpadEnter'
1228
			},
1229
			{
1230
				label: 'Ctrl+Enter',
1231
				ariaLabel: 'Control+Enter',
1232
				electronAccelerator: 'Ctrl+Enter',
1233
				userSettingsLabel: 'ctrl+enter',
1234
				isWYSIWYG: true,
1235
				isMultiChord: false,
1236
				dispatchParts: ['ctrl+[Enter]'],
1237
				singleModifierDispatchParts: [null],
1238
			}
1239
		);
1240
	});
1241

1242
	test('resolveUserBinding Ctrl+[Comma] Ctrl+/', () => {
1243
		assertResolveKeybinding(
1244
			mapper, new Keybinding([
1245
				new ScanCodeChord(true, false, false, false, ScanCode.Comma),
1246
				new KeyCodeChord(true, false, false, false, KeyCode.Slash),
1247
			]),
1248
			[{
1249
				label: 'Ctrl+, Ctrl+/',
1250
				ariaLabel: 'Control+, Control+/',
1251
				electronAccelerator: null,
1252
				userSettingsLabel: 'ctrl+, ctrl+/',
1253
				isWYSIWYG: true,
1254
				isMultiChord: true,
1255
				dispatchParts: ['ctrl+[Comma]', 'ctrl+[Slash]'],
1256
				singleModifierDispatchParts: [null, null],
1257
			}]
1258
		);
1259
	});
1260

1261
	test('resolveUserBinding Ctrl+[Comma]', () => {
1262
		assertResolveKeybinding(
1263
			mapper, new Keybinding([
1264
				new ScanCodeChord(true, false, false, false, ScanCode.Comma)
1265
			]),
1266
			[{
1267
				label: 'Ctrl+,',
1268
				ariaLabel: 'Control+,',
1269
				electronAccelerator: 'Ctrl+,',
1270
				userSettingsLabel: 'ctrl+,',
1271
				isWYSIWYG: true,
1272
				isMultiChord: false,
1273
				dispatchParts: ['ctrl+[Comma]'],
1274
				singleModifierDispatchParts: [null],
1275
			}]
1276
		);
1277
	});
1278

1279
	test('resolveKeyboardEvent Single Modifier ControlLeft+', () => {
1280
		assertResolveKeyboardEvent(
1281
			mapper,
1282
			{
1283
				_standardKeyboardEventBrand: true,
1284
				ctrlKey: true,
1285
				shiftKey: false,
1286
				altKey: false,
1287
				metaKey: false,
1288
				altGraphKey: false,
1289
				keyCode: -1,
1290
				code: 'ControlLeft'
1291
			},
1292
			{
1293
				label: 'Ctrl',
1294
				ariaLabel: 'Control',
1295
				electronAccelerator: null,
1296
				userSettingsLabel: 'ctrl',
1297
				isWYSIWYG: true,
1298
				isMultiChord: false,
1299
				dispatchParts: [null],
1300
				singleModifierDispatchParts: ['ctrl'],
1301
			}
1302
		);
1303
	});
1304

1305
	test('resolveKeyboardEvent Single Modifier ControlRight+', () => {
1306
		assertResolveKeyboardEvent(
1307
			mapper,
1308
			{
1309
				_standardKeyboardEventBrand: true,
1310
				ctrlKey: true,
1311
				shiftKey: false,
1312
				altKey: false,
1313
				metaKey: false,
1314
				altGraphKey: false,
1315
				keyCode: -1,
1316
				code: 'ControlRight'
1317
			},
1318
			{
1319
				label: 'Ctrl',
1320
				ariaLabel: 'Control',
1321
				electronAccelerator: null,
1322
				userSettingsLabel: 'ctrl',
1323
				isWYSIWYG: true,
1324
				isMultiChord: false,
1325
				dispatchParts: [null],
1326
				singleModifierDispatchParts: ['ctrl'],
1327
			}
1328
		);
1329
	});
1330

1331
	test('resolveKeyboardEvent Single Modifier ShiftLeft+', () => {
1332
		assertResolveKeyboardEvent(
1333
			mapper,
1334
			{
1335
				_standardKeyboardEventBrand: true,
1336
				ctrlKey: false,
1337
				shiftKey: true,
1338
				altKey: false,
1339
				metaKey: false,
1340
				altGraphKey: false,
1341
				keyCode: -1,
1342
				code: 'ShiftLeft'
1343
			},
1344
			{
1345
				label: 'Shift',
1346
				ariaLabel: 'Shift',
1347
				electronAccelerator: null,
1348
				userSettingsLabel: 'shift',
1349
				isWYSIWYG: true,
1350
				isMultiChord: false,
1351
				dispatchParts: [null],
1352
				singleModifierDispatchParts: ['shift'],
1353
			}
1354
		);
1355
	});
1356

1357
	test('resolveKeyboardEvent Single Modifier ShiftRight+', () => {
1358
		assertResolveKeyboardEvent(
1359
			mapper,
1360
			{
1361
				_standardKeyboardEventBrand: true,
1362
				ctrlKey: false,
1363
				shiftKey: true,
1364
				altKey: false,
1365
				metaKey: false,
1366
				altGraphKey: false,
1367
				keyCode: -1,
1368
				code: 'ShiftRight'
1369
			},
1370
			{
1371
				label: 'Shift',
1372
				ariaLabel: 'Shift',
1373
				electronAccelerator: null,
1374
				userSettingsLabel: 'shift',
1375
				isWYSIWYG: true,
1376
				isMultiChord: false,
1377
				dispatchParts: [null],
1378
				singleModifierDispatchParts: ['shift'],
1379
			}
1380
		);
1381
	});
1382

1383
	test('resolveKeyboardEvent Single Modifier AltLeft+', () => {
1384
		assertResolveKeyboardEvent(
1385
			mapper,
1386
			{
1387
				_standardKeyboardEventBrand: true,
1388
				ctrlKey: false,
1389
				shiftKey: false,
1390
				altKey: true,
1391
				metaKey: false,
1392
				altGraphKey: false,
1393
				keyCode: -1,
1394
				code: 'AltLeft'
1395
			},
1396
			{
1397
				label: 'Alt',
1398
				ariaLabel: 'Alt',
1399
				electronAccelerator: null,
1400
				userSettingsLabel: 'alt',
1401
				isWYSIWYG: true,
1402
				isMultiChord: false,
1403
				dispatchParts: [null],
1404
				singleModifierDispatchParts: ['alt'],
1405
			}
1406
		);
1407
	});
1408

1409
	test('resolveKeyboardEvent Single Modifier AltRight+', () => {
1410
		assertResolveKeyboardEvent(
1411
			mapper,
1412
			{
1413
				_standardKeyboardEventBrand: true,
1414
				ctrlKey: false,
1415
				shiftKey: false,
1416
				altKey: true,
1417
				metaKey: false,
1418
				altGraphKey: false,
1419
				keyCode: -1,
1420
				code: 'AltRight'
1421
			},
1422
			{
1423
				label: 'Alt',
1424
				ariaLabel: 'Alt',
1425
				electronAccelerator: null,
1426
				userSettingsLabel: 'alt',
1427
				isWYSIWYG: true,
1428
				isMultiChord: false,
1429
				dispatchParts: [null],
1430
				singleModifierDispatchParts: ['alt'],
1431
			}
1432
		);
1433
	});
1434

1435
	test('resolveKeyboardEvent Single Modifier MetaLeft+', () => {
1436
		assertResolveKeyboardEvent(
1437
			mapper,
1438
			{
1439
				_standardKeyboardEventBrand: true,
1440
				ctrlKey: false,
1441
				shiftKey: false,
1442
				altKey: false,
1443
				metaKey: true,
1444
				altGraphKey: false,
1445
				keyCode: -1,
1446
				code: 'MetaLeft'
1447
			},
1448
			{
1449
				label: 'Super',
1450
				ariaLabel: 'Super',
1451
				electronAccelerator: null,
1452
				userSettingsLabel: 'meta',
1453
				isWYSIWYG: true,
1454
				isMultiChord: false,
1455
				dispatchParts: [null],
1456
				singleModifierDispatchParts: ['meta'],
1457
			}
1458
		);
1459
	});
1460

1461
	test('resolveKeyboardEvent Single Modifier MetaRight+', () => {
1462
		assertResolveKeyboardEvent(
1463
			mapper,
1464
			{
1465
				_standardKeyboardEventBrand: true,
1466
				ctrlKey: false,
1467
				shiftKey: false,
1468
				altKey: false,
1469
				metaKey: true,
1470
				altGraphKey: false,
1471
				keyCode: -1,
1472
				code: 'MetaRight'
1473
			},
1474
			{
1475
				label: 'Super',
1476
				ariaLabel: 'Super',
1477
				electronAccelerator: null,
1478
				userSettingsLabel: 'meta',
1479
				isWYSIWYG: true,
1480
				isMultiChord: false,
1481
				dispatchParts: [null],
1482
				singleModifierDispatchParts: ['meta'],
1483
			}
1484
		);
1485
	});
1486

1487
	test('resolveKeyboardEvent Only Modifiers Ctrl+Shift+', () => {
1488
		assertResolveKeyboardEvent(
1489
			mapper,
1490
			{
1491
				_standardKeyboardEventBrand: true,
1492
				ctrlKey: true,
1493
				shiftKey: true,
1494
				altKey: false,
1495
				metaKey: false,
1496
				altGraphKey: false,
1497
				keyCode: -1,
1498
				code: 'ShiftLeft'
1499
			},
1500
			{
1501
				label: 'Ctrl+Shift',
1502
				ariaLabel: 'Control+Shift',
1503
				electronAccelerator: null,
1504
				userSettingsLabel: 'ctrl+shift',
1505
				isWYSIWYG: true,
1506
				isMultiChord: false,
1507
				dispatchParts: [null],
1508
				singleModifierDispatchParts: [null],
1509
			}
1510
		);
1511
	});
1512

1513
	test('resolveKeyboardEvent mapAltGrToCtrlAlt AltGr+Z', async () => {
1514
		const mapper = await createKeyboardMapper(true, 'linux_en_us', true, OperatingSystem.Linux);
1515

1516
		assertResolveKeyboardEvent(
1517
			mapper,
1518
			{
1519
				_standardKeyboardEventBrand: true,
1520
				ctrlKey: false,
1521
				shiftKey: false,
1522
				altKey: false,
1523
				metaKey: false,
1524
				altGraphKey: true,
1525
				keyCode: -1,
1526
				code: 'KeyZ'
1527
			},
1528
			{
1529
				label: 'Ctrl+Alt+Z',
1530
				ariaLabel: 'Control+Alt+Z',
1531
				electronAccelerator: 'Ctrl+Alt+Z',
1532
				userSettingsLabel: 'ctrl+alt+z',
1533
				isWYSIWYG: true,
1534
				isMultiChord: false,
1535
				dispatchParts: ['ctrl+alt+[KeyZ]'],
1536
				singleModifierDispatchParts: [null],
1537
			}
1538
		);
1539
	});
1540
});
1541

1542
suite('keyboardMapper', () => {
1543

1544
	ensureNoDisposablesAreLeakedInTestSuite();
1545

1546
	test('issue #23706: Linux UK layout: Ctrl + Apostrophe also toggles terminal', () => {
1547
		const mapper = new MacLinuxKeyboardMapper(false, {
1548
			'Backquote': {
1549
				'value': '`',
1550
				'withShift': '¬',
1551
				'withAltGr': '|',
1552
				'withShiftAltGr': '|'
1553
			}
1554
		}, false, OperatingSystem.Linux);
1555

1556
		assertResolveKeyboardEvent(
1557
			mapper,
1558
			{
1559
				_standardKeyboardEventBrand: true,
1560
				ctrlKey: true,
1561
				shiftKey: false,
1562
				altKey: false,
1563
				metaKey: false,
1564
				altGraphKey: false,
1565
				keyCode: -1,
1566
				code: 'Backquote'
1567
			},
1568
			{
1569
				label: 'Ctrl+`',
1570
				ariaLabel: 'Control+`',
1571
				electronAccelerator: null,
1572
				userSettingsLabel: 'ctrl+`',
1573
				isWYSIWYG: true,
1574
				isMultiChord: false,
1575
				dispatchParts: ['ctrl+[Backquote]'],
1576
				singleModifierDispatchParts: [null],
1577
			}
1578
		);
1579
	});
1580

1581
	test('issue #24064: NumLock/NumPad keys stopped working in 1.11 on Linux', () => {
1582
		const mapper = new MacLinuxKeyboardMapper(false, {}, false, OperatingSystem.Linux);
1583

1584
		function assertNumpadKeyboardEvent(keyCode: KeyCode, code: string, label: string, electronAccelerator: string | null, userSettingsLabel: string, dispatch: string): void {
1585
			assertResolveKeyboardEvent(
1586
				mapper,
1587
				{
1588
					_standardKeyboardEventBrand: true,
1589
					ctrlKey: false,
1590
					shiftKey: false,
1591
					altKey: false,
1592
					metaKey: false,
1593
					altGraphKey: false,
1594
					keyCode: keyCode,
1595
					code: code
1596
				},
1597
				{
1598
					label: label,
1599
					ariaLabel: label,
1600
					electronAccelerator: electronAccelerator,
1601
					userSettingsLabel: userSettingsLabel,
1602
					isWYSIWYG: true,
1603
					isMultiChord: false,
1604
					dispatchParts: [dispatch],
1605
					singleModifierDispatchParts: [null],
1606
				}
1607
			);
1608
		}
1609

1610
		assertNumpadKeyboardEvent(KeyCode.End, 'Numpad1', 'End', 'End', 'end', '[End]');
1611
		assertNumpadKeyboardEvent(KeyCode.DownArrow, 'Numpad2', 'DownArrow', 'Down', 'down', '[ArrowDown]');
1612
		assertNumpadKeyboardEvent(KeyCode.PageDown, 'Numpad3', 'PageDown', 'PageDown', 'pagedown', '[PageDown]');
1613
		assertNumpadKeyboardEvent(KeyCode.LeftArrow, 'Numpad4', 'LeftArrow', 'Left', 'left', '[ArrowLeft]');
1614
		assertNumpadKeyboardEvent(KeyCode.Unknown, 'Numpad5', 'NumPad5', null, 'numpad5', '[Numpad5]');
1615
		assertNumpadKeyboardEvent(KeyCode.RightArrow, 'Numpad6', 'RightArrow', 'Right', 'right', '[ArrowRight]');
1616
		assertNumpadKeyboardEvent(KeyCode.Home, 'Numpad7', 'Home', 'Home', 'home', '[Home]');
1617
		assertNumpadKeyboardEvent(KeyCode.UpArrow, 'Numpad8', 'UpArrow', 'Up', 'up', '[ArrowUp]');
1618
		assertNumpadKeyboardEvent(KeyCode.PageUp, 'Numpad9', 'PageUp', 'PageUp', 'pageup', '[PageUp]');
1619
		assertNumpadKeyboardEvent(KeyCode.Insert, 'Numpad0', 'Insert', 'Insert', 'insert', '[Insert]');
1620
		assertNumpadKeyboardEvent(KeyCode.Delete, 'NumpadDecimal', 'Delete', 'Delete', 'delete', '[Delete]');
1621
	});
1622

1623
	test('issue #24107: Delete, Insert, Home, End, PgUp, PgDn, and arrow keys no longer work editor in 1.11', () => {
1624
		const mapper = new MacLinuxKeyboardMapper(false, {}, false, OperatingSystem.Linux);
1625

1626
		function assertKeyboardEvent(keyCode: KeyCode, code: string, label: string, electronAccelerator: string, userSettingsLabel: string, dispatch: string): void {
1627
			assertResolveKeyboardEvent(
1628
				mapper,
1629
				{
1630
					_standardKeyboardEventBrand: true,
1631
					ctrlKey: false,
1632
					shiftKey: false,
1633
					altKey: false,
1634
					metaKey: false,
1635
					altGraphKey: false,
1636
					keyCode: keyCode,
1637
					code: code
1638
				},
1639
				{
1640
					label: label,
1641
					ariaLabel: label,
1642
					electronAccelerator: electronAccelerator,
1643
					userSettingsLabel: userSettingsLabel,
1644
					isWYSIWYG: true,
1645
					isMultiChord: false,
1646
					dispatchParts: [dispatch],
1647
					singleModifierDispatchParts: [null],
1648
				}
1649
			);
1650
		}
1651

1652
		// https://github.com/microsoft/vscode/issues/24107#issuecomment-292318497
1653
		assertKeyboardEvent(KeyCode.UpArrow, 'Lang3', 'UpArrow', 'Up', 'up', '[ArrowUp]');
1654
		assertKeyboardEvent(KeyCode.DownArrow, 'NumpadEnter', 'DownArrow', 'Down', 'down', '[ArrowDown]');
1655
		assertKeyboardEvent(KeyCode.LeftArrow, 'Convert', 'LeftArrow', 'Left', 'left', '[ArrowLeft]');
1656
		assertKeyboardEvent(KeyCode.RightArrow, 'NonConvert', 'RightArrow', 'Right', 'right', '[ArrowRight]');
1657
		assertKeyboardEvent(KeyCode.Delete, 'PrintScreen', 'Delete', 'Delete', 'delete', '[Delete]');
1658
		assertKeyboardEvent(KeyCode.Insert, 'NumpadDivide', 'Insert', 'Insert', 'insert', '[Insert]');
1659
		assertKeyboardEvent(KeyCode.End, 'Unknown', 'End', 'End', 'end', '[End]');
1660
		assertKeyboardEvent(KeyCode.Home, 'IntlRo', 'Home', 'Home', 'home', '[Home]');
1661
		assertKeyboardEvent(KeyCode.PageDown, 'ControlRight', 'PageDown', 'PageDown', 'pagedown', '[PageDown]');
1662
		assertKeyboardEvent(KeyCode.PageUp, 'Lang4', 'PageUp', 'PageUp', 'pageup', '[PageUp]');
1663

1664
		// https://github.com/microsoft/vscode/issues/24107#issuecomment-292323924
1665
		assertKeyboardEvent(KeyCode.PageDown, 'ControlRight', 'PageDown', 'PageDown', 'pagedown', '[PageDown]');
1666
		assertKeyboardEvent(KeyCode.PageUp, 'Lang4', 'PageUp', 'PageUp', 'pageup', '[PageUp]');
1667
		assertKeyboardEvent(KeyCode.End, '', 'End', 'End', 'end', '[End]');
1668
		assertKeyboardEvent(KeyCode.Home, 'IntlRo', 'Home', 'Home', 'home', '[Home]');
1669
		assertKeyboardEvent(KeyCode.Delete, 'PrintScreen', 'Delete', 'Delete', 'delete', '[Delete]');
1670
		assertKeyboardEvent(KeyCode.Insert, 'NumpadDivide', 'Insert', 'Insert', 'insert', '[Insert]');
1671
		assertKeyboardEvent(KeyCode.RightArrow, 'NonConvert', 'RightArrow', 'Right', 'right', '[ArrowRight]');
1672
		assertKeyboardEvent(KeyCode.LeftArrow, 'Convert', 'LeftArrow', 'Left', 'left', '[ArrowLeft]');
1673
		assertKeyboardEvent(KeyCode.DownArrow, 'NumpadEnter', 'DownArrow', 'Down', 'down', '[ArrowDown]');
1674
		assertKeyboardEvent(KeyCode.UpArrow, 'Lang3', 'UpArrow', 'Up', 'up', '[ArrowUp]');
1675
	});
1676
});
1677

1678
suite('keyboardMapper - LINUX ru', () => {
1679

1680
	ensureNoDisposablesAreLeakedInTestSuite();
1681

1682
	let mapper: MacLinuxKeyboardMapper;
1683

1684
	suiteSetup(async () => {
1685
		const _mapper = await createKeyboardMapper(false, 'linux_ru', false, OperatingSystem.Linux);
1686
		mapper = _mapper;
1687
	});
1688

1689
	test('mapping', () => {
1690
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'linux_ru.txt');
1691
	});
1692

1693
	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
1694
		assertResolveKeybinding(mapper, decodeKeybinding(k, OperatingSystem.Linux)!, expected);
1695
	}
1696

1697
	test('resolveKeybinding Ctrl+S', () => {
1698
		_assertResolveKeybinding(
1699
			KeyMod.CtrlCmd | KeyCode.KeyS,
1700
			[{
1701
				label: 'Ctrl+S',
1702
				ariaLabel: 'Control+S',
1703
				electronAccelerator: 'Ctrl+S',
1704
				userSettingsLabel: 'ctrl+s',
1705
				isWYSIWYG: true,
1706
				isMultiChord: false,
1707
				dispatchParts: ['ctrl+[KeyS]'],
1708
				singleModifierDispatchParts: [null],
1709
			}]
1710
		);
1711
	});
1712
});
1713

1714
suite('keyboardMapper - LINUX en_uk', () => {
1715

1716
	ensureNoDisposablesAreLeakedInTestSuite();
1717

1718
	let mapper: MacLinuxKeyboardMapper;
1719

1720
	suiteSetup(async () => {
1721
		const _mapper = await createKeyboardMapper(false, 'linux_en_uk', false, OperatingSystem.Linux);
1722
		mapper = _mapper;
1723
	});
1724

1725
	test('mapping', () => {
1726
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'linux_en_uk.txt');
1727
	});
1728

1729
	test('issue #24522: resolveKeyboardEvent Ctrl+Alt+[Minus]', () => {
1730
		assertResolveKeyboardEvent(
1731
			mapper,
1732
			{
1733
				_standardKeyboardEventBrand: true,
1734
				ctrlKey: true,
1735
				shiftKey: false,
1736
				altKey: true,
1737
				metaKey: false,
1738
				altGraphKey: false,
1739
				keyCode: -1,
1740
				code: 'Minus'
1741
			},
1742
			{
1743
				label: 'Ctrl+Alt+-',
1744
				ariaLabel: 'Control+Alt+-',
1745
				electronAccelerator: null,
1746
				userSettingsLabel: 'ctrl+alt+[Minus]',
1747
				isWYSIWYG: false,
1748
				isMultiChord: false,
1749
				dispatchParts: ['ctrl+alt+[Minus]'],
1750
				singleModifierDispatchParts: [null],
1751
			}
1752
		);
1753
	});
1754
});
1755

1756
suite('keyboardMapper - MAC zh_hant', () => {
1757

1758
	ensureNoDisposablesAreLeakedInTestSuite();
1759

1760
	let mapper: MacLinuxKeyboardMapper;
1761

1762
	suiteSetup(async () => {
1763
		const _mapper = await createKeyboardMapper(false, 'mac_zh_hant', false, OperatingSystem.Macintosh);
1764
		mapper = _mapper;
1765
	});
1766

1767
	test('mapping', () => {
1768
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'mac_zh_hant.txt');
1769
	});
1770

1771
	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
1772
		assertResolveKeybinding(mapper, decodeKeybinding(k, OperatingSystem.Macintosh)!, expected);
1773
	}
1774

1775
	test('issue #28237 resolveKeybinding Cmd+C', () => {
1776
		_assertResolveKeybinding(
1777
			KeyMod.CtrlCmd | KeyCode.KeyC,
1778
			[{
1779
				label: '⌘C',
1780
				ariaLabel: 'Command+C',
1781
				electronAccelerator: 'Cmd+C',
1782
				userSettingsLabel: 'cmd+c',
1783
				isWYSIWYG: true,
1784
				isMultiChord: false,
1785
				dispatchParts: ['meta+[KeyC]'],
1786
				singleModifierDispatchParts: [null],
1787
			}]
1788
		);
1789
	});
1790
});
1791

1792
suite('keyboardMapper - MAC zh_hant2', () => {
1793

1794
	ensureNoDisposablesAreLeakedInTestSuite();
1795

1796
	let mapper: MacLinuxKeyboardMapper;
1797

1798
	suiteSetup(async () => {
1799
		const _mapper = await createKeyboardMapper(false, 'mac_zh_hant2', false, OperatingSystem.Macintosh);
1800
		mapper = _mapper;
1801
	});
1802

1803
	test('mapping', () => {
1804
		return assertMapping(WRITE_FILE_IF_DIFFERENT, mapper, 'mac_zh_hant2.txt');
1805
	});
1806
});
1807

1808
function _assertKeybindingTranslation(mapper: MacLinuxKeyboardMapper, OS: OperatingSystem, kb: number, _expected: string | string[]): void {
1809
	let expected: string[];
1810
	if (typeof _expected === 'string') {
1811
		expected = [_expected];
1812
	} else if (Array.isArray(_expected)) {
1813
		expected = _expected;
1814
	} else {
1815
		expected = [];
1816
	}
1817

1818
	const runtimeKeybinding = createSimpleKeybinding(kb, OS);
1819

1820
	const keybindingLabel = new USLayoutResolvedKeybinding([runtimeKeybinding], OS).getUserSettingsLabel();
1821

1822
	const actualHardwareKeypresses = mapper.keyCodeChordToScanCodeChord(runtimeKeybinding);
1823
	if (actualHardwareKeypresses.length === 0) {
1824
		assert.deepStrictEqual([], expected, `simpleKeybindingToHardwareKeypress -- "${keybindingLabel}" -- actual: "[]" -- expected: "${expected}"`);
1825
		return;
1826
	}
1827

1828
	const actual = actualHardwareKeypresses
1829
		.map(k => UserSettingsLabelProvider.toLabel(OS, [k], (keybinding) => ScanCodeUtils.toString(keybinding.scanCode)));
1830
	assert.deepStrictEqual(actual, expected, `simpleKeybindingToHardwareKeypress -- "${keybindingLabel}" -- actual: "${actual}" -- expected: "${expected}"`);
1831
}
1832

1833
Product

Resources

Company
