public void CompareTo1()
 {
     var i1 = new KeyInput('c', KeyModifiers.None);
     Assert.IsTrue(i1.CompareTo(new KeyInput('z', KeyModifiers.None)) < 0);
     Assert.IsTrue(i1.CompareTo(new KeyInput('c', KeyModifiers.None)) == 0);
     Assert.IsTrue(i1.CompareTo(new KeyInput('a', KeyModifiers.None)) > 0);
 }

		public IEnumerable<ProviderAndCommand> GetOneKeyShortcuts(KeyInput keyInput) {
			var keyShortcut = new KeyShortcut(keyInput, KeyInput.Default);
			List<ProviderAndCommand> list;
			if (dict.TryGetValue(keyShortcut, out list))
				return list;
			return Array.Empty<ProviderAndCommand>();
		}

 public void FindConflictingCommands3()
 {
     var util = Create("::ctrl+z, h");
     var inputs = new KeyInput[] { InputUtil.CharAndModifiersToKeyInput('z', KeyModifiers.Control) };
     var list = util.FindConflictingCommandKeyBindings(new HashSet<KeyInput>(inputs));
     Assert.AreEqual(1, list.Count);
 }

 internal VimKeyData(KeyInput keyInput, string text)
 {
     Contract.Assert(keyInput != null);
     KeyInputOptional = keyInput;
     TextOptional = text;
     IsDeadKey = false;
 }

        public void Run(KeyInput keyInput)
        {
            Key key;
            ModifierKeys modifierKeys;

            if (!TryConvert(keyInput, out key, out modifierKeys))
            {
                throw new Exception(String.Format("Couldn't convert {0} to Wpf keys", keyInput));
            }

            try
            {
                _defaultKeyboardDevice.DownKeyModifiers = modifierKeys;

                if (PreProcess(keyInput, key, modifierKeys))
                {
                    return;
                }

                var text = keyInput.RawChar.IsSome()
                    ? keyInput.Char.ToString()
                    : String.Empty;
                Run(text, key, modifierKeys);
            }
            finally
            {
                _defaultKeyboardDevice.DownKeyModifiers = ModifierKeys.None;

            }
        }

        internal bool TryConvert(Guid commandGroup, uint commandId, IntPtr pvaIn, out KeyInput kiOutput)
        {
            kiOutput = null;

            // Don't ever process a command when we are in an automation function.  Doing so will cause VsVim to
            // intercept items like running Macros and certain wizard functionality
            if (VsShellUtilities.IsInAutomationFunction(_serviceProvider))
            {
                return false;
            }

            EditCommand command;
            if (!OleCommandUtil.TryConvert(commandGroup, commandId, pvaIn, out command))
            {
                return false;
            }

            // If the current state of the buffer cannot process the command then do not convert it
            if (!_buffer.CanProcess(command.KeyInput))
            {
                return false;
            }

            kiOutput = command.KeyInput;
            return true;
        }

        internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr variantIn, out KeyInput keyInput, out EditCommandKind kind, out bool isRawText)
        {
            if (VSConstants.GUID_VSStandardCommandSet97 == commandGroup)
            {
                return TryConvert((VSConstants.VSStd97CmdID)commandId, variantIn, out keyInput, out kind, out isRawText);
            }

            if (VSConstants.VSStd2K == commandGroup)
            {
                return TryConvert((VSConstants.VSStd2KCmdID)commandId, variantIn, out keyInput, out kind, out isRawText);
            }

            if (commandGroup == HiddenCommand.Group && commandId == HiddenCommand.Id)
            {
                keyInput = KeyInputUtil.CharWithControlToKeyInput(';');
                kind = EditCommandKind.UserInput;
                isRawText = true;
                return true;
            }

            keyInput = null;
            kind = EditCommandKind.UserInput;
            isRawText = false;
            return false;
        }

 public void FindConflictingCommands5()
 {
     var util = Create("::a", "::ctrl+z, h");
     var inputs = new KeyInput[] { KeyInputUtil.CharWithControlToKeyInput('z') };
     var list = util.FindConflictingCommandKeyBindings(new HashSet<KeyInput>(inputs));
     Assert.AreEqual(1, list.Count);
 }

 public void FindConflictingCommands4()
 {
     Create("::h, z");
     var inputs = new KeyInput[] { KeyInputUtil.CharToKeyInput('z') };
     var list = _serviceRaw.FindConflictingCommandKeyBindings(_commandsSnapshot, new HashSet<KeyInput>(inputs));
     Assert.Equal(0, list.Count);
 }

		public override bool HandleKeyPress(KeyInput e)
		{
			if (world == null)
				return false;

			return ProcessInput(e);
		}

        /// <summary>
        /// Try and get the KeyInput which corresponds to the given Key and modifiers
        /// TODO: really think about this method
        /// </summary>
        internal bool TryGetKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
        {
            // First just check and see if there is a direct mapping
            var keyType = new KeyType(key, modifierKeys);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                return true;
            }

            // Next consider only the shift key part of the requested modifier.  We can
            // re-apply the original modifiers later
            keyType = new KeyType(key, modifierKeys & ModifierKeys.Shift);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            // Last consider it without any modifiers and reapply
            keyType = new KeyType(key, ModifierKeys.None);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            return false;
        }

 public void FindConflictingCommands1()
 {
     Create("::ctrl+h");
     var inputs = new KeyInput[] { KeyInputUtil.CharWithControlToKeyInput('h') };
     var list = _serviceRaw.FindConflictingCommandKeyBindings(_commandsSnapshot, new HashSet<KeyInput>(inputs));
     Assert.Equal(1, list.Count);
 }

        /// <summary>
        /// Try and map a KeyInput to a single KeyInput value.  This will only succeed for KeyInput 
        /// values which have no mapping or map to a single KeyInput value
        /// </summary>
        private bool TryGetSingleMapping(KeyInput original, out KeyInput mapped)
        {
            var result = _vimBuffer.GetKeyInputMapping(original);
            if (result.IsNeedsMoreInput || result.IsRecursive || result.IsPartiallyMapped)
            {
                // No single mapping
                mapped = null;
                return false;
            }

            if (result.IsMapped)
            {
                var set = ((KeyMappingResult.Mapped)result).Item;
                if (!set.IsOneKeyInput)
                {
                    mapped = null;
                    return false;
                }

                mapped = set.FirstKeyInput.Value;
                return true;
            }

            // Shouldn't get here because all cases of KeyMappingResult should be
            // handled above
            Contract.Assert(false);
            mapped = null;
            return false;
        }

        /// <summary>
        /// Is this KeyInput intended to be processed by the active display window
        /// </summary>
        private bool IsDisplayWindowKey(KeyInput keyInput)
        {
            // Consider normal completion
            if (_broker.IsCompletionActive)
            {
                return
                    keyInput.IsArrowKey ||
                    keyInput == KeyInputUtil.EnterKey ||
                    keyInput == KeyInputUtil.TabKey ||
                    keyInput.Key == VimKey.Back;
            }

            if (_broker.IsSmartTagSessionActive)
            {
                return
                    keyInput.IsArrowKey ||
                    keyInput == KeyInputUtil.EnterKey;
            }

            if (_broker.IsSignatureHelpActive)
            {
                return keyInput.IsArrowKey;
            }

            return false;
        }

 public void FindConflictingCommands4()
 {
     var util = Create("::h, z");
     var inputs = new KeyInput[] { new KeyInput('z') };
     var list = util.FindConflictingCommandKeyBindings(new HashSet<KeyInput>(inputs));
     Assert.AreEqual(0, list.Count);
 }

 public void FindConflictingCommands5()
 {
     var commands = Create("::a","::z, h");
     var inputs = new KeyInput[] { new KeyInput('z') };
     var list = KeyBindingService.FindConflictingCommands(commands, new HashSet<KeyInput>(inputs));
     Assert.AreEqual(1, list.Count);
 }

 public void FindConflictingCommands7()
 {
     var util = Create("balgh::a", "aoeu::z");
     var inputs = new KeyInput[] { KeyInputUtil.CharToKeyInput('z'), KeyInputUtil.CharToKeyInput('a') };
     var list = util.FindConflictingCommandKeyBindings(new HashSet<KeyInput>(inputs));
     Assert.AreEqual(0, list.Count);
 }

        public override bool HandleKeyPressInner(KeyInput e)
        {
            if (World == null) return false;
            if (World.LocalPlayer == null) return false;

            return ProcessInput(e);
        }

 private void VerifyConvert(VSConstants.VSStd97CmdID cmd, KeyInput ki, EditCommandKind kind)
 {
     EditCommand command;
     Assert.True(OleCommandUtil.TryConvert(VSConstants.GUID_VSStandardCommandSet97, (uint)cmd, IntPtr.Zero, VimKeyModifiers.None, out command));
     Assert.Equal(ki, command.KeyInput);
     Assert.Equal(kind, command.EditCommandKind);
 }

		public override bool HandleKeyPress(KeyInput e)
		{
			if (e.Event == KeyInputEvent.Down)
			{
				var hk = Hotkey.FromKeyInput(e);

				if (hk == Game.Settings.Keys.DevReloadChromeKey)
				{
					ChromeProvider.Initialize(Game.ModData.Manifest.Chrome);
					return true;
				}

				if (hk == Game.Settings.Keys.HideUserInterfaceKey)
				{
					foreach (var child in this.Children)
						child.Visible ^= true;

					return true;
				}

				if (hk == Game.Settings.Keys.TakeScreenshotKey)
				{
					if (e.Event == KeyInputEvent.Down)
						Game.TakeScreenshot = true;

					return true;
				}
			}

			return base.HandleKeyPress(e);
		}