fix(kbm): Add Win key to modifier release, check SendVirtualInput returns, add tests

- Add VK_LWIN/VK_RWIN to modifierKeys[] in HandleSingleKeyToTextRemapEvent
  so Win key is released before text injection (prevents Win+h/e/l shortcuts)
- Check SendVirtualInput return on modifier release — pass through original
  key if release fails (prevents Ctrl+text corruption on SendInput failure)
- Add MockedInput::SetKeyboardState for test setup
- Add ClearSingleKeyToTextRemaps to ResetTestEnv
- Add 2 new tests:
  - HandleSingleKeyToTextRemapEvent_ShouldReleaseAndRestoreWinKey_WhenWinKeyIsHeld
  - HandleSingleKeyToTextRemapEvent_ShouldReleaseAndRestoreCtrl_WhenCtrlIsHeld

All 94 KBM unit tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: crutkas

src/modules/keyboardmanager/KeyboardManagerEngineLibrary/KeyboardEventHandlers.cpp

@@ -1824,7 +1824,7 @@ namespace KeyboardEventHandlers
         }
 
         // Release held modifiers before text injection to prevent Ctrl+text corruption
-        constexpr int modifierKeys[] = { VK_LCONTROL, VK_RCONTROL, VK_LSHIFT, VK_RSHIFT, VK_LMENU, VK_RMENU };
+        constexpr int modifierKeys[] = { VK_LCONTROL, VK_RCONTROL, VK_LSHIFT, VK_RSHIFT, VK_LMENU, VK_RMENU, VK_LWIN, VK_RWIN };
         std::vector<INPUT> releaseEvents;
         std::vector<int> releasedKeys;
 
@@ -1839,7 +1839,10 @@ namespace KeyboardEventHandlers
 
         if (!releaseEvents.empty())
         {
-            ii.SendVirtualInput(releaseEvents);
+            if (!ii.SendVirtualInput(releaseEvents))
+            {
+                return 0;
+            }
         }
 
         Helpers::SendTextInput(*remapping);
@@ -1853,6 +1856,9 @@ namespace KeyboardEventHandlers
                 Helpers::SetKeyEvent(restoreEvents, INPUT_KEYBOARD, static_cast<WORD>(vk), 0, KeyboardManagerConstants::KEYBOARDMANAGER_SHORTCUT_FLAG);
             }
             ii.SendVirtualInput(restoreEvents);
+            // Note: not checking return here — failing to restore modifiers is
+            // less harmful than failing to release them (text already sent correctly).
+            // The user can tap the modifier to resync state.
         }
 
         return 1;

src/modules/keyboardmanager/KeyboardManagerEngineTest/MockedInput.cpp

@@ -130,6 +130,12 @@ bool MockedInput::GetVirtualKeyState(int key)
     return keyboardState[key];
 }
 
+// Function to set the state of a particular key for test setup
+void MockedInput::SetKeyboardState(int key, bool state)
+{
+    keyboardState[key] = state;
+}
+
 // Function to reset the mocked keyboard state
 void MockedInput::ResetKeyboardState()
 {

src/modules/keyboardmanager/KeyboardManagerEngineTest/MockedInput.h

@@ -42,6 +42,9 @@ namespace KeyboardManagerInput
         // Function to get the state of a particular key
         bool GetVirtualKeyState(int key);
 
+        // Function to set the state of a particular key for test setup
+        void SetKeyboardState(int key, bool state);
+
         // Function to reset the mocked keyboard state
         void ResetKeyboardState();
 

src/modules/keyboardmanager/KeyboardManagerEngineTest/SingleKeyRemappingTests.cpp

@@ -329,4 +329,64 @@ namespace RemappingLogicTests
             Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x56), false);
         }
     };
+
+    // Tests for single key to text remap modifier release logic
+    TEST_CLASS (SingleKeyToTextRemapModifierTests)
+    {
+    private:
+        KeyboardManagerInput::MockedInput mockedInputHandler;
+        State testState;
+
+    public:
+        TEST_METHOD_INITIALIZE(InitializeTestEnv)
+        {
+            TestHelpers::ResetTestEnv(mockedInputHandler, testState);
+
+            // Set HandleSingleKeyToTextRemapEvent as the hook procedure
+            std::function<intptr_t(LowlevelKeyboardEvent*)> currentHookProc = std::bind(&KeyboardEventHandlers::HandleSingleKeyToTextRemapEvent, std::ref(mockedInputHandler), std::placeholders::_1, std::ref(testState));
+            mockedInputHandler.SetHookProc(currentHookProc);
+        }
+
+        // Test if Win key is released and restored when held during text remap
+        TEST_METHOD (HandleSingleKeyToTextRemapEvent_ShouldReleaseAndRestoreWinKey_WhenWinKeyIsHeld)
+        {
+            // Remap X to text "hello"
+            testState.AddSingleKeyToTextRemap(0x58, L"hello");
+
+            // Simulate LWin being held down
+            mockedInputHandler.SetKeyboardState(VK_LWIN, true);
+            Assert::AreEqual(true, mockedInputHandler.GetVirtualKeyState(VK_LWIN));
+
+            std::vector<INPUT> inputs{
+                { .type = INPUT_KEYBOARD, .ki = { .wVk = 0x58 } },
+            };
+
+            // Send X keydown — handler should release LWin before text and restore after
+            mockedInputHandler.SendVirtualInput(inputs);
+
+            // After the handler completes, LWin should be restored (re-pressed)
+            Assert::AreEqual(true, mockedInputHandler.GetVirtualKeyState(VK_LWIN));
+        }
+
+        // Test if Ctrl key is released and restored when held during text remap
+        TEST_METHOD (HandleSingleKeyToTextRemapEvent_ShouldReleaseAndRestoreCtrl_WhenCtrlIsHeld)
+        {
+            // Remap X to text "hello"
+            testState.AddSingleKeyToTextRemap(0x58, L"hello");
+
+            // Simulate LCtrl being held down
+            mockedInputHandler.SetKeyboardState(VK_LCONTROL, true);
+            Assert::AreEqual(true, mockedInputHandler.GetVirtualKeyState(VK_LCONTROL));
+
+            std::vector<INPUT> inputs{
+                { .type = INPUT_KEYBOARD, .ki = { .wVk = 0x58 } },
+            };
+
+            // Send X keydown
+            mockedInputHandler.SendVirtualInput(inputs);
+
+            // After the handler completes, LCtrl should be restored
+            Assert::AreEqual(true, mockedInputHandler.GetVirtualKeyState(VK_LCONTROL));
+        }
+    };
 }

src/modules/keyboardmanager/KeyboardManagerEngineTest/TestHelpers.cpp

@@ -15,6 +15,7 @@ namespace TestHelpers
         state.ClearSingleKeyRemaps();
         state.ClearOSLevelShortcuts();
         state.ClearAppSpecificShortcuts();
+        state.ClearSingleKeyToTextRemaps();
 
         // Allocate memory for the keyboardManagerState activatedApp member to avoid CRT assert errors
         std::wstring maxLengthString;