CapsHotkey/tests.cpp at main · kkzi/CapsHotkey · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include <Windows.h>

#include "CapsHotkey.hpp"

#include <cstdlib>
#include <vector>

static void require(bool condition)
{
    if (!condition)
    {
        std::abort();
    }
}

static bool has_flag(DWORD value, DWORD flag)
{
    return (value & flag) == flag;
}

static void assert_input(const INPUT &input, WORD key, DWORD flags)
{
    require(input.type == INPUT_KEYBOARD);
    require(input.ki.wVk == key);
    require(input.ki.dwFlags == flags);
}

static void test_ctrl_left_sequence()
{
    auto inputs = build_key_click_inputs(std::vector<int>{ VK_CONTROL, VK_LEFT });

    require(inputs.size() == 4);
    assert_input(inputs[0], VK_CONTROL, 0);
    assert_input(inputs[1], VK_LEFT, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[2], VK_LEFT, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
    assert_input(inputs[3], VK_CONTROL, KEYEVENTF_KEYUP);
}

static void test_shift_end_sequence()
{
    auto inputs = build_key_click_inputs(std::vector<int>{ VK_SHIFT, VK_END });

    require(inputs.size() == 4);
    assert_input(inputs[0], VK_SHIFT, 0);
    assert_input(inputs[1], VK_END, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[2], VK_END, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
    assert_input(inputs[3], VK_SHIFT, KEYEVENTF_KEYUP);
}

static void test_ctrl_shift_left_release_order()
{
    auto inputs = build_key_click_inputs(std::vector<int>{ VK_CONTROL, VK_SHIFT, VK_LEFT });

    require(inputs.size() == 6);
    assert_input(inputs[0], VK_CONTROL, 0);
    assert_input(inputs[1], VK_SHIFT, 0);
    assert_input(inputs[2], VK_LEFT, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[3], VK_LEFT, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
    assert_input(inputs[4], VK_SHIFT, KEYEVENTF_KEYUP);
    assert_input(inputs[5], VK_CONTROL, KEYEVENTF_KEYUP);
}

static void test_multi_step_sequence_does_not_overlap_modifiers()
{
    auto inputs = build_key_sequence_inputs(std::vector<std::vector<int>>{
        { VK_SHIFT, VK_HOME },
        { VK_CONTROL, VK_INSERT },
        { VK_DELETE },
    });

    require(inputs.size() == 10);
    assert_input(inputs[0], VK_SHIFT, 0);
    assert_input(inputs[1], VK_HOME, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[2], VK_HOME, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
    assert_input(inputs[3], VK_SHIFT, KEYEVENTF_KEYUP);
    assert_input(inputs[4], VK_CONTROL, 0);
    assert_input(inputs[5], VK_INSERT, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[6], VK_INSERT, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
    assert_input(inputs[7], VK_CONTROL, KEYEVENTF_KEYUP);
    assert_input(inputs[8], VK_DELETE, KEYEVENTF_EXTENDEDKEY);
    assert_input(inputs[9], VK_DELETE, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
}

static void test_extended_key_table()
{
    require(is_extended_key(VK_LEFT));
    require(is_extended_key(VK_RIGHT));
    require(is_extended_key(VK_HOME));
    require(is_extended_key(VK_END));
    require(is_extended_key(VK_INSERT));
    require(is_extended_key(VK_DELETE));
    require(is_extended_key(VK_RCONTROL));
    require(!is_extended_key(VK_CONTROL));
    require(!is_extended_key(VK_SHIFT));
    require(!is_extended_key('A'));
}

static void test_single_regular_key()
{
    auto inputs = build_key_click_inputs(std::vector<int>{ 'A' });

    require(inputs.size() == 2);
    assert_input(inputs[0], 'A', 0);
    assert_input(inputs[1], 'A', KEYEVENTF_KEYUP);
    require(!has_flag(inputs[0].ki.dwFlags, KEYEVENTF_EXTENDEDKEY));
}

static void test_repeated_source_key_while_caps_is_held()
{
    key2hook_.clear();
    triggered_keys_.clear();
    capslock_pressed_ = true;
    status_ = HookStatus::Normal;

    int trigger_count = 0;
    {
        std::lock_guard lock(key2hook_mutex_);
        key2hook_['W'] = KeyHookItem{ 'W', {}, [&trigger_count] { ++trigger_count; }, "test" };
    }

    require(hook_other_key('W', WM_KEYDOWN));
    require(trigger_count == 1);
    require(hook_other_key('W', WM_KEYDOWN));
    require(trigger_count == 1);
    require(hook_other_key('W', WM_KEYUP));
    require(hook_other_key('W', WM_KEYDOWN));
    require(trigger_count == 2);

    reset_hook_status();
    key2hook_.clear();
}

int main()
{
    test_ctrl_left_sequence();
    test_shift_end_sequence();
    test_ctrl_shift_left_release_order();
    test_multi_step_sequence_does_not_overlap_modifiers();
    test_extended_key_table();
    test_single_regular_key();
    test_repeated_source_key_while_caps_is_held();
    return 0;
}