mirror of
https://github.com/microsoft/PowerToys.git
synced 2026-04-04 18:26:39 +02:00
Refactored Keyboard Manager UI code and added unit tests for Keyboard Manager UI (#5718)
* Added tests for loading and saving remappings in the UI * Added tests for ApplyRemappings methods * Moved single key remap validation logic to separate method so that it can be tested * Added tests for single key remap validation in UI * Refactored shortcut validation code to be testable * Added some shortcut validation tests * Refactored code to be cleaner * Added tests for action key and modifier key selection and formatted file * Added tests for selecting None * Added tests for selecting Null * Added tests for WinL error * Added CtrlAltDel tests * Added tests for MapToSameKey * Added tests for mapping repeated shortcut * Fixed const correctness * Clean up type names with type alias * Clean up ValidateAndUpdateKeyBufferElement tests and tweak ValidateShortcutBufferElement signature * Fixed bug when None selected * Refactored one test as per test case framework * Cleaned up more tests * Cleaned up buffer validation tests * Added tests for KBM Common Helpers and Shortcut
This commit is contained in:
Arjun Balgovind
@@ -0,0 +1,521 @@
|
||||
#include "pch.h"
|
||||
#include "CppUnitTest.h"
|
||||
#include <keyboardmanager/common/KeyboardManagerState.h>
|
||||
#include <keyboardmanager/ui/LoadingAndSavingRemappingHelper.h>
|
||||
#include "TestHelpers.h"
|
||||
#include "../common/shared_constants.h"
|
||||
|
||||
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
|
||||
|
||||
namespace RemappingUITests
|
||||
{
|
||||
// Tests for methods in the LoadingAndSavingRemappingHelper namespace
|
||||
TEST_CLASS (LoadingAndSavingRemappingTests)
|
||||
{
|
||||
std::wstring testApp1 = L"testtrocess1.exe";
|
||||
std::wstring testApp2 = L"testprocess2.exe";
|
||||
|
||||
public:
|
||||
TEST_METHOD_INITIALIZE(InitializeTestEnv)
|
||||
{
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when no remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingNoRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when valid key to key remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingValidKeyToKeyRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to B and B to C
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x42, 0x43 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when valid key to shortcut remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingValidKeyToShortcutRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to Ctrl+V and B to Alt+Tab
|
||||
Shortcut s1;
|
||||
s1.SetKey(VK_CONTROL);
|
||||
s1.SetKey(0x56);
|
||||
Shortcut s2;
|
||||
s2.SetKey(VK_MENU);
|
||||
s2.SetKey(VK_TAB);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, s1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x42, s2 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when valid shortcut to key remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingValidShortcutToKeyRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+V to A and Alt+Tab to B
|
||||
Shortcut s1;
|
||||
s1.SetKey(VK_CONTROL);
|
||||
s1.SetKey(0x56);
|
||||
Shortcut s2;
|
||||
s2.SetKey(VK_MENU);
|
||||
s2.SetKey(VK_TAB);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ s1, 0x41 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ s2, 0x42 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when valid shortcut to shortcut remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingValidShortcutToShortcutRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+V to Ctrl+D and Alt+Tab to Win+A
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x56);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x44);
|
||||
Shortcut src2;
|
||||
src2.SetKey(VK_MENU);
|
||||
src2.SetKey(VK_TAB);
|
||||
Shortcut dest2;
|
||||
dest2.SetKey(CommonSharedConstants::VK_WIN_BOTH);
|
||||
dest2.SetKey(0x41);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src2, dest2 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when valid remaps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingValidRemapsOfAllTypes)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+V to Ctrl+D, Alt+Tab to A, A to B and B to Win+A
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x56);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x44);
|
||||
Shortcut src2;
|
||||
src2.SetKey(VK_MENU);
|
||||
src2.SetKey(VK_TAB);
|
||||
Shortcut dest2;
|
||||
dest2.SetKey(CommonSharedConstants::VK_WIN_BOTH);
|
||||
dest2.SetKey(0x41);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src2, 0x41 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x42, dest2 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is unsuccessful when remaps with null keys are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnRemapUnsuccessful_OnPassingRemapsWithNullKeys)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to NULL
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, NULL }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is invalid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::RemapUnsuccessful);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is unsuccessful when remaps with invalid shortcuts are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnRemapUnsuccessful_OnPassingRemapsWithInvalidShortcut)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to incomplete shortcut (Ctrl)
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, src1 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is invalid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::RemapUnsuccessful);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is unsuccessful when remaps with the same key remapped twice are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnRemapUnsuccessful_OnPassingRemapsWithSameKeyRemappedTwice)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to B and A to Ctrl+C
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x43);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, src1 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is invalid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::RemapUnsuccessful);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is unsuccessful when remaps with the same shortcut remapped twice are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnRemapUnsuccessful_OnPassingRemapsWithSameShortcutRemappedTwice)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+A to B and Ctrl+A to Ctrl+V
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x41);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x56);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), std::wstring()));
|
||||
|
||||
// Assert that remapping set is invalid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::RemapUnsuccessful);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is unsuccessful when app specific remaps with the same shortcut remapped twice for the same target app are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnRemapUnsuccessful_OnPassingAppSpecificRemapsWithSameShortcutRemappedTwiceForTheSameTargetApp)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+A to B and Ctrl+A to Ctrl+V for testApp1
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x41);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x56);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, 0x42 }), testApp1));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), testApp1));
|
||||
|
||||
// Assert that remapping set is invalid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::RemapUnsuccessful);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the CheckIfRemappingsAreValid method is successful when app specific remaps with the same shortcut remapped twice for different target apps are passed
|
||||
TEST_METHOD (CheckIfRemappingsAreValid_ShouldReturnNoError_OnPassingAppSpecificRemapsWithSameShortcutRemappedTwiceForDifferentTargetApps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+A to B for testApp1 and Ctrl+A to Ctrl+V for testApp2
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x41);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x56);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, 0x42 }), testApp1));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), testApp2));
|
||||
|
||||
// Assert that remapping set is valid
|
||||
bool isSuccess = (LoadingAndSavingRemappingHelper::CheckIfRemappingsAreValid(remapBuffer) == KeyboardManagerHelper::ErrorType::NoError);
|
||||
Assert::AreEqual(true, isSuccess);
|
||||
}
|
||||
|
||||
// Test if the GetOrphanedKeys method return an empty vector on passing no remaps
|
||||
TEST_METHOD (GetOrphanedKeys_ShouldReturnEmptyVector_OnPassingNoRemaps)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Assert that there are no orphaned keys
|
||||
Assert::AreEqual(true, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer).empty());
|
||||
}
|
||||
|
||||
// Test if the GetOrphanedKeys method return one orphaned on passing one key remap
|
||||
TEST_METHOD (GetOrphanedKeys_ShouldReturnOneOrphanedKey_OnPassingOneKeyRemap)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to B
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
|
||||
// Assert that only A is orphaned
|
||||
Assert::AreEqual((size_t)1, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer).size());
|
||||
Assert::AreEqual((DWORD)0x41, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer)[0]);
|
||||
}
|
||||
|
||||
// Test if the GetOrphanedKeys method return an empty vector on passing swapped key remaps
|
||||
TEST_METHOD (GetOrphanedKeys_ShouldReturnEmptyVector_OnPassingSwappedKeyRemap)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to B and B to A
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x42, 0x41 }), std::wstring()));
|
||||
|
||||
// Assert that there are no orphaned keys
|
||||
Assert::AreEqual(true, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer).empty());
|
||||
}
|
||||
|
||||
// Test if the GetOrphanedKeys method return one orphaned on passing two key remaps where one key is mapped to a remapped key
|
||||
TEST_METHOD (GetOrphanedKeys_ShouldReturnOneOrphanedKey_OnPassingTwoKeyRemapsWhereOneKeyIsMappedToARemappedKey)
|
||||
{
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to Ctrl+B and C to A
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x42);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, dest1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x43, 0x41 }), std::wstring()));
|
||||
|
||||
// Assert that only C is orphaned
|
||||
Assert::AreEqual((size_t)1, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer).size());
|
||||
Assert::AreEqual((DWORD)0x43, LoadingAndSavingRemappingHelper::GetOrphanedKeys(remapBuffer)[0]);
|
||||
}
|
||||
|
||||
// Test if the PreProcessRemapTable method combines all the modifier pairs when the left and right modifiers are remapped to the same target
|
||||
TEST_METHOD (PreProcessRemapTable_ShouldCombineAllPairs_OnPassingLeftAndRightModifiersRemappedToTheSameTarget)
|
||||
{
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> remapTable;
|
||||
|
||||
// Remap LCtrl and RCtrl to A, LAlt and RAlt to B, LShift and RShift to C, LWin and RWin to D
|
||||
remapTable[VK_LCONTROL] = 0x41;
|
||||
remapTable[VK_RCONTROL] = 0x41;
|
||||
remapTable[VK_LMENU] = 0x42;
|
||||
remapTable[VK_RMENU] = 0x42;
|
||||
remapTable[VK_LSHIFT] = 0x43;
|
||||
remapTable[VK_RSHIFT] = 0x43;
|
||||
remapTable[VK_LWIN] = 0x44;
|
||||
remapTable[VK_RWIN] = 0x44;
|
||||
|
||||
// Pre process table
|
||||
LoadingAndSavingRemappingHelper::PreProcessRemapTable(remapTable);
|
||||
|
||||
// Expected Ctrl remapped to A, Alt to B, Shift to C, Win to D
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> expectedTable;
|
||||
expectedTable[VK_CONTROL] = 0x41;
|
||||
expectedTable[VK_MENU] = 0x42;
|
||||
expectedTable[VK_SHIFT] = 0x43;
|
||||
expectedTable[CommonSharedConstants::VK_WIN_BOTH] = 0x44;
|
||||
|
||||
bool areTablesEqual = (expectedTable == remapTable);
|
||||
Assert::AreEqual(true, areTablesEqual);
|
||||
}
|
||||
|
||||
// Test if the PreProcessRemapTable method does not combines any of the modifier pairs when the left and right modifiers are remapped to different targets
|
||||
TEST_METHOD (PreProcessRemapTable_ShouldNotCombineAnyPairs_OnPassingLeftAndRightModifiersRemappedToTheDifferentTargets)
|
||||
{
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> remapTable;
|
||||
|
||||
// Remap left modifiers to A and right modifiers to B
|
||||
remapTable[VK_LCONTROL] = 0x41;
|
||||
remapTable[VK_RCONTROL] = 0x42;
|
||||
remapTable[VK_LMENU] = 0x41;
|
||||
remapTable[VK_RMENU] = 0x42;
|
||||
remapTable[VK_LSHIFT] = 0x41;
|
||||
remapTable[VK_RSHIFT] = 0x42;
|
||||
remapTable[VK_LWIN] = 0x41;
|
||||
remapTable[VK_RWIN] = 0x42;
|
||||
|
||||
// Pre process table
|
||||
LoadingAndSavingRemappingHelper::PreProcessRemapTable(remapTable);
|
||||
|
||||
// Expected unchanged table
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> expectedTable;
|
||||
expectedTable[VK_LCONTROL] = 0x41;
|
||||
expectedTable[VK_RCONTROL] = 0x42;
|
||||
expectedTable[VK_LMENU] = 0x41;
|
||||
expectedTable[VK_RMENU] = 0x42;
|
||||
expectedTable[VK_LSHIFT] = 0x41;
|
||||
expectedTable[VK_RSHIFT] = 0x42;
|
||||
expectedTable[VK_LWIN] = 0x41;
|
||||
expectedTable[VK_RWIN] = 0x42;
|
||||
|
||||
bool areTablesEqual = (expectedTable == remapTable);
|
||||
Assert::AreEqual(true, areTablesEqual);
|
||||
}
|
||||
|
||||
// Test if the ApplySingleKeyRemappings method resets the keyboard manager state's single key remappings on passing an empty buffer
|
||||
TEST_METHOD (ApplySingleKeyRemappings_ShouldResetSingleKeyRemappings_OnPassingEmptyBuffer)
|
||||
{
|
||||
KeyboardManagerState testState;
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap A to B
|
||||
testState.AddSingleKeyRemap(0x41, 0x42);
|
||||
|
||||
// Apply the single key remaps from the buffer to the keyboard manager state variable
|
||||
LoadingAndSavingRemappingHelper::ApplySingleKeyRemappings(testState, remapBuffer, false);
|
||||
|
||||
// Assert that single key remapping in the kbm state variable is empty
|
||||
Assert::AreEqual((size_t)0, testState.singleKeyReMap.size());
|
||||
}
|
||||
|
||||
// Test if the ApplySingleKeyRemappings method copies only the valid remappings to the keyboard manager state variable when some of the remappings are invalid
|
||||
TEST_METHOD (ApplySingleKeyRemappings_ShouldCopyOnlyValidRemappings_OnPassingBufferWithSomeInvalidRemappings)
|
||||
{
|
||||
KeyboardManagerState testState;
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Add A->B, B->Ctrl+V, C to incomplete shortcut and D to incomplete key remappings to the buffer
|
||||
Shortcut s1;
|
||||
s1.SetKey(VK_CONTROL);
|
||||
s1.SetKey(0x56);
|
||||
Shortcut s2;
|
||||
s2.SetKey(VK_LMENU);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x41, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x42, s1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x43, NULL }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ 0x44, s2 }), std::wstring()));
|
||||
|
||||
// Apply the single key remaps from the buffer to the keyboard manager state variable
|
||||
LoadingAndSavingRemappingHelper::ApplySingleKeyRemappings(testState, remapBuffer, false);
|
||||
|
||||
// Expected A remapped to B, B remapped to Ctrl+V
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> expectedTable;
|
||||
expectedTable[0x41] = 0x42;
|
||||
expectedTable[0x42] = s1;
|
||||
|
||||
bool areTablesEqual = (expectedTable == testState.singleKeyReMap);
|
||||
Assert::AreEqual(true, areTablesEqual);
|
||||
}
|
||||
|
||||
// Test if the ApplySingleKeyRemappings method splits common modifiers to their left and right version when copying to the keyboard manager state variable if remappings from common modifiers are passed
|
||||
TEST_METHOD (ApplySingleKeyRemappings_ShouldSplitRemappingsFromCommonModifiers_OnPassingBufferWithSomeMappingsFromCommonModifiers)
|
||||
{
|
||||
KeyboardManagerState testState;
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Add Ctrl->A, Alt->B, Shift->C and Win->D remappings to the buffer
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ VK_CONTROL, 0x41 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ VK_MENU, 0x42 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ VK_SHIFT, 0x43 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ CommonSharedConstants::VK_WIN_BOTH, 0x44 }), std::wstring()));
|
||||
|
||||
// Apply the single key remaps from the buffer to the keyboard manager state variable
|
||||
LoadingAndSavingRemappingHelper::ApplySingleKeyRemappings(testState, remapBuffer, false);
|
||||
|
||||
// Expected LCtrl/RCtrl remapped to A, LAlt/RAlt to B, LShift/RShift to C, LWin/RWin to D
|
||||
std::unordered_map<DWORD, std::variant<DWORD, Shortcut>> expectedTable;
|
||||
expectedTable[VK_LCONTROL] = 0x41;
|
||||
expectedTable[VK_RCONTROL] = 0x41;
|
||||
expectedTable[VK_LMENU] = 0x42;
|
||||
expectedTable[VK_RMENU] = 0x42;
|
||||
expectedTable[VK_LSHIFT] = 0x43;
|
||||
expectedTable[VK_RSHIFT] = 0x43;
|
||||
expectedTable[VK_LWIN] = 0x44;
|
||||
expectedTable[VK_RWIN] = 0x44;
|
||||
|
||||
bool areTablesEqual = (expectedTable == testState.singleKeyReMap);
|
||||
Assert::AreEqual(true, areTablesEqual);
|
||||
}
|
||||
|
||||
// Test if the ApplyShortcutRemappings method resets the keyboard manager state's os level and app specific shortcut remappings on passing an empty buffer
|
||||
TEST_METHOD (ApplyShortcutRemappings_ShouldResetShortcutRemappings_OnPassingEmptyBuffer)
|
||||
{
|
||||
KeyboardManagerState testState;
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Remap Ctrl+A to Ctrl+B for all apps and Ctrl+C to Alt+V for testApp1
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x41);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x42);
|
||||
Shortcut src2;
|
||||
src2.SetKey(VK_CONTROL);
|
||||
src2.SetKey(0x43);
|
||||
Shortcut dest2;
|
||||
dest2.SetKey(VK_MENU);
|
||||
dest2.SetKey(0x56);
|
||||
testState.AddOSLevelShortcut(src1, dest1);
|
||||
testState.AddAppSpecificShortcut(testApp1, src1, dest1);
|
||||
|
||||
// Apply the shortcut remaps from the buffer to the keyboard manager state variable
|
||||
LoadingAndSavingRemappingHelper::ApplyShortcutRemappings(testState, remapBuffer, false);
|
||||
|
||||
// Assert that shortcut remappings in the kbm state variable is empty
|
||||
Assert::AreEqual((size_t)0, testState.osLevelShortcutReMap.size());
|
||||
Assert::AreEqual((size_t)0, testState.appSpecificShortcutReMap.size());
|
||||
}
|
||||
|
||||
// Test if the ApplyShortcutRemappings method copies only the valid remappings to the keyboard manager state variable when some of the remappings are invalid
|
||||
TEST_METHOD (ApplyShortcutRemappings_ShouldCopyOnlyValidRemappings_OnPassingBufferWithSomeInvalidRemappings)
|
||||
{
|
||||
KeyboardManagerState testState;
|
||||
RemapBuffer remapBuffer;
|
||||
|
||||
// Add Ctrl+A->Ctrl+B, Ctrl+C->Alt+V, Ctrl+F->incomplete shortcut and Ctrl+G->incomplete key os level remappings to buffer
|
||||
// Add Ctrl+F->Alt+V, Ctrl+G->Ctrl+B, Ctrl+A->incomplete shortcut and Ctrl+C->incomplete key app specific remappings to buffer
|
||||
Shortcut src1;
|
||||
src1.SetKey(VK_CONTROL);
|
||||
src1.SetKey(0x41);
|
||||
Shortcut dest1;
|
||||
dest1.SetKey(VK_CONTROL);
|
||||
dest1.SetKey(0x42);
|
||||
Shortcut src2;
|
||||
src2.SetKey(VK_CONTROL);
|
||||
src2.SetKey(0x43);
|
||||
Shortcut dest2;
|
||||
dest2.SetKey(VK_MENU);
|
||||
dest2.SetKey(0x56);
|
||||
Shortcut src3;
|
||||
src3.SetKey(VK_CONTROL);
|
||||
src3.SetKey(0x46);
|
||||
Shortcut src4;
|
||||
src4.SetKey(VK_CONTROL);
|
||||
src4.SetKey(0x47);
|
||||
Shortcut dest4;
|
||||
dest4.SetKey(VK_CONTROL);
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, dest1 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src2, dest2 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src3, NULL }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src4, dest4 }), std::wstring()));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src3, dest2 }), testApp1));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src4, dest1 }), testApp1));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src1, NULL }), testApp1));
|
||||
remapBuffer.push_back(std::make_pair(RemapBufferItem({ src2, dest4 }), testApp1));
|
||||
|
||||
// Apply the shortcut remaps from the buffer to the keyboard manager state variable
|
||||
LoadingAndSavingRemappingHelper::ApplyShortcutRemappings(testState, remapBuffer, false);
|
||||
|
||||
// Ctrl+A->Ctrl+B and Ctrl+C->Alt+V
|
||||
std::map<Shortcut, RemapShortcut> expectedOSLevelTable;
|
||||
expectedOSLevelTable[src1] = RemapShortcut(dest1);
|
||||
expectedOSLevelTable[src2] = RemapShortcut(dest2);
|
||||
|
||||
// Ctrl+F->Alt+V and Ctrl+G->Ctrl+B for testApp1
|
||||
std::map<std::wstring, std::map<Shortcut, RemapShortcut>> expectedAppSpecificLevelTable;
|
||||
expectedAppSpecificLevelTable[testApp1][src3] = RemapShortcut(dest2);
|
||||
expectedAppSpecificLevelTable[testApp1][src4] = RemapShortcut(dest1);
|
||||
|
||||
bool areOSLevelTablesEqual = (expectedOSLevelTable == testState.osLevelShortcutReMap);
|
||||
bool areAppSpecificTablesEqual = (expectedAppSpecificLevelTable == testState.appSpecificShortcutReMap);
|
||||
Assert::AreEqual(true, areOSLevelTablesEqual);
|
||||
Assert::AreEqual(true, areAppSpecificTablesEqual);
|
||||
}
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user