Share test utils between keyboard mappers

src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts

@@ -11,6 +11,7 @@ import { CharCode } from 'vs/base/common/charCode';
 import { UILabelProvider, AriaLabelProvider, ElectronAcceleratorLabelProvider, UserSettingsLabelProvider } from 'vs/platform/keybinding/common/keybindingLabels';
 import { OperatingSystem } from 'vs/base/common/platform';
 import { IHTMLContentElement } from 'vs/base/common/htmlContent';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
 
 export interface IKeyMapping {
 	vkey: string;
@@ -173,7 +174,7 @@ export class WindowsNativeResolvedKeybinding extends ResolvedKeybinding {
 	}
 }
 
-export class WindowsKeyboardMapper {
+export class WindowsKeyboardMapper implements IKeyboardMapper {
 
 	private readonly _codeInfo: IHardwareCodeMapping[];
 	private readonly _hwToKb: KeyCode[];

src/vs/workbench/services/keybinding/test/keyboardMapperTestUtils.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as assert from 'assert';
+import { IHTMLContentElement } from 'vs/base/common/htmlContent';
+import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { Keybinding } from 'vs/base/common/keyCodes';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { readFile, writeFile } from 'vs/base/node/pfs';
+
+export interface IResolvedKeybinding {
+	label: string;
+	ariaLabel: string;
+	HTMLLabel: IHTMLContentElement[];
+	electronAccelerator: string;
+	userSettingsLabel: string;
+	isChord: boolean;
+	hasCtrlModifier: boolean;
+	hasShiftModifier: boolean;
+	hasAltModifier: boolean;
+	hasMetaModifier: boolean;
+	dispatchParts: [string, string];
+}
+
+export function assertResolveKeybinding(mapper: IKeyboardMapper, keybinding: Keybinding, expected: IResolvedKeybinding[]): void {
+	let actual: IResolvedKeybinding[] = mapper.resolveKeybinding(keybinding).map((kb => {
+		return {
+			label: kb.getLabel(),
+			ariaLabel: kb.getAriaLabel(),
+			HTMLLabel: kb.getHTMLLabel(),
+			electronAccelerator: kb.getElectronAccelerator(),
+			userSettingsLabel: kb.getUserSettingsLabel(),
+			isChord: kb.isChord(),
+			hasCtrlModifier: kb.hasCtrlModifier(),
+			hasShiftModifier: kb.hasShiftModifier(),
+			hasAltModifier: kb.hasAltModifier(),
+			hasMetaModifier: kb.hasMetaModifier(),
+			dispatchParts: kb.getDispatchParts(),
+		};
+	}));
+	assert.deepEqual(actual, expected);
+}
+
+function _htmlPieces(pieces: string[]): IHTMLContentElement[] {
+	let children: IHTMLContentElement[] = [];
+	for (let i = 0, len = pieces.length; i < len; i++) {
+		if (i !== 0) {
+			children.push({ tagName: 'span', text: '+' });
+		}
+		children.push({ tagName: 'span', className: 'monaco-kbkey', text: pieces[i] });
+	}
+	return children;
+}
+
+export function simpleHTMLLabel(pieces: string[]): IHTMLContentElement {
+	return {
+		tagName: 'span',
+		className: 'monaco-kb',
+		children: _htmlPieces(pieces)
+	};
+}
+
+export function chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement {
+	return {
+		tagName: 'span',
+		className: 'monaco-kb',
+		children: [].concat(
+			_htmlPieces(firstPart),
+			[{ tagName: 'span', text: ' ' }],
+			_htmlPieces(chordPart)
+		)
+	};
+}
+
+export function readRawMapping<T>(file: string): TPromise<T> {
+	return readFile(require.toUrl(`vs/workbench/services/keybinding/test/${file}.js`)).then((buff) => {
+		let contents = buff.toString();
+		let func = new Function('define', contents);
+		let rawMappings: T = null;
+		func(function (value) {
+			rawMappings = value;
+		});
+		return rawMappings;
+	});
+}
+
+export function assertMapping(mapper: IKeyboardMapper, file: string, done: (err?: any) => void): void {
+	const filePath = require.toUrl(`vs/workbench/services/keybinding/test/${file}`);
+
+	readFile(filePath).then((buff) => {
+		let expected = buff.toString();
+		const actual = mapper.dumpDebugInfo();
+		if (actual !== expected) {
+			writeFile(filePath, actual);
+		}
+		try {
+			assert.deepEqual(actual, expected);
+		} catch (err) {
+			return done(err);
+		}
+		done();
+	}, done);
+}

src/vs/workbench/services/keybinding/test/keyboardMapper.test.ts → src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts

@@ -7,48 +7,24 @@
 
 import * as assert from 'assert';
 import { KeyMod, KeyCode, createKeybinding, SimpleKeybinding, Keybinding } from 'vs/base/common/keyCodes';
-import { KeyboardMapper, IKeyboardMapping } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { MacLinuxKeyboardMapper, IKeyboardMapping } from 'vs/workbench/services/keybinding/common/macLinuxKeyboardMapper';
 import { OperatingSystem } from 'vs/base/common/platform';
 import { UserSettingsLabelProvider } from 'vs/platform/keybinding/common/keybindingLabels';
 import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
 import { KeyboardEventCodeUtils } from 'vs/workbench/services/keybinding/common/keyboardEventCode';
 import { IHTMLContentElement } from 'vs/base/common/htmlContent';
-import { readFile, writeFile } from 'vs/base/node/pfs';
 import { TPromise } from 'vs/base/common/winjs.base';
+import { readRawMapping, assertMapping } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils';
 
-function createKeyboardMapper(file: string, OS: OperatingSystem): TPromise<KeyboardMapper> {
-	return readFile(require.toUrl(`vs/workbench/services/keybinding/test/${file}.js`)).then((buff) => {
-		let contents = buff.toString();
-		let func = new Function('define', contents);
-		let rawMappings: IKeyboardMapping = null;
-		func(function (value) {
-			rawMappings = value;
-		});
-		return new KeyboardMapper(rawMappings, OS);
+function createKeyboardMapper(file: string, OS: OperatingSystem): TPromise<MacLinuxKeyboardMapper> {
+	return readRawMapping<IKeyboardMapping>(file).then((rawMappings) => {
+		return new MacLinuxKeyboardMapper(rawMappings, OS);
 	});
 }
 
-function assertMapping(mapper: KeyboardMapper, file: string, done: (err?: any) => void): void {
-	const filePath = require.toUrl(`vs/workbench/services/keybinding/test/${file}`);
-
-	readFile(filePath).then((buff) => {
-		let expected = buff.toString();
-		const actual = mapper.dumpDebugInfo();
-		if (actual !== expected) {
-			writeFile(filePath, actual);
-		}
-		try {
-			assert.deepEqual(actual, expected);
-		} catch (err) {
-			return done(err);
-		}
-		done();
-	}, done);
-}
-
 suite('keyboardMapper - MAC de_ch', () => {
 
-	let mapper: KeyboardMapper;
+	let mapper: MacLinuxKeyboardMapper;
 
 	suiteSetup((done) => {
 		createKeyboardMapper('mac_de_ch', OperatingSystem.Macintosh).then((_mapper) => {
@@ -120,7 +96,7 @@ suite('keyboardMapper - MAC de_ch', () => {
 
 suite('keyboardMapper - LINUX de_ch', () => {
 
-	let mapper: KeyboardMapper;
+	let mapper: MacLinuxKeyboardMapper;
 
 	suiteSetup((done) => {
 		createKeyboardMapper('linux_de_ch', OperatingSystem.Linux).then((_mapper) => {
@@ -155,7 +131,7 @@ suite('keyboardMapper - LINUX de_ch', () => {
 
 suite('keyboardMapper - LINUX de_ch', () => {
 
-	let mapper: KeyboardMapper;
+	let mapper: MacLinuxKeyboardMapper;
 
 	suiteSetup((done) => {
 		createKeyboardMapper('linux_en_us', OperatingSystem.Linux).then((_mapper) => {
@@ -169,7 +145,7 @@ suite('keyboardMapper - LINUX de_ch', () => {
 	});
 });
 
-function _assertKeybindingTranslation(mapper: KeyboardMapper, OS: OperatingSystem, kb: number, _expected: string | string[]): void {
+function _assertKeybindingTranslation(mapper: MacLinuxKeyboardMapper, OS: OperatingSystem, kb: number, _expected: string | string[]): void {
 	let expected: string[];
 	if (typeof _expected === 'string') {
 		expected = [_expected];

src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts

@@ -5,108 +5,20 @@
 
 'use strict';
 
-import * as assert from 'assert';
 import { OperatingSystem } from 'vs/base/common/platform';
-import { readFile, writeFile } from 'vs/base/node/pfs';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { WindowsKeyboardMapper, IKeyboardMapping } from 'vs/workbench/services/keybinding/common/windowsKeyboardMapper';
 import { createKeybinding, KeyMod, KeyCode, KeyChord } from 'vs/base/common/keyCodes';
-import { IHTMLContentElement } from 'vs/base/common/htmlContent';
+import { IResolvedKeybinding, assertResolveKeybinding, readRawMapping, assertMapping, simpleHTMLLabel, chordHTMLLabel } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils';
 
-function createKeyboardMapper(file: string, OS: OperatingSystem): TPromise<WindowsKeyboardMapper> {
-	return readFile(require.toUrl(`vs/workbench/services/keybinding/test/${file}.js`)).then((buff) => {
-		let contents = buff.toString();
-		let func = new Function('define', contents);
-		let rawMappings: IKeyboardMapping = null;
-		func(function (value) {
-			rawMappings = value;
-		});
+function createKeyboardMapper(file: string): TPromise<WindowsKeyboardMapper> {
+	return readRawMapping<IKeyboardMapping>(file).then((rawMappings) => {
 		return new WindowsKeyboardMapper(rawMappings);
 	});
 }
 
-function assertMapping(mapper: WindowsKeyboardMapper, file: string, done: (err?: any) => void): void {
-	const filePath = require.toUrl(`vs/workbench/services/keybinding/test/${file}`);
-
-	readFile(filePath).then((buff) => {
-		let expected = buff.toString();
-		const actual = mapper.dumpDebugInfo();
-		if (actual !== expected) {
-			writeFile(filePath, actual);
-		}
-		try {
-			assert.deepEqual(actual, expected);
-		} catch (err) {
-			return done(err);
-		}
-		done();
-	}, done);
-}
-
-function _htmlPieces(pieces: string[]): IHTMLContentElement[] {
-	let children: IHTMLContentElement[] = [];
-	for (let i = 0, len = pieces.length; i < len; i++) {
-		if (i !== 0) {
-			children.push({ tagName: 'span', text: '+' });
-		}
-		children.push({ tagName: 'span', className: 'monaco-kbkey', text: pieces[i] });
-	}
-	return children;
-}
-
-function simpleHTMLLabel(pieces: string[]): IHTMLContentElement {
-	return {
-		tagName: 'span',
-		className: 'monaco-kb',
-		children: _htmlPieces(pieces)
-	};
-}
-
-function chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement {
-	return {
-		tagName: 'span',
-		className: 'monaco-kb',
-		children: [].concat(
-			_htmlPieces(firstPart),
-			[{ tagName: 'span', text: ' ' }],
-			_htmlPieces(chordPart)
-		)
-	};
-}
-
-interface IResolvedKeybindingExpected {
-	label: string;
-	ariaLabel: string;
-	HTMLLabel: IHTMLContentElement[];
-	electronAccelerator: string;
-	userSettingsLabel: string;
-	isChord: boolean;
-	hasCtrlModifier: boolean;
-	hasShiftModifier: boolean;
-	hasAltModifier: boolean;
-	hasMetaModifier: boolean;
-	dispatchParts: [string, string];
-}
-
-function _assertResolvedKeybinding(mapper: WindowsKeyboardMapper, k: number, expected: IResolvedKeybindingExpected): void {
-	let kbs = mapper.resolveKeybinding(createKeybinding(k, OperatingSystem.Windows));
-	assert.equal(kbs.length, 1);
-	let kb = kbs[0];
-
-	let actual: IResolvedKeybindingExpected = {
-		label: kb.getLabel(),
-		ariaLabel: kb.getAriaLabel(),
-		HTMLLabel: kb.getHTMLLabel(),
-		electronAccelerator: kb.getElectronAccelerator(),
-		userSettingsLabel: kb.getUserSettingsLabel(),
-		isChord: kb.isChord(),
-		hasCtrlModifier: kb.hasCtrlModifier(),
-		hasShiftModifier: kb.hasShiftModifier(),
-		hasAltModifier: kb.hasAltModifier(),
-		hasMetaModifier: kb.hasMetaModifier(),
-		dispatchParts: kb.getDispatchParts(),
-	};
-	assert.deepEqual(actual, expected);
+function _assertResolveKeybinding(mapper: WindowsKeyboardMapper, k: number, expected: IResolvedKeybinding): void {
+	assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Windows), [expected]);
 }
 
 suite('keyboardMapper - WINDOWS de_ch', () => {
@@ -114,7 +26,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 	let mapper: WindowsKeyboardMapper;
 
 	suiteSetup((done) => {
-		createKeyboardMapper('win_de_ch', OperatingSystem.Macintosh).then((_mapper) => {
+		createKeyboardMapper('win_de_ch').then((_mapper) => {
 			mapper = _mapper;
 			done();
 		}, done);
@@ -124,12 +36,9 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		assertMapping(mapper, 'win_de_ch.txt', done);
 	});
 
-	function assertResolveKeybinding(kb: number, expected: IResolvedKeybindingExpected): void {
-		_assertResolvedKeybinding(mapper, kb, expected);
-	}
-
 	test('resolveKeybinding Ctrl+A', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyMod.CtrlCmd | KeyCode.KEY_A,
 			{
 				label: 'Ctrl+A',
@@ -148,7 +57,8 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 	});
 
 	test('resolveKeybinding Ctrl+Z', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyMod.CtrlCmd | KeyCode.KEY_Z,
 			{
 				label: 'Ctrl+Z',
@@ -167,7 +77,8 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 	});
 
 	test('resolveKeybinding Ctrl+]', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET,
 			{
 				label: 'Ctrl+^',
@@ -186,7 +97,8 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 	});
 
 	test('resolveKeybinding Ctrl+/', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyMod.CtrlCmd | KeyCode.US_SLASH,
 			{
 				label: 'Ctrl+§',
@@ -205,7 +117,8 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 	});
 
 	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
 			{
 				label: 'Ctrl+K Ctrl+ä',
@@ -229,7 +142,7 @@ suite('keyboardMapper - WINDOWS en_us', () => {
 	let mapper: WindowsKeyboardMapper;
 
 	suiteSetup((done) => {
-		createKeyboardMapper('win_en_us', OperatingSystem.Macintosh).then((_mapper) => {
+		createKeyboardMapper('win_en_us').then((_mapper) => {
 			mapper = _mapper;
 			done();
 		}, done);
@@ -239,12 +152,9 @@ suite('keyboardMapper - WINDOWS en_us', () => {
 		assertMapping(mapper, 'win_en_us.txt', done);
 	});
 
-	function assertResolveKeybinding(kb: number, expected: IResolvedKeybindingExpected): void {
-		_assertResolvedKeybinding(mapper, kb, expected);
-	}
-
 	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
-		assertResolveKeybinding(
+		_assertResolveKeybinding(
+			mapper,
 			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
 			{
 				label: 'Ctrl+K Ctrl+\\',