diff --git a/src/vs/base/common/keyCodes.ts b/src/vs/base/common/keyCodes.ts
index 72385cc019c4..6598111d23a2 100644
--- a/src/vs/base/common/keyCodes.ts
+++ b/src/vs/base/common/keyCodes.ts
@@ -306,6 +306,7 @@ let STRING = createMapping((TO_STRING_MAP) => {
 	TO_STRING_MAP[KeyCode.KEY_Y] = 'Y';
 	TO_STRING_MAP[KeyCode.KEY_Z] = 'Z';
 
+	TO_STRING_MAP[KeyCode.Meta] = 'Meta';
 	TO_STRING_MAP[KeyCode.ContextMenu] = 'ContextMenu';
 
 	TO_STRING_MAP[KeyCode.F1] = 'F1';
diff --git a/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts b/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts
index d516b9c0d959..f2dcf3647987 100644
--- a/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts
+++ b/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts
@@ -177,7 +177,7 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper {
 				if (immutableKeyCode === KeyCode.Unknown || immutableKeyCode === KeyCode.Ctrl || immutableKeyCode === KeyCode.Meta || immutableKeyCode === KeyCode.Alt || immutableKeyCode === KeyCode.Shift) {
 					this._hwToDispatch[code] = null; // cannot dispatch on this hw code
 				} else {
-					this._hwToDispatch[code] = KeyCodeUtils.toString(immutableKeyCode);
+					this._hwToDispatch[code] = `[${KeyboardEventCodeUtils.toString(code)}]`;
 				}
 			}
 		}
@@ -377,8 +377,11 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper {
 
 		this._hwToKb[hwEncoded] = kbEncoded;
 
-		this._kbToHw[kbEncoded] = this._kbToHw[kbEncoded] || [];
-		this._kbToHw[kbEncoded].unshift(hwEncoded);
+		if (keyCode !== KeyCode.Unknown) {
+			// Do not save an inverse lookup for Unknown
+			this._kbToHw[kbEncoded] = this._kbToHw[kbEncoded] || [];
+			this._kbToHw[kbEncoded].unshift(hwEncoded);
+		}
 	}
 
 	private _registerAllCombos1(
@@ -568,6 +571,22 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper {
 	}
 
 	private _getStableKeyCodeForHWCode(code: KeyboardEventCode): KeyCode {
+		if (code >= KeyboardEventCode.Digit1 && code <= KeyboardEventCode.Digit0) {
+			// digits are ok
+			switch (code) {
+				case KeyboardEventCode.Digit1: return KeyCode.KEY_1;
+				case KeyboardEventCode.Digit2: return KeyCode.KEY_2;
+				case KeyboardEventCode.Digit3: return KeyCode.KEY_3;
+				case KeyboardEventCode.Digit4: return KeyCode.KEY_4;
+				case KeyboardEventCode.Digit5: return KeyCode.KEY_5;
+				case KeyboardEventCode.Digit6: return KeyCode.KEY_6;
+				case KeyboardEventCode.Digit7: return KeyCode.KEY_7;
+				case KeyboardEventCode.Digit8: return KeyCode.KEY_8;
+				case KeyboardEventCode.Digit9: return KeyCode.KEY_9;
+				case KeyboardEventCode.Digit0: return KeyCode.KEY_0;
+			}
+		}
+
 		// Check if this hw code always maps to the same kb code and back
 		let constantKeyCode: KeyCode = -1;
 		for (let mod = 0; mod < 8; mod++) {
@@ -575,6 +594,11 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper {
 			const kbEncoded = this._hwToKb[hwEncoded];
 			const keyCode = (kbEncoded >>> 3);
 
+			if (keyCode === KeyCode.Unknown) {
+				// maps to unknown keyCode
+				return -1;
+			}
+
 			if (constantKeyCode === -1) {
 				constantKeyCode = keyCode;
 			} else if (constantKeyCode !== keyCode) {
diff --git a/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts b/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts
index c7daa1c28ee1..a94f8dd0313a 100644
--- a/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts
+++ b/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts
@@ -179,10 +179,12 @@ export class WindowsKeyboardMapper implements IKeyboardMapper {
 	private readonly _codeInfo: IHardwareCodeMapping[];
 	private readonly _hwToKb: KeyCode[];
 	private readonly _kbToLabel: string[] = [];
+	private readonly _kbExists: boolean[];
 
 	constructor(rawMappings: IKeyboardMapping) {
 		this._hwToKb = [];
 		this._kbToLabel = [];
+		this._kbExists = [];
 		this._kbToLabel[KeyCode.Unknown] = KeyCodeUtils.toString(KeyCode.Unknown);
 
 		for (let code = KeyboardEventCode.None; code < KeyboardEventCode.MAX_VALUE; code++) {
@@ -190,6 +192,7 @@ export class WindowsKeyboardMapper implements IKeyboardMapper {
 			if (immutableKeyCode !== -1) {
 				this._hwToKb[code] = immutableKeyCode;
 				this._kbToLabel[immutableKeyCode] = KeyCodeUtils.toString(immutableKeyCode);
+				this._kbExists[immutableKeyCode] = true;
 			}
 		}
 
@@ -223,6 +226,7 @@ export class WindowsKeyboardMapper implements IKeyboardMapper {
 				this._codeInfo[code] = mapping;
 
 				if (keyCode !== KeyCode.Unknown) {
+					this._kbExists[keyCode] = true;
 					if (value >= CharCode.a && value <= CharCode.z) {
 						this._kbToLabel[keyCode] = String.fromCharCode(CharCode.A + (value - CharCode.a));
 					} else if (value) {
@@ -328,8 +332,17 @@ export class WindowsKeyboardMapper implements IKeyboardMapper {
 
 	public resolveKeybinding(keybinding: Keybinding): WindowsNativeResolvedKeybinding[] {
 		if (keybinding.type === KeybindingType.Chord) {
+			let firstPartKeyCode = keybinding.firstPart.keyCode;
+			let chordPartKeyCode = keybinding.chordPart.keyCode;
+			if (!this._kbExists[firstPartKeyCode] || !this._kbExists[chordPartKeyCode]) {
+				return [];
+			}
 			return [new WindowsNativeResolvedKeybinding(this, keybinding.firstPart, keybinding.chordPart)];
 		} else {
+			let keyCode = keybinding.keyCode;
+			if (!this._kbExists[keyCode]) {
+				return [];
+			}
 			return [new WindowsNativeResolvedKeybinding(this, keybinding, null)];
 		}
 	}
diff --git a/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts b/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts
index b37842040381..fa0817b1639a 100644
--- a/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts
+++ b/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts
@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import { KeyMod, KeyCode, createKeybinding, SimpleKeybinding, Keybinding } from 'vs/base/common/keyCodes';
+import { KeyMod, KeyCode, createKeybinding, SimpleKeybinding, KeyChord } from 'vs/base/common/keyCodes';
 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';
@@ -14,7 +14,7 @@ import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayo
 import { KeyboardEventCodeUtils } from 'vs/workbench/services/keybinding/common/keyboardEventCode';
 import { IHTMLContentElement } from 'vs/base/common/htmlContent';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { readRawMapping, assertMapping, IResolvedKeybinding, assertResolveKeybinding, simpleHTMLLabel } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils';
+import { readRawMapping, assertMapping, IResolvedKeybinding, assertResolveKeybinding, simpleHTMLLabel, chordHTMLLabel } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils';
 
 function createKeyboardMapper(file: string, OS: OperatingSystem): TPromise<MacLinuxKeyboardMapper> {
 	return readRawMapping<IKeyboardMapping>(file).then((rawMappings) => {
@@ -49,9 +49,9 @@ suite('keyboardMapper - MAC de_ch', () => {
 		return simpleHTMLLabel(pieces, OperatingSystem.Macintosh);
 	}
 
-	// function _chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement {
-	// 	return chordHTMLLabel(firstPart, chordPart, OperatingSystem.Macintosh);
-	// }
+	function _chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement {
+		return chordHTMLLabel(firstPart, chordPart, OperatingSystem.Macintosh);
+	}
 
 	test('kb => hw', () => {
 		// unchanged
@@ -68,42 +68,6 @@ suite('keyboardMapper - MAC de_ch', () => {
 		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_SLASH, 'shift+cmd+Digit7');
 	});
 
-	test('resolveKeybinding', () => {
-		function _assertAllLabels(keybinding: Keybinding, labels: string[], ariaLabels: string[], htmlLabel: IHTMLContentElement[][]): void {
-			const kb = mapper.resolveKeybinding(keybinding);
-
-			let actualLabels = kb.map(k => k.getLabel());
-			assert.deepEqual(actualLabels, labels);
-
-			let actualAriaLabels = kb.map(k => k.getAriaLabel());
-			assert.deepEqual(actualAriaLabels, ariaLabels);
-
-			let actualHTMLLabels = kb.map(k => k.getHTMLLabel());
-			assert.deepEqual(actualHTMLLabels, htmlLabel);
-		}
-
-		function assertAllLabels(keybinding: Keybinding, label: string | string[], ariaLabel: string | string[], htmlLabel: IHTMLContentElement[][]): void {
-			let _labels = (typeof label === 'string' ? [label] : label);
-			let _ariaLabels = (typeof ariaLabel === 'string' ? [ariaLabel] : ariaLabel);
-			_assertAllLabels(keybinding, _labels, _ariaLabels, htmlLabel);
-		}
-
-		// TODO: ElectronAccelerator, UserSettings
-		assertAllLabels(
-			createKeybinding(KeyMod.CtrlCmd | KeyCode.KEY_Z, OperatingSystem.Macintosh),
-			'⌘Z',
-			'Command+Z',
-			[[{
-				tagName: 'span',
-				className: 'monaco-kb',
-				children: [
-					{ tagName: 'span', className: 'monaco-kbkey', text: '⌘' },
-					{ tagName: 'span', className: 'monaco-kbkey', text: 'Z' },
-				]
-			}]]
-		);
-	});
-
 	// TODO: missing
 	test('resolveKeybinding Cmd+A', () => {
 		_assertResolveKeybinding(
@@ -131,6 +95,176 @@ suite('keyboardMapper - MAC de_ch', () => {
 		);
 	});
 
+	test('resolveKeybinding Cmd+Z', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.KEY_Z,
+			[{
+				label: '⌘Z',
+				ariaLabel: 'Command+Z',
+				HTMLLabel: [_simpleHTMLLabel(['⌘', 'Z'])],
+				electronAccelerator: 'Cmd+Z',
+				userSettingsLabel: 'cmd+z',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: true,
+				dispatchParts: ['meta+[KeyY]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+]', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: '⌃⌥⌘6',
+				ariaLabel: 'Control+Alt+Command+6',
+				HTMLLabel: [_simpleHTMLLabel(['⌃', '⌥', '⌘', '6'])],
+				electronAccelerator: 'Ctrl+Alt+Cmd+6',
+				userSettingsLabel: 'ctrl+alt+cmd+6',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: true,
+				hasMetaModifier: true,
+				dispatchParts: ['ctrl+alt+meta+[Digit6]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Shift+]', () => {
+		_assertResolveKeybinding(
+			KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: '⌃⌥9',
+				ariaLabel: 'Control+Alt+9',
+				HTMLLabel: [_simpleHTMLLabel(['⌃', '⌥', '9'])],
+				electronAccelerator: 'Ctrl+Alt+9',
+				userSettingsLabel: 'ctrl+alt+9',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: true,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+alt+[Digit9]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+/', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.US_SLASH,
+			[{
+				label: '⇧⌘7',
+				ariaLabel: 'Shift+Command+7',
+				HTMLLabel: [_simpleHTMLLabel(['⇧', '⌘', '7'])],
+				electronAccelerator: 'Shift+Cmd+7',
+				userSettingsLabel: 'shift+cmd+7',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: true,
+				dispatchParts: ['shift+meta+[Digit7]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+Shift+/', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH,
+			[{
+				label: '⇧⌘\'',
+				ariaLabel: 'Shift+Command+\'',
+				HTMLLabel: [_simpleHTMLLabel(['⇧', '⌘', '\''])],
+				electronAccelerator: null,
+				userSettingsLabel: 'shift+cmd+[Minus]',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: true,
+				dispatchParts: ['shift+meta+[Minus]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+K Cmd+\\', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
+			[{
+				label: '⌘K ⌃⇧⌥⌘7',
+				ariaLabel: 'Command+K Control+Shift+Alt+Command+7',
+				HTMLLabel: [_chordHTMLLabel(['⌘', 'K'], ['⌃', '⇧', '⌥', '⌘', '7'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd+k ctrl+shift+alt+cmd+7',
+				isChord: true,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['meta+[KeyK]', 'ctrl+shift+alt+meta+[Digit7]'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+K Cmd+=', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[{
+				label: '⌘K ⇧⌘0',
+				ariaLabel: 'Command+K Shift+Command+0',
+				HTMLLabel: [_chordHTMLLabel(['⌘', 'K'], ['⇧', '⌘', '0'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd+k shift+cmd+0',
+				isChord: true,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['meta+[KeyK]', 'shift+meta+[Digit0]'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+DownArrow', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.DownArrow,
+			[{
+				label: '⌘↓',
+				ariaLabel: 'Command+DownArrow',
+				HTMLLabel: [_simpleHTMLLabel(['⌘', '↓'])],
+				electronAccelerator: 'Cmd+Down',
+				userSettingsLabel: 'cmd+down',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: true,
+				dispatchParts: ['meta+[ArrowDown]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Cmd+NUMPAD_0', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.NUMPAD_0,
+			[{
+				label: '⌘NumPad0',
+				ariaLabel: 'Command+NumPad0',
+				HTMLLabel: [_simpleHTMLLabel(['⌘', 'NumPad0'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'cmd+numpad0',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: true,
+				dispatchParts: ['meta+[Numpad0]', null],
+			}]
+		);
+	});
 });
 
 suite('keyboardMapper - LINUX de_ch', () => {
@@ -152,6 +286,18 @@ suite('keyboardMapper - LINUX de_ch', () => {
 		_assertKeybindingTranslation(mapper, OperatingSystem.Linux, kb, expected);
 	}
 
+	function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void {
+		assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Linux), expected);
+	}
+
+	function _simpleHTMLLabel(pieces: string[]): IHTMLContentElement {
+		return simpleHTMLLabel(pieces, OperatingSystem.Linux);
+	}
+
+	function _chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement {
+		return chordHTMLLabel(firstPart, chordPart, OperatingSystem.Linux);
+	}
+
 	test('kb => hw', () => {
 		// unchanged
 		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KEY_1, 'ctrl+Digit1');
@@ -166,6 +312,184 @@ suite('keyboardMapper - LINUX de_ch', () => {
 		// Ctrl+/
 		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_SLASH, 'ctrl+shift+Digit7');
 	});
+
+	test('resolveKeybinding Ctrl+A', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.KEY_A,
+			[{
+				label: 'Ctrl+A',
+				ariaLabel: 'Control+A',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'A'])],
+				electronAccelerator: 'Ctrl+A',
+				userSettingsLabel: 'ctrl+a',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+[KeyA]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Z', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.KEY_Z,
+			[{
+				label: 'Ctrl+Z',
+				ariaLabel: 'Control+Z',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])],
+				electronAccelerator: 'Ctrl+Z',
+				userSettingsLabel: 'ctrl+z',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+[KeyY]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+]', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[]
+		);
+	});
+
+	test('resolveKeybinding Shift+]', () => {
+		_assertResolveKeybinding(
+			KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: 'Ctrl+Alt+0',
+				ariaLabel: 'Control+Alt+0',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Alt', '0'])],
+				electronAccelerator: 'Ctrl+Alt+0',
+				userSettingsLabel: 'ctrl+alt+0',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: true,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+alt+[Digit0]', null],
+			}, {
+				label: 'Ctrl+Alt+$',
+				ariaLabel: 'Control+Alt+$',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Alt', '$'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+alt+[Backslash]',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: true,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+alt+[Backslash]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+/', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.US_SLASH,
+			[{
+				label: 'Ctrl+Shift+7',
+				ariaLabel: 'Control+Shift+7',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Shift', '7'])],
+				electronAccelerator: 'Ctrl+Shift+7',
+				userSettingsLabel: 'ctrl+shift+7',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+shift+[Digit7]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Shift+/', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH,
+			[{
+				label: 'Ctrl+Shift+\'',
+				ariaLabel: 'Control+Shift+\'',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Shift', '\''])],
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+shift+[Minus]',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+shift+[Minus]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+\\', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
+			[]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
+		_assertResolveKeybinding(
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[{
+				label: 'Ctrl+K Ctrl+Shift+0',
+				ariaLabel: 'Control+K Control+Shift+0',
+				HTMLLabel: [_chordHTMLLabel(['Ctrl', 'K'], ['Ctrl', 'Shift', '0'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+k ctrl+shift+0',
+				isChord: true,
+				hasCtrlModifier: false,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+[KeyK]', 'ctrl+shift+[Digit0]'],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+DownArrow', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.DownArrow,
+			[{
+				label: 'Ctrl+DownArrow',
+				ariaLabel: 'Control+DownArrow',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'DownArrow'])],
+				electronAccelerator: 'Ctrl+Down',
+				userSettingsLabel: 'ctrl+down',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+[ArrowDown]', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+NUMPAD_0', () => {
+		_assertResolveKeybinding(
+			KeyMod.CtrlCmd | KeyCode.NUMPAD_0,
+			[{
+				label: 'Ctrl+NumPad0',
+				ariaLabel: 'Control+NumPad0',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'NumPad0'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+numpad0',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+[Numpad0]', null],
+			}]
+		);
+	});
 });
 
 suite('keyboardMapper - LINUX de_ch', () => {
diff --git a/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts b/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts
index b992215cbf64..f55591911e71 100644
--- a/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts
+++ b/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts
@@ -18,8 +18,8 @@ function createKeyboardMapper(file: string): TPromise<WindowsKeyboardMapper> {
 	});
 }
 
-function _assertResolveKeybinding(mapper: WindowsKeyboardMapper, k: number, expected: IResolvedKeybinding): void {
-	assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Windows), [expected]);
+function _assertResolveKeybinding(mapper: WindowsKeyboardMapper, k: number, expected: IResolvedKeybinding[]): void {
+	assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Windows), expected);
 }
 
 function _simpleHTMLLabel(pieces: string[]): IHTMLContentElement {
@@ -49,7 +49,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyMod.CtrlCmd | KeyCode.KEY_A,
-			{
+			[{
 				label: 'Ctrl+A',
 				ariaLabel: 'Control+A',
 				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'A'])],
@@ -61,7 +61,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+A', null],
-			}
+			}]
 		);
 	});
 
@@ -69,7 +69,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyMod.CtrlCmd | KeyCode.KEY_Z,
-			{
+			[{
 				label: 'Ctrl+Z',
 				ariaLabel: 'Control+Z',
 				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])],
@@ -81,7 +81,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+Z', null],
-			}
+			}]
 		);
 	});
 
@@ -89,7 +89,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET,
-			{
+			[{
 				label: 'Ctrl+^',
 				ariaLabel: 'Control+^',
 				HTMLLabel: [_simpleHTMLLabel(['Ctrl', '^'])],
@@ -101,7 +101,28 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+]', null],
-			}
+			}]
+		);
+	});
+
+
+	test('resolveKeybinding Shift+]', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET,
+			[{
+				label: 'Shift+^',
+				ariaLabel: 'Shift+^',
+				HTMLLabel: [_simpleHTMLLabel(['Shift', '^'])],
+				electronAccelerator: 'Shift+]',
+				userSettingsLabel: 'shift+]',
+				isChord: false,
+				hasCtrlModifier: false,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['shift+]', null],
+			}]
 		);
 	});
 
@@ -109,7 +130,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyMod.CtrlCmd | KeyCode.US_SLASH,
-			{
+			[{
 				label: 'Ctrl+§',
 				ariaLabel: 'Control+§',
 				HTMLLabel: [_simpleHTMLLabel(['Ctrl', '§'])],
@@ -121,7 +142,27 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+/', null],
-			}
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+Shift+/', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH,
+			[{
+				label: 'Ctrl+Shift+§',
+				ariaLabel: 'Control+Shift+§',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Shift', '§'])],
+				electronAccelerator: 'Ctrl+Shift+/',
+				userSettingsLabel: 'ctrl+shift+/',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: true,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+shift+/', null],
+			}]
 		);
 	});
 
@@ -129,7 +170,7 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
-			{
+			[{
 				label: 'Ctrl+K Ctrl+ä',
 				ariaLabel: 'Control+K Control+ä',
 				HTMLLabel: [_chordHTMLLabel(['Ctrl', 'K'], ['Ctrl', 'ä'])],
@@ -141,7 +182,55 @@ suite('keyboardMapper - WINDOWS de_ch', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+K', 'ctrl+\\'],
-			}
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+K Ctrl+=', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL),
+			[]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+DownArrow', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.DownArrow,
+			[{
+				label: 'Ctrl+DownArrow',
+				ariaLabel: 'Control+DownArrow',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'DownArrow'])],
+				electronAccelerator: 'Ctrl+Down',
+				userSettingsLabel: 'ctrl+down',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+DownArrow', null],
+			}]
+		);
+	});
+
+	test('resolveKeybinding Ctrl+NUMPAD_0', () => {
+		_assertResolveKeybinding(
+			mapper,
+			KeyMod.CtrlCmd | KeyCode.NUMPAD_0,
+			[{
+				label: 'Ctrl+NumPad0',
+				ariaLabel: 'Control+NumPad0',
+				HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'NumPad0'])],
+				electronAccelerator: null,
+				userSettingsLabel: 'ctrl+numpad0',
+				isChord: false,
+				hasCtrlModifier: true,
+				hasShiftModifier: false,
+				hasAltModifier: false,
+				hasMetaModifier: false,
+				dispatchParts: ['ctrl+NumPad0', null],
+			}]
 		);
 	});
 });
@@ -165,7 +254,7 @@ suite('keyboardMapper - WINDOWS en_us', () => {
 		_assertResolveKeybinding(
 			mapper,
 			KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH),
-			{
+			[{
 				label: 'Ctrl+K Ctrl+\\',
 				ariaLabel: 'Control+K Control+\\',
 				HTMLLabel: [_chordHTMLLabel(['Ctrl', 'K'], ['Ctrl', '\\'])],
@@ -177,7 +266,7 @@ suite('keyboardMapper - WINDOWS en_us', () => {
 				hasAltModifier: false,
 				hasMetaModifier: false,
 				dispatchParts: ['ctrl+K', 'ctrl+\\'],
-			}
+			}]
 		);
 	});
 });