mh
/
qmk_firmware
mirror of https://github.com/qmk/qmk_firmware/
1
0
Fork 0
Code Issues 0 Projects 0 Releases 1.6k Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
18056 Commits
63 Branches
2.5 GiB
Tree: 2c5d66987d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2c5d66987d'
${ noResults }
qmk_firmware/quantum/debounce/tests/sym_defer_pk_tests.cpp

240 lines
5.5 KiB
Raw Normal View History

Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
Format code according to conventions (#15193)
2 years ago
​
Avoid 8-bit timer overflows in debounce algorithms (#12240) * Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce tests
2 years ago
​
​
​
​
​
​
​
​
​
​
​
 
  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. }