logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

none_tests.cpp (6233B)

    

  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.  */
  17. #include "gtest/gtest.h"
  19. #include "debounce_test_common.h"
  21. TEST_F(DebounceTest, OneKeyShort1) {
  22.     addEvents({
  23.         /* Time, Inputs, Outputs */
  24.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  26.         {5, {}, {}},
  27.         /* 0ms delay (fast scan rate) */
  28.         {5, {{0, 1, UP}}, {{0, 1, UP}}},
  30.         {10, {}, {}},
  31.     });
  32.     runEvents();
  33. }
  35. TEST_F(DebounceTest, OneKeyShort2) {
  36.     addEvents({
  37.         /* Time, Inputs, Outputs */
  38.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  40.         {5, {}, {}},
  41.         /* 1ms delay */
  42.         {6, {{0, 1, UP}}, {{0, 1, UP}}},
  44.         {11, {}, {}},
  45.     });
  46.     runEvents();
  47. }
  49. TEST_F(DebounceTest, OneKeyShort3) {
  50.     addEvents({
  51.         /* Time, Inputs, Outputs */
  52.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  54.         {5, {}, {}},
  55.         /* 2ms delay */
  56.         {7, {{0, 1, UP}}, {{0, 1, UP}}},
  58.         {12, {}, {}},
  59.     });
  60.     runEvents();
  61. }
  63. TEST_F(DebounceTest, OneKeyTooQuick1) {
  64.     addEvents({
  65.         /* Time, Inputs, Outputs */
  66.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  67.         /* Release key exactly on the debounce time */
  68.         {5, {{0, 1, UP}}, {{0, 1, UP}}},
  69.     });
  70.     runEvents();
  71. }
  73. TEST_F(DebounceTest, OneKeyTooQuick2) {
  74.     addEvents({
  75.         /* Time, Inputs, Outputs */
  76.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  78.         {5, {}, {}},
  79.         {6, {{0, 1, UP}}, {{0, 1, UP}}},
  81.         /* Press key exactly on the debounce time */
  82.         {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  83.     });
  84.     runEvents();
  85. }
  87. TEST_F(DebounceTest, OneKeyBouncing1) {
  88.     addEvents({
  89.         /* Time, Inputs, Outputs */
  90.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  91.         {1, {{0, 1, UP}}, {{0, 1, UP}}},
  92.         {2, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  93.         {3, {{0, 1, UP}}, {{0, 1, UP}}},
  94.         {4, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  95.         {5, {{0, 1, UP}}, {{0, 1, UP}}},
  96.         {6, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  97.         {11, {{0, 1, UP}}, {{0, 1, UP}}}, /* 5ms after DOWN at time 7 */
  98.     });
  99.     runEvents();
  100. }
  102. TEST_F(DebounceTest, OneKeyBouncing2) {
  103.     addEvents({
  104.         /* Time, Inputs, Outputs */
  105.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  106.         {5, {}, {}},
  107.         {6, {{0, 1, UP}}, {{0, 1, UP}}},
  108.         {7, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  109.         {8, {{0, 1, UP}}, {{0, 1, UP}}},
  110.         {9, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  111.         {10, {{0, 1, UP}}, {{0, 1, UP}}},
  112.         {15, {}, {}}, /* 5ms after UP at time 10 */
  113.     });
  114.     runEvents();
  115. }
  117. TEST_F(DebounceTest, OneKeyLong) {
  118.     addEvents({
  119.         /* Time, Inputs, Outputs */
  120.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  122.         {5, {}, {}},
  124.         {25, {{0, 1, UP}}, {{0, 1, UP}}},
  126.         {30, {}, {}},
  128.         {50, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  130.         {55, {}, {}},
  131.     });
  132.     runEvents();
  133. }
  135. TEST_F(DebounceTest, TwoKeysShort) {
  136.     addEvents({
  137.         /* Time, Inputs, Outputs */
  138.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  139.         {1, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
  141.         {6, {}, {}},
  143.         {7, {{0, 1, UP}}, {{0, 1, UP}}},
  144.         {8, {{0, 2, UP}}, {{0, 2, UP}}},
  146.         {13, {}, {}},
  147.     });
  148.     runEvents();
  149. }
  151. TEST_F(DebounceTest, TwoKeysSimultaneous1) {
  152.     addEvents({
  153.         /* Time, Inputs, Outputs */
  154.         {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}},
  156.         {5, {}, {}},
  157.         {6, {{0, 1, UP}, {0, 2, UP}}, {{0, 1, UP}, {0, 2, UP}}},
  159.         {11, {}, {}},
  160.     });
  161.     runEvents();
  162. }
  164. TEST_F(DebounceTest, TwoKeysSimultaneous2) {
  165.     addEvents({
  166.         /* Time, Inputs, Outputs */
  167.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  168.         {1, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
  170.         {5, {}, {}},
  171.         {6, {}, {}},
  172.         {7, {{0, 1, UP}}, {{0, 1, UP}}},
  173.         {8, {{0, 2, UP}}, {{0, 2, UP}}},
  175.         {13, {}, {}},
  176.     });
  177.     runEvents();
  178. }
  180. TEST_F(DebounceTest, OneKeyDelayedScan1) {
  181.     addEvents({
  182.         /* Time, Inputs, Outputs */
  183.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  185.         /* Processing is very late */
  186.         {300, {}, {}},
  187.         /* Immediately release key */
  188.         {300, {{0, 1, UP}}, {{0, 1, UP}}},
  190.         {305, {}, {}},
  191.     });
  192.     time_jumps_ = true;
  193.     runEvents();
  194. }
  196. TEST_F(DebounceTest, OneKeyDelayedScan2) {
  197.     addEvents({
  198.         /* Time, Inputs, Outputs */
  199.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  201.         /* Processing is very late */
  202.         {300, {}, {}},
  203.         /* Release key after 1ms */
  204.         {301, {{0, 1, UP}}, {{0, 1, UP}}},
  206.         {306, {}, {}},
  207.     });
  208.     time_jumps_ = true;
  209.     runEvents();
  210. }
  212. TEST_F(DebounceTest, OneKeyDelayedScan3) {
  213.     addEvents({
  214.         /* Time, Inputs, Outputs */
  215.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  217.         /* Release key before debounce expires */
  218.         {300, {{0, 1, UP}}, {{0, 1, UP}}},
  219.     });
  220.     time_jumps_ = true;
  221.     runEvents();
  222. }
  224. TEST_F(DebounceTest, OneKeyDelayedScan4) {
  225.     addEvents({
  226.         /* Time, Inputs, Outputs */
  227.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  229.         /* Processing is a bit late */
  230.         {50, {}, {}},
  231.         /* Release key after 1ms */
  232.         {51, {{0, 1, UP}}, {{0, 1, UP}}},
  234.         {56, {}, {}},
  235.     });
  236.     time_jumps_ = true;
  237.     runEvents();
  238. }
  240. TEST_F(DebounceTest, AsyncTickOneKeyShort1) {
  241.     addEvents({
  242.         /* Time, Inputs, Outputs */
  243.         {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  245.         {5, {}, {}},
  246.         /* 0ms delay (fast scan rate) */
  247.         {5, {{0, 1, UP}}, {{0, 1, UP}}},
  249.         {10, {}, {}},
  250.     });
  251.     /*
  252.      * Debounce implementations should never read the timer more than once per invocation
  253.      */
  254.     async_time_jumps_ = DEBOUNCE;
  255.     runEvents();
  256. }