diff --git a/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj b/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj index ae676ab6fb..1b439f9115 100644 --- a/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj +++ b/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj @@ -102,11 +102,14 @@ - + + + Create + diff --git a/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj.filters b/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj.filters index e5da9d58c1..2f1fc44727 100644 --- a/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj.filters +++ b/src/modules/keyboardmanager/test/KeyboardManagerTest.vcxproj.filters @@ -24,7 +24,16 @@ Source Files - + + Source Files + + + Source Files + + + Source Files + + Source Files diff --git a/src/modules/keyboardmanager/test/MockedInputSanityTests.cpp b/src/modules/keyboardmanager/test/MockedInputSanityTests.cpp new file mode 100644 index 0000000000..81a25f8b6f --- /dev/null +++ b/src/modules/keyboardmanager/test/MockedInputSanityTests.cpp @@ -0,0 +1,49 @@ +#include "pch.h" +#include "CppUnitTest.h" +#include "MockedInput.h" +#include +#include +#include "TestHelpers.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace RemappingLogicTests +{ + // Tests for MockedInput test helper - to ensure simulated keyboard input behaves as expected + TEST_CLASS (MockedInputSanityTests) + { + private: + MockedInput mockedInputHandler; + KeyboardManagerState testState; + + public: + TEST_METHOD_INITIALIZE(InitializeTestEnv) + { + // Reset test environment + TestHelpers::ResetTestEnv(mockedInputHandler, testState); + } + + // Test if mocked input is working + TEST_METHOD (MockedInput_ShouldSetKeyboardState_OnKeyEvent) + { + // Send key down and key up for A key (0x41) and check keyboard state both times + const int nInputs = 1; + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = 0x41; + + // Send A keydown + mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT)); + + // A key state should be true + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), true); + input[0].ki.dwFlags = KEYEVENTF_KEYUP; + + // Send A keyup + mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT)); + + // A key state should be false + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + } + }; +} diff --git a/src/modules/keyboardmanager/test/KeyboardManagerRemapLogicTest.cpp b/src/modules/keyboardmanager/test/OSLevelShortcutRemappingTests.cpp similarity index 84% rename from src/modules/keyboardmanager/test/KeyboardManagerRemapLogicTest.cpp rename to src/modules/keyboardmanager/test/OSLevelShortcutRemappingTests.cpp index 6387919b62..2d546130de 100644 --- a/src/modules/keyboardmanager/test/KeyboardManagerRemapLogicTest.cpp +++ b/src/modules/keyboardmanager/test/OSLevelShortcutRemappingTests.cpp @@ -7,219 +7,15 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework; -MockedInput mockedInputHandler; -KeyboardManagerState testState; - -namespace KeyboardManagerRemapLogicTests +namespace RemappingLogicTests { - TEST_CLASS (MockedInputSanityTests) - { - public: - TEST_METHOD_INITIALIZE(InitializeTestEnv) - { - // Reset test environment - TestHelpers::ResetTestEnv(mockedInputHandler, testState); - } - - // Test if mocked input is working - TEST_METHOD (MockedInput_ShouldSetKeyboardState_OnKeyEvent) - { - // Send key down and key up for A key (0x41) and check keyboard state both times - const int nInputs = 1; - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = 0x41; - - // Send A keydown - mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT)); - - // A key state should be true - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), true); - input[0].ki.dwFlags = KEYEVENTF_KEYUP; - - // Send A keyup - mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT)); - - // A key state should be false - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - } - }; - - TEST_CLASS (SetKeyEventTests) - { - public: - TEST_METHOD_INITIALIZE(InitializeTestEnv) - { - // Reset test environment - TestHelpers::ResetTestEnv(mockedInputHandler, testState); - } - - // Test if SetKeyEvent sets the extended key flag for all the extended keys - TEST_METHOD (SetKeyEvent_ShouldUseExtendedKeyFlag_WhenArgumentIsExtendedKey) - { - const int nInputs = 15; - INPUT input[nInputs] = {}; - - // List of extended keys - WORD keyCodes[nInputs] = { VK_RCONTROL, VK_RMENU, VK_NUMLOCK, VK_SNAPSHOT, VK_CANCEL, VK_INSERT, VK_HOME, VK_PRIOR, VK_DELETE, VK_END, VK_NEXT, VK_LEFT, VK_DOWN, VK_RIGHT, VK_UP }; - - for (int i = 0; i < nInputs; i++) - { - // Set key events for all the extended keys - KeyboardManagerHelper::SetKeyEvent(input, i, INPUT_KEYBOARD, keyCodes[i], 0, 0); - // Extended key flag should be set - Assert::AreEqual(true, bool(input[i].ki.dwFlags & KEYEVENTF_EXTENDEDKEY)); - } - } - }; - - TEST_CLASS (SingleKeyRemappingTests) - { - public: - TEST_METHOD_INITIALIZE(InitializeTestEnv) - { - // Reset test environment - TestHelpers::ResetTestEnv(mockedInputHandler, testState); - - // Set HandleSingleKeyRemapEvent as the hook procedure - std::function currentHookProc = std::bind(&KeyboardEventHandlers::HandleSingleKeyRemapEvent, std::ref(mockedInputHandler), std::placeholders::_1, std::ref(testState)); - mockedInputHandler.SetHookProc(currentHookProc); - } - - // Test if correct keyboard states are set for a single key remap - TEST_METHOD (RemappedKey_ShouldSetTargetKeyState_OnKeyEvent) - { - // Remap A to B - testState.AddSingleKeyRemap(0x41, 0x42); - const int nInputs = 1; - - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = 0x41; - - // Send A keydown - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged, and B key state should be true - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x42), true); - input[0].ki.dwFlags = KEYEVENTF_KEYUP; - - // Send A keyup - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged, and B key state should be false - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x42), false); - } - - // Test if key is suppressed if a key is disabled by single key remap - TEST_METHOD (RemappedKeyDisabled_ShouldNotChangeKeyState_OnKeyEvent) - { - // Remap A to 0x0 (disabled) - testState.AddSingleKeyRemap(0x41, 0x0); - const int nInputs = 1; - - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = 0x41; - - // Send A keydown - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - input[0].ki.dwFlags = KEYEVENTF_KEYUP; - - // Send A keyup - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - } - - // Test if correct keyboard states are set for a remap to Win (Both) key - TEST_METHOD (RemappedKeyToWinBoth_ShouldSetWinLeftKeyState_OnKeyEvent) - { - // Remap A to Common Win key - testState.AddSingleKeyRemap(0x41, CommonSharedConstants::VK_WIN_BOTH); - const int nInputs = 1; - - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = 0x41; - - // Send A keydown - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged, and common Win key state should be true - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_LWIN), true); - input[0].ki.dwFlags = KEYEVENTF_KEYUP; - - // Send A keyup - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // A key state should be unchanged, and common Win key state should be false - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); - Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_LWIN), false); - } - - // Test if SendVirtualInput is sent exactly once with the suppress flag when Caps Lock is remapped to Ctrl - TEST_METHOD (HandleSingleKeyRemapEvent_ShouldSendVirutalInputWithSuppressFlagExactlyOnce_WhenCapsLockIsMappedToCtrlAltShift) - { - // Set sendvirtualinput call count condition to return true if the key event was sent with the suppress flag - mockedInputHandler.SetSendVirtualInputTestHandler([](LowlevelKeyboardEvent* data) { - if (data->lParam->dwExtraInfo == KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG) - return true; - else - return false; - }); - - // Remap Caps Lock to Ctrl - testState.AddSingleKeyRemap(VK_CAPITAL, VK_CONTROL); - const int nInputs = 1; - - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = VK_CAPITAL; - - // Send Caps Lock keydown - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // SendVirtualInput should be called exactly once with the above condition - Assert::AreEqual(1, mockedInputHandler.GetSendVirtualInputCallCount()); - } - - // Test if SendVirtualInput is sent exactly once with the suppress flag when Ctrl is remapped to Caps Lock - TEST_METHOD (HandleSingleKeyRemapEvent_ShouldSendVirutalInputWithSuppressFlagExactlyOnce_WhenCtrlAltShiftIsMappedToCapsLock) - { - // Set sendvirtualinput call count condition to return true if the key event was sent with the suppress flag - mockedInputHandler.SetSendVirtualInputTestHandler([](LowlevelKeyboardEvent* data) { - if (data->lParam->dwExtraInfo == KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG) - return true; - else - return false; - }); - - // Remap Ctrl to Caps Lock - testState.AddSingleKeyRemap(VK_CONTROL, VK_CAPITAL); - const int nInputs = 1; - - INPUT input[nInputs] = {}; - input[0].type = INPUT_KEYBOARD; - input[0].ki.wVk = VK_CONTROL; - - // Send Ctrl keydown - mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); - - // SendVirtualInput should be called exactly once with the above condition - Assert::AreEqual(1, mockedInputHandler.GetSendVirtualInputCallCount()); - } - }; - + // Tests for shortcut remapping logic TEST_CLASS (OSLevelShortcutRemappingTests) { + private: + MockedInput mockedInputHandler; + KeyboardManagerState testState; + public: TEST_METHOD_INITIALIZE(InitializeTestEnv) { diff --git a/src/modules/keyboardmanager/test/SetKeyEventTests.cpp b/src/modules/keyboardmanager/test/SetKeyEventTests.cpp new file mode 100644 index 0000000000..c39b5d0444 --- /dev/null +++ b/src/modules/keyboardmanager/test/SetKeyEventTests.cpp @@ -0,0 +1,44 @@ +#include "pch.h" +#include "CppUnitTest.h" +#include "MockedInput.h" +#include +#include +#include "TestHelpers.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace RemappingLogicTests +{ + // Tests for the SetKeyEvent method + TEST_CLASS (SetKeyEventTests) + { + private: + MockedInput mockedInputHandler; + KeyboardManagerState testState; + + public: + TEST_METHOD_INITIALIZE(InitializeTestEnv) + { + // Reset test environment + TestHelpers::ResetTestEnv(mockedInputHandler, testState); + } + + // Test if SetKeyEvent sets the extended key flag for all the extended keys + TEST_METHOD (SetKeyEvent_ShouldUseExtendedKeyFlag_WhenArgumentIsExtendedKey) + { + const int nInputs = 15; + INPUT input[nInputs] = {}; + + // List of extended keys + WORD keyCodes[nInputs] = { VK_RCONTROL, VK_RMENU, VK_NUMLOCK, VK_SNAPSHOT, VK_CANCEL, VK_INSERT, VK_HOME, VK_PRIOR, VK_DELETE, VK_END, VK_NEXT, VK_LEFT, VK_DOWN, VK_RIGHT, VK_UP }; + + for (int i = 0; i < nInputs; i++) + { + // Set key events for all the extended keys + KeyboardManagerHelper::SetKeyEvent(input, i, INPUT_KEYBOARD, keyCodes[i], 0, 0); + // Extended key flag should be set + Assert::AreEqual(true, bool(input[i].ki.dwFlags & KEYEVENTF_EXTENDEDKEY)); + } + } + }; +} diff --git a/src/modules/keyboardmanager/test/SingleKeyRemappingTests.cpp b/src/modules/keyboardmanager/test/SingleKeyRemappingTests.cpp new file mode 100644 index 0000000000..a244ec23c4 --- /dev/null +++ b/src/modules/keyboardmanager/test/SingleKeyRemappingTests.cpp @@ -0,0 +1,161 @@ +#include "pch.h" +#include "CppUnitTest.h" +#include "MockedInput.h" +#include +#include +#include "TestHelpers.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace RemappingLogicTests +{ + // Tests for single key remapping logic + TEST_CLASS (SingleKeyRemappingTests) + { + private: + MockedInput mockedInputHandler; + KeyboardManagerState testState; + + public: + TEST_METHOD_INITIALIZE(InitializeTestEnv) + { + // Reset test environment + TestHelpers::ResetTestEnv(mockedInputHandler, testState); + + // Set HandleSingleKeyRemapEvent as the hook procedure + std::function currentHookProc = std::bind(&KeyboardEventHandlers::HandleSingleKeyRemapEvent, std::ref(mockedInputHandler), std::placeholders::_1, std::ref(testState)); + mockedInputHandler.SetHookProc(currentHookProc); + } + + // Test if correct keyboard states are set for a single key remap + TEST_METHOD (RemappedKey_ShouldSetTargetKeyState_OnKeyEvent) + { + // Remap A to B + testState.AddSingleKeyRemap(0x41, 0x42); + const int nInputs = 1; + + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = 0x41; + + // Send A keydown + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged, and B key state should be true + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x42), true); + input[0].ki.dwFlags = KEYEVENTF_KEYUP; + + // Send A keyup + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged, and B key state should be false + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x42), false); + } + + // Test if key is suppressed if a key is disabled by single key remap + TEST_METHOD (RemappedKeyDisabled_ShouldNotChangeKeyState_OnKeyEvent) + { + // Remap A to 0x0 (disabled) + testState.AddSingleKeyRemap(0x41, 0x0); + const int nInputs = 1; + + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = 0x41; + + // Send A keydown + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + input[0].ki.dwFlags = KEYEVENTF_KEYUP; + + // Send A keyup + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + } + + // Test if correct keyboard states are set for a remap to Win (Both) key + TEST_METHOD (RemappedKeyToWinBoth_ShouldSetWinLeftKeyState_OnKeyEvent) + { + // Remap A to Common Win key + testState.AddSingleKeyRemap(0x41, CommonSharedConstants::VK_WIN_BOTH); + const int nInputs = 1; + + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = 0x41; + + // Send A keydown + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged, and common Win key state should be true + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_LWIN), true); + input[0].ki.dwFlags = KEYEVENTF_KEYUP; + + // Send A keyup + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // A key state should be unchanged, and common Win key state should be false + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false); + Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_LWIN), false); + } + + // Test if SendVirtualInput is sent exactly once with the suppress flag when Caps Lock is remapped to Ctrl + TEST_METHOD (HandleSingleKeyRemapEvent_ShouldSendVirutalInputWithSuppressFlagExactlyOnce_WhenCapsLockIsMappedToCtrlAltShift) + { + // Set sendvirtualinput call count condition to return true if the key event was sent with the suppress flag + mockedInputHandler.SetSendVirtualInputTestHandler([](LowlevelKeyboardEvent* data) { + if (data->lParam->dwExtraInfo == KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG) + return true; + else + return false; + }); + + // Remap Caps Lock to Ctrl + testState.AddSingleKeyRemap(VK_CAPITAL, VK_CONTROL); + const int nInputs = 1; + + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = VK_CAPITAL; + + // Send Caps Lock keydown + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // SendVirtualInput should be called exactly once with the above condition + Assert::AreEqual(1, mockedInputHandler.GetSendVirtualInputCallCount()); + } + + // Test if SendVirtualInput is sent exactly once with the suppress flag when Ctrl is remapped to Caps Lock + TEST_METHOD (HandleSingleKeyRemapEvent_ShouldSendVirutalInputWithSuppressFlagExactlyOnce_WhenCtrlAltShiftIsMappedToCapsLock) + { + // Set sendvirtualinput call count condition to return true if the key event was sent with the suppress flag + mockedInputHandler.SetSendVirtualInputTestHandler([](LowlevelKeyboardEvent* data) { + if (data->lParam->dwExtraInfo == KeyboardManagerConstants::KEYBOARDMANAGER_SUPPRESS_FLAG) + return true; + else + return false; + }); + + // Remap Ctrl to Caps Lock + testState.AddSingleKeyRemap(VK_CONTROL, VK_CAPITAL); + const int nInputs = 1; + + INPUT input[nInputs] = {}; + input[0].type = INPUT_KEYBOARD; + input[0].ki.wVk = VK_CONTROL; + + // Send Ctrl keydown + mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT)); + + // SendVirtualInput should be called exactly once with the above condition + Assert::AreEqual(1, mockedInputHandler.GetSendVirtualInputCallCount()); + } + }; +}