sym_defer_pk_tests.cpp (6081B)
1 /* Copyright 2021 Simon Arlott 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 2 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include "gtest/gtest.h" 18 19 #include "debounce_test_common.h" 20 21 TEST_F(DebounceTest, OneKeyShort1) { 22 addEvents({ 23 /* Time, Inputs, Outputs */ 24 {0, {{0, 1, DOWN}}, {}}, 25 26 {5, {}, {{0, 1, DOWN}}}, 27 /* 0ms delay (fast scan rate) */ 28 {5, {{0, 1, UP}}, {}}, 29 30 {10, {}, {{0, 1, UP}}}, 31 }); 32 runEvents(); 33 } 34 35 TEST_F(DebounceTest, OneKeyShort2) { 36 addEvents({ 37 /* Time, Inputs, Outputs */ 38 {0, {{0, 1, DOWN}}, {}}, 39 40 {5, {}, {{0, 1, DOWN}}}, 41 /* 1ms delay */ 42 {6, {{0, 1, UP}}, {}}, 43 44 {11, {}, {{0, 1, UP}}}, 45 }); 46 runEvents(); 47 } 48 49 TEST_F(DebounceTest, OneKeyShort3) { 50 addEvents({ 51 /* Time, Inputs, Outputs */ 52 {0, {{0, 1, DOWN}}, {}}, 53 54 {5, {}, {{0, 1, DOWN}}}, 55 /* 2ms delay */ 56 {7, {{0, 1, UP}}, {}}, 57 58 {12, {}, {{0, 1, UP}}}, 59 }); 60 runEvents(); 61 } 62 63 TEST_F(DebounceTest, OneKeyTooQuick1) { 64 addEvents({ 65 /* Time, Inputs, Outputs */ 66 {0, {{0, 1, DOWN}}, {}}, 67 /* Release key exactly on the debounce time */ 68 {5, {{0, 1, UP}}, {}}, 69 }); 70 runEvents(); 71 } 72 73 TEST_F(DebounceTest, OneKeyTooQuick2) { 74 addEvents({ 75 /* Time, Inputs, Outputs */ 76 {0, {{0, 1, DOWN}}, {}}, 77 78 {5, {}, {{0, 1, DOWN}}}, 79 {6, {{0, 1, UP}}, {}}, 80 81 /* Press key exactly on the debounce time */ 82 {11, {{0, 1, DOWN}}, {}}, 83 }); 84 runEvents(); 85 } 86 87 TEST_F(DebounceTest, OneKeyBouncing1) { 88 addEvents({ 89 /* Time, Inputs, Outputs */ 90 {0, {{0, 1, DOWN}}, {}}, 91 {1, {{0, 1, UP}}, {}}, 92 {2, {{0, 1, DOWN}}, {}}, 93 {3, {{0, 1, UP}}, {}}, 94 {4, {{0, 1, DOWN}}, {}}, 95 {5, {{0, 1, UP}}, {}}, 96 {6, {{0, 1, DOWN}}, {}}, 97 {11, {}, {{0, 1, DOWN}}}, /* 5ms after DOWN at time 7 */ 98 }); 99 runEvents(); 100 } 101 102 TEST_F(DebounceTest, OneKeyBouncing2) { 103 addEvents({ 104 /* Time, Inputs, Outputs */ 105 {0, {{0, 1, DOWN}}, {}}, 106 {5, {}, {{0, 1, DOWN}}}, 107 {6, {{0, 1, UP}}, {}}, 108 {7, {{0, 1, DOWN}}, {}}, 109 {8, {{0, 1, UP}}, {}}, 110 {9, {{0, 1, DOWN}}, {}}, 111 {10, {{0, 1, UP}}, {}}, 112 {15, {}, {{0, 1, UP}}}, /* 5ms after UP at time 10 */ 113 }); 114 runEvents(); 115 } 116 117 TEST_F(DebounceTest, OneKeyLong) { 118 addEvents({ 119 /* Time, Inputs, Outputs */ 120 {0, {{0, 1, DOWN}}, {}}, 121 122 {5, {}, {{0, 1, DOWN}}}, 123 124 {25, {{0, 1, UP}}, {}}, 125 126 {30, {}, {{0, 1, UP}}}, 127 128 {50, {{0, 1, DOWN}}, {}}, 129 130 {55, {}, {{0, 1, DOWN}}}, 131 }); 132 runEvents(); 133 } 134 135 TEST_F(DebounceTest, TwoKeysShort) { 136 addEvents({ 137 /* Time, Inputs, Outputs */ 138 {0, {{0, 1, DOWN}}, {}}, 139 {1, {{0, 2, DOWN}}, {}}, 140 141 {5, {}, {{0, 1, DOWN}}}, 142 {6, {}, {{0, 2, DOWN}}}, 143 144 {7, {{0, 1, UP}}, {}}, 145 {8, {{0, 2, UP}}, {}}, 146 147 {12, {}, {{0, 1, UP}}}, 148 {13, {}, {{0, 2, UP}}}, 149 }); 150 runEvents(); 151 } 152 153 TEST_F(DebounceTest, TwoKeysSimultaneous1) { 154 addEvents({ 155 /* Time, Inputs, Outputs */ 156 {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}}, 157 158 {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, 159 {6, {{0, 1, UP}, {0, 2, UP}}, {}}, 160 161 {11, {}, {{0, 1, UP}, {0, 2, UP}}}, 162 }); 163 runEvents(); 164 } 165 166 TEST_F(DebounceTest, TwoKeysSimultaneous2) { 167 addEvents({ 168 /* Time, Inputs, Outputs */ 169 {0, {{0, 1, DOWN}}, {}}, 170 {1, {{0, 2, DOWN}}, {}}, 171 172 {5, {}, {{0, 1, DOWN}}}, 173 {6, {{0, 1, UP}}, {{0, 2, DOWN}}}, 174 {7, {{0, 2, UP}}, {}}, 175 176 {11, {}, {{0, 1, UP}}}, 177 {12, {}, {{0, 2, UP}}}, 178 }); 179 runEvents(); 180 } 181 182 TEST_F(DebounceTest, OneKeyDelayedScan1) { 183 addEvents({ 184 /* Time, Inputs, Outputs */ 185 {0, {{0, 1, DOWN}}, {}}, 186 187 /* Processing is very late */ 188 {300, {}, {{0, 1, DOWN}}}, 189 /* Immediately release key */ 190 {300, {{0, 1, UP}}, {}}, 191 192 {305, {}, {{0, 1, UP}}}, 193 }); 194 time_jumps_ = true; 195 runEvents(); 196 } 197 198 TEST_F(DebounceTest, OneKeyDelayedScan2) { 199 addEvents({ 200 /* Time, Inputs, Outputs */ 201 {0, {{0, 1, DOWN}}, {}}, 202 203 /* Processing is very late */ 204 {300, {}, {{0, 1, DOWN}}}, 205 /* Release key after 1ms */ 206 {301, {{0, 1, UP}}, {}}, 207 208 {306, {}, {{0, 1, UP}}}, 209 }); 210 time_jumps_ = true; 211 runEvents(); 212 } 213 214 TEST_F(DebounceTest, OneKeyDelayedScan3) { 215 addEvents({ 216 /* Time, Inputs, Outputs */ 217 {0, {{0, 1, DOWN}}, {}}, 218 219 /* Release key before debounce expires */ 220 {300, {{0, 1, UP}}, {}}, 221 }); 222 time_jumps_ = true; 223 runEvents(); 224 } 225 226 TEST_F(DebounceTest, OneKeyDelayedScan4) { 227 addEvents({ 228 /* Time, Inputs, Outputs */ 229 {0, {{0, 1, DOWN}}, {}}, 230 231 /* Processing is a bit late */ 232 {50, {}, {{0, 1, DOWN}}}, 233 /* Release key after 1ms */ 234 {51, {{0, 1, UP}}, {}}, 235 236 {56, {}, {{0, 1, UP}}}, 237 }); 238 time_jumps_ = true; 239 runEvents(); 240 } 241 242 TEST_F(DebounceTest, AsyncTickOneKeyShort1) { 243 addEvents({ 244 /* Time, Inputs, Outputs */ 245 {0, {{0, 1, DOWN}}, {}}, 246 247 {5, {}, {{0, 1, DOWN}}}, 248 /* 0ms delay (fast scan rate) */ 249 {5, {{0, 1, UP}}, {}}, 250 251 {10, {}, {{0, 1, UP}}}, 252 }); 253 /* 254 * Debounce implementations should never read the timer more than once per invocation 255 */ 256 async_time_jumps_ = DEBOUNCE; 257 runEvents(); 258 }