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.

394 lines
11 KiB

  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. #include "gtest/gtest.h"
  17. #include "debounce_test_common.h"
  18. TEST_F(DebounceTest, OneKeyShort1) {
  19. addEvents({
  20. /* Time, Inputs, Outputs */
  21. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  22. /* Release key after 1ms delay */
  23. {1, {{0, 1, UP}}, {}},
  24. /*
  25. * Until the eager timer on DOWN is observed to finish, the defer timer
  26. * on UP can't start. There's no workaround for this because it's not
  27. * possible to debounce an event that isn't being tracked.
  28. *
  29. * sym_defer_pk has the same problem but the test has to track that the
  30. * key changed state so the DOWN timer is always allowed to finish
  31. * before starting the UP timer.
  32. */
  33. {5, {}, {}},
  34. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  35. /* Press key again after 1ms delay */
  36. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  37. });
  38. runEvents();
  39. }
  40. TEST_F(DebounceTest, OneKeyShort2) {
  41. addEvents({
  42. /* Time, Inputs, Outputs */
  43. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  44. /* Release key after 2ms delay */
  45. {2, {{0, 1, UP}}, {}},
  46. {5, {}, {}}, /* See OneKeyShort1 */
  47. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  48. /* Press key again after 1ms delay */
  49. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  50. });
  51. runEvents();
  52. }
  53. TEST_F(DebounceTest, OneKeyShort3) {
  54. addEvents({
  55. /* Time, Inputs, Outputs */
  56. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  57. /* Release key after 3ms delay */
  58. {3, {{0, 1, UP}}, {}},
  59. {5, {}, {}}, /* See OneKeyShort1 */
  60. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  61. /* Press key again after 1ms delay */
  62. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  63. });
  64. runEvents();
  65. }
  66. TEST_F(DebounceTest, OneKeyShort4) {
  67. addEvents({
  68. /* Time, Inputs, Outputs */
  69. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  70. /* Release key after 4ms delay */
  71. {4, {{0, 1, UP}}, {}},
  72. {5, {}, {}}, /* See OneKeyShort1 */
  73. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  74. /* Press key again after 1ms delay */
  75. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  76. });
  77. runEvents();
  78. }
  79. TEST_F(DebounceTest, OneKeyShort5) {
  80. addEvents({
  81. /* Time, Inputs, Outputs */
  82. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  83. /* Release key after 5ms delay */
  84. {5, {{0, 1, UP}}, {}},
  85. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  86. /* Press key again after 1ms delay */
  87. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  88. });
  89. runEvents();
  90. }
  91. TEST_F(DebounceTest, OneKeyShort6) {
  92. addEvents({
  93. /* Time, Inputs, Outputs */
  94. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  95. /* Release key after 6ms delay */
  96. {6, {{0, 1, UP}}, {}},
  97. {11, {}, {{0, 1, UP}}}, /* 5ms after UP at time 6 */
  98. /* Press key again after 1ms delay */
  99. {12, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  100. });
  101. runEvents();
  102. }
  103. TEST_F(DebounceTest, OneKeyShort7) {
  104. addEvents({
  105. /* Time, Inputs, Outputs */
  106. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  107. /* Release key after 7ms delay */
  108. {7, {{0, 1, UP}}, {}},
  109. {12, {}, {{0, 1, UP}}}, /* 5ms after UP at time 7 */
  110. /* Press key again after 1ms delay */
  111. {13, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  112. });
  113. runEvents();
  114. }
  115. TEST_F(DebounceTest, OneKeyShort8) {
  116. addEvents({
  117. /* Time, Inputs, Outputs */
  118. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  119. /* Release key after 1ms delay */
  120. {1, {{0, 1, UP}}, {}},
  121. {5, {}, {}}, /* See OneKeyShort1 */
  122. {10, {}, {{0, 1, UP}}}, /* 5ms after UP at time 7 */
  123. /* Press key again after 0ms delay (scan 2) */
  124. {10, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  125. });
  126. runEvents();
  127. }
  128. TEST_F(DebounceTest, OneKeyShort9) {
  129. addEvents({
  130. /* Time, Inputs, Outputs */
  131. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  132. /* Release key after 1ms delay */
  133. {1, {{0, 1, UP}}, {}},
  134. {5, {}, {}}, /* See OneKeyShort1 */
  135. /* Press key again after 0ms delay (same scan) before debounce finishes */
  136. {10, {{0, 1, DOWN}}, {}},
  137. });
  138. runEvents();
  139. }
  140. TEST_F(DebounceTest, OneKeyBouncing1) {
  141. addEvents({
  142. /* Time, Inputs, Outputs */
  143. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  144. {1, {{0, 1, UP}}, {}},
  145. {2, {{0, 1, DOWN}}, {}},
  146. {3, {{0, 1, UP}}, {}},
  147. {4, {{0, 1, DOWN}}, {}},
  148. {5, {{0, 1, UP}}, {}},
  149. {6, {{0, 1, DOWN}}, {}},
  150. {7, {{0, 1, UP}}, {}},
  151. {8, {{0, 1, DOWN}}, {}},
  152. {9, {{0, 1, UP}}, {}},
  153. {10, {{0, 1, DOWN}}, {}},
  154. {11, {{0, 1, UP}}, {}},
  155. {12, {{0, 1, DOWN}}, {}},
  156. {13, {{0, 1, UP}}, {}},
  157. {14, {{0, 1, DOWN}}, {}},
  158. {15, {{0, 1, UP}}, {}},
  159. {20, {}, {{0, 1, UP}}},
  160. /* Press key again after 1ms delay */
  161. {21, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  162. });
  163. runEvents();
  164. }
  165. TEST_F(DebounceTest, OneKeyBouncing2) {
  166. addEvents({
  167. /* Time, Inputs, Outputs */
  168. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  169. /* Change twice in the same time period */
  170. {1, {{0, 1, UP}}, {}},
  171. {1, {{0, 1, DOWN}}, {}},
  172. /* Change three times in the same time period */
  173. {2, {{0, 1, UP}}, {}},
  174. {2, {{0, 1, DOWN}}, {}},
  175. {2, {{0, 1, UP}}, {}},
  176. /* Change twice in the same time period */
  177. {6, {{0, 1, DOWN}}, {}},
  178. {6, {{0, 1, UP}}, {}},
  179. /* Change three times in the same time period */
  180. {7, {{0, 1, DOWN}}, {}},
  181. {7, {{0, 1, UP}}, {}},
  182. {7, {{0, 1, DOWN}}, {}},
  183. /* Change twice in the same time period */
  184. {8, {{0, 1, UP}}, {}},
  185. {8, {{0, 1, DOWN}}, {}},
  186. /* Change three times in the same time period */
  187. {9, {{0, 1, UP}}, {}},
  188. {9, {{0, 1, DOWN}}, {}},
  189. {9, {{0, 1, UP}}, {}},
  190. {14, {}, {{0, 1, UP}}},
  191. /* Press key again after 1ms delay */
  192. {15, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  193. });
  194. runEvents();
  195. }
  196. TEST_F(DebounceTest, OneKeyLong) {
  197. addEvents({
  198. /* Time, Inputs, Outputs */
  199. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  200. {25, {{0, 1, UP}}, {}},
  201. {30, {}, {{0, 1, UP}}},
  202. {50, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  203. {75, {{0, 1, UP}}, {}},
  204. {80, {}, {{0, 1, UP}}},
  205. {100, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  206. });
  207. runEvents();
  208. }
  209. TEST_F(DebounceTest, TwoKeysShort) {
  210. addEvents({
  211. /* Time, Inputs, Outputs */
  212. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  213. {1, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
  214. /* Release key after 2ms delay */
  215. {2, {{0, 1, UP}}, {}},
  216. {3, {{0, 2, UP}}, {}},
  217. {5, {}, {}}, /* See OneKeyShort1 */
  218. {6, {}, {}}, /* See OneKeyShort1 */
  219. {10, {}, {{0, 1, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  220. /* Press key again after 1ms delay */
  221. {11, {{0, 1, DOWN}}, {{0, 1, DOWN}, {0, 2, UP}}}, /* 5ms+5ms after DOWN at time 0 */
  222. {12, {{0, 2, DOWN}}, {{0, 2, DOWN}}}, /* 5ms+5ms after DOWN at time 0 */
  223. });
  224. runEvents();
  225. }
  226. TEST_F(DebounceTest, OneKeyDelayedScan1) {
  227. addEvents({
  228. /* Time, Inputs, Outputs */
  229. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  230. /* Processing is very late, immediately release key */
  231. {300, {{0, 1, UP}}, {}},
  232. {305, {}, {{0, 1, UP}}},
  233. });
  234. time_jumps_ = true;
  235. runEvents();
  236. }
  237. TEST_F(DebounceTest, OneKeyDelayedScan2) {
  238. addEvents({
  239. /* Time, Inputs, Outputs */
  240. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  241. /* Processing is very late, immediately release key */
  242. {300, {{0, 1, UP}}, {}},
  243. /* Processing is very late again */
  244. {600, {}, {{0, 1, UP}}},
  245. });
  246. time_jumps_ = true;
  247. runEvents();
  248. }
  249. TEST_F(DebounceTest, OneKeyDelayedScan3) {
  250. addEvents({
  251. /* Time, Inputs, Outputs */
  252. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  253. /* Processing is very late */
  254. {300, {}, {}},
  255. /* Release key after 1ms */
  256. {301, {{0, 1, UP}}, {}},
  257. {306, {}, {{0, 1, UP}}},
  258. });
  259. time_jumps_ = true;
  260. runEvents();
  261. }
  262. TEST_F(DebounceTest, OneKeyDelayedScan4) {
  263. addEvents({
  264. /* Time, Inputs, Outputs */
  265. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  266. /* Processing is very late */
  267. {300, {}, {}},
  268. /* Release key after 1ms */
  269. {301, {{0, 1, UP}}, {}},
  270. /* Processing is very late again */
  271. {600, {}, {{0, 1, UP}}},
  272. });
  273. time_jumps_ = true;
  274. runEvents();
  275. }
  276. TEST_F(DebounceTest, OneKeyDelayedScan5) {
  277. addEvents({
  278. /* Time, Inputs, Outputs */
  279. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  280. {5, {{0, 1, UP}}, {}},
  281. /* Processing is very late */
  282. {300, {}, {{0, 1, UP}}},
  283. /* Immediately press key again */
  284. {300, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  285. });
  286. time_jumps_ = true;
  287. runEvents();
  288. }
  289. TEST_F(DebounceTest, OneKeyDelayedScan6) {
  290. addEvents({
  291. /* Time, Inputs, Outputs */
  292. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  293. {5, {{0, 1, UP}}, {}},
  294. /* Processing is very late */
  295. {300, {}, {{0, 1, UP}}},
  296. /* Press key again after 1ms */
  297. {301, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  298. });
  299. time_jumps_ = true;
  300. runEvents();
  301. }
  302. TEST_F(DebounceTest, OneKeyDelayedScan7) {
  303. addEvents({
  304. /* Time, Inputs, Outputs */
  305. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  306. {5, {{0, 1, UP}}, {}},
  307. /* Press key again before debounce expires */
  308. {300, {{0, 1, DOWN}}, {}},
  309. });
  310. time_jumps_ = true;
  311. runEvents();
  312. }
  313. TEST_F(DebounceTest, OneKeyDelayedScan8) {
  314. addEvents({
  315. /* Time, Inputs, Outputs */
  316. {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
  317. /* Processing is a bit late */
  318. {50, {}, {}},
  319. /* Release key after 1ms */
  320. {51, {{0, 1, UP}}, {}},
  321. /* Processing is a bit late again */
  322. {100, {}, {{0, 1, UP}}},
  323. });
  324. time_jumps_ = true;
  325. runEvents();
  326. }