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.

1259 lines
40 KiB

  1. #include "minunit.h"
  2. #include "test_keymap.c"
  3. MAIN
  4. // CLEAR_KB
  5. TEST("clear")
  6. for (int i = 0; i < NUMBER_OF_CHORDS; i++) {
  7. struct Chord* chord_ptr = (struct Chord*) pgm_read_word (&list_of_chords[i]);
  8. struct Chord chord_storage;
  9. memcpy_P(&chord_storage, chord_ptr, sizeof(struct Chord));
  10. struct Chord* chord = &chord_storage;
  11. *chord->state = READY;
  12. if (chord->counter) {
  13. *chord->counter = 1;
  14. }
  15. }
  16. history_index++;
  17. for (int j = 0; j < SAFE_RANGE-1; j++) {
  18. keyboard_history[history_index][j] = 1;
  19. }
  20. current_pseudolayer = 5;
  21. lock_next = true;
  22. autoshift_mode = false;
  23. command_mode = 1;
  24. in_leader_mode = true;
  25. dynamic_macro_mode = true;
  26. a_key_went_through = true;
  27. for (int i = 0; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
  28. dynamic_macro_buffer[i] = 1;
  29. }
  30. uint8_t clear_state = ACTIVATED;
  31. struct Chord clear_chord PROGMEM = {0, QWERTY, &clear_state, NULL, 0, 0, clear};
  32. clear_chord.function(&clear_chord);
  33. for (int i = 0; i < NUMBER_OF_CHORDS; i++) {
  34. struct Chord* chord_ptr = (struct Chord*) pgm_read_word (&list_of_chords[i]);
  35. struct Chord chord_storage;
  36. memcpy_P(&chord_storage, chord_ptr, sizeof(struct Chord));
  37. struct Chord* chord = &chord_storage;
  38. ASSERT_EQ(UINT, *chord->state, IDLE);
  39. if (chord->counter) {
  40. ASSERT_EQ(UINT, *chord->counter, 0);
  41. }
  42. }
  43. for (int j = 0; j < SAFE_RANGE-1; j++) {
  44. ASSERT_EQ(UINT, keyboard_history[history_index][j], 0);
  45. }
  46. ASSERT_EQ(UINT, current_pseudolayer, 1);
  47. ASSERT_EQ(UINT, lock_next, false);
  48. ASSERT_EQ(UINT, autoshift_mode, true);
  49. ASSERT_EQ(UINT, command_mode, 0);
  50. ASSERT_EQ(UINT, in_leader_mode, false);
  51. ASSERT_EQ(UINT, leader_ind, 0);
  52. ASSERT_EQ(UINT, dynamic_macro_mode, false);
  53. ASSERT_EQ(UINT, a_key_went_through, false);
  54. for (int i = 0; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
  55. ASSERT_EQ(UINT, dynamic_macro_buffer[i], 0);
  56. }
  57. END_TEST
  58. TEST("pause_ms")
  59. pause_ms(500);
  60. ASSERT_EQ(UINT, current_time, 500);
  61. END_TEST
  62. // KC
  63. TEST("single_dance_held_states")
  64. ASSERT_EQ(UINT, state_1, IDLE);
  65. process_record_user(TOP1, &pressed);
  66. pause_ms(CHORD_TIMEOUT);
  67. ASSERT_EQ(UINT, state_1, IDLE);
  68. pause_ms(1);
  69. ASSERT_EQ(UINT, state_1, ACTIVATED);
  70. pause_ms(DANCE_TIMEOUT);
  71. ASSERT_EQ(UINT, state_1, ACTIVATED);
  72. pause_ms(1);
  73. ASSERT_EQ(UINT, state_1, PRESS_FROM_ACTIVE);
  74. pause_ms(DANCE_TIMEOUT);
  75. ASSERT_EQ(UINT, state_1, PRESS_FROM_ACTIVE);
  76. pause_ms(1);
  77. ASSERT_EQ(UINT, state_1, FINISHED_FROM_ACTIVE);
  78. process_record_user(TOP1, &depressed);
  79. ASSERT_EQ(UINT, state_1, IDLE);
  80. END_TEST
  81. TEST("single_dance_held_codes")
  82. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  83. process_record_user(TOP1, &pressed);
  84. pause_ms(CHORD_TIMEOUT);
  85. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  86. pause_ms(1);
  87. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  88. pause_ms(DANCE_TIMEOUT);
  89. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  90. pause_ms(1);
  91. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  92. pause_ms(DANCE_TIMEOUT);
  93. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  94. pause_ms(1);
  95. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  96. process_record_user(TOP1, &depressed);
  97. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  98. END_TEST
  99. TEST("single_dance_tapped_states")
  100. ASSERT_EQ(UINT, state_1, IDLE);
  101. process_record_user(TOP1, &pressed);
  102. pause_ms(CHORD_TIMEOUT);
  103. ASSERT_EQ(UINT, state_1, IDLE);
  104. pause_ms(1);
  105. ASSERT_EQ(UINT, state_1, ACTIVATED);
  106. process_record_user(TOP1, &depressed);
  107. ASSERT_EQ(UINT, state_1, IDLE);
  108. END_TEST
  109. TEST("single_dance_tapped_codes")
  110. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  111. process_record_user(TOP1, &pressed);
  112. pause_ms(CHORD_TIMEOUT);
  113. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  114. pause_ms(1);
  115. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  116. process_record_user(TOP1, &depressed);
  117. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  118. END_TEST
  119. // I can not actually track the states if the tap is faster than chord timeout
  120. TEST("single_dance_tapped_fast_codes")
  121. ASSERT_EQ(UINT, state_0, IDLE);
  122. process_record_user(TOP1, &pressed);
  123. pause_ms(1);
  124. process_record_user(TOP1, &depressed);
  125. ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
  126. ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 1);
  127. ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 0);
  128. END_TEST
  129. TEST("subchords_are_ignored")
  130. ASSERT_EQ(UINT, state_0, IDLE);
  131. process_record_user(TOP1, &pressed);
  132. pause_ms(1);
  133. process_record_user(TOP2, &pressed);
  134. pause_ms(CHORD_TIMEOUT + 1);
  135. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  136. ASSERT_EQ(UINT, keyboard_history[history_index][KC_W], 0);
  137. ASSERT_EQ(UINT, keyboard_history[history_index][KC_ESC], 1);
  138. END_TEST
  139. TEST("multiple_chords_at_once")
  140. ASSERT_EQ(UINT, state_0, IDLE);
  141. process_record_user(TOP1, &pressed);
  142. pause_ms(1);
  143. process_record_user(TOP3, &pressed);
  144. pause_ms(CHORD_TIMEOUT + 1);
  145. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
  146. ASSERT_EQ(UINT, keyboard_history[history_index][KC_E], 1);
  147. END_TEST
  148. // MO
  149. TEST("momentary_layer")
  150. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  151. process_record_user(BOT7, &pressed);
  152. pause_ms(1);
  153. process_record_user(BOT8, &pressed);
  154. pause_ms(CHORD_TIMEOUT + 1);
  155. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  156. process_record_user(BOT7, &depressed);
  157. pause_ms(1);
  158. process_record_user(BOT8, &depressed);
  159. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  160. END_TEST
  161. TEST("momentary_layer_reset")
  162. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  163. process_record_user(BOT7, &pressed);
  164. pause_ms(1);
  165. process_record_user(BOT8, &pressed);
  166. pause_ms(CHORD_TIMEOUT + 1);
  167. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  168. pause_ms(DANCE_TIMEOUT + 1);
  169. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  170. process_record_user(BOT7, &depressed);
  171. pause_ms(1);
  172. process_record_user(BOT8, &depressed);
  173. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  174. END_TEST
  175. TEST("momentary_layer_alt")
  176. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  177. process_record_user(TOP8, &pressed);
  178. pause_ms(1);
  179. process_record_user(TOP9, &pressed);
  180. pause_ms(1);
  181. process_record_user(TOP0, &pressed);
  182. pause_ms(1);
  183. process_record_user(BOT8, &pressed);
  184. pause_ms(1);
  185. process_record_user(BOT9, &pressed);
  186. pause_ms(1);
  187. process_record_user(BOT0, &pressed);
  188. pause_ms(CHORD_TIMEOUT + 1);
  189. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  190. process_record_user(TOP8, &depressed);
  191. pause_ms(1);
  192. process_record_user(TOP9, &depressed);
  193. pause_ms(1);
  194. process_record_user(TOP0, &depressed);
  195. pause_ms(1);
  196. process_record_user(BOT8, &depressed);
  197. pause_ms(1);
  198. process_record_user(BOT9, &depressed);
  199. pause_ms(1);
  200. process_record_user(BOT0, &depressed);
  201. ASSERT_EQ(UINT, current_pseudolayer, FNC);
  202. END_TEST
  203. // DF
  204. TEST("permanent_layer")
  205. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  206. process_record_user(BOT9, &pressed);
  207. pause_ms(1);
  208. process_record_user(BOT0, &pressed);
  209. pause_ms(CHORD_TIMEOUT + 1);
  210. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  211. process_record_user(BOT9, &depressed);
  212. pause_ms(1);
  213. process_record_user(BOT0, &depressed);
  214. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  215. pause_ms(1000);
  216. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  217. END_TEST
  218. // AT
  219. TEST("autoshift_toggle")
  220. ASSERT_EQ(UINT, autoshift_mode, 1);
  221. uint8_t state = ACTIVATED;
  222. struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, autoshift_toggle};
  223. chord.function(&chord);
  224. ASSERT_EQ(UINT, autoshift_mode, 0);
  225. state = ACTIVATED;
  226. chord.function(&chord);
  227. ASSERT_EQ(UINT, autoshift_mode, 1);
  228. END_TEST
  229. // AS
  230. TEST("autoshift_tap")
  231. process_record_user(BOT1, &pressed);
  232. pause_ms(CHORD_TIMEOUT + 1);
  233. process_record_user(BOT1, &depressed);
  234. ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
  235. ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
  236. ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 1);
  237. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
  238. ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 0);
  239. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 0);
  240. END_TEST
  241. TEST("autoshift_hold")
  242. process_record_user(BOT1, &pressed);
  243. pause_ms(CHORD_TIMEOUT + 1);
  244. pause_ms(LONG_PRESS_MULTIPLIER * (DANCE_TIMEOUT + 1));
  245. process_record_user(BOT1, &depressed);
  246. ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
  247. ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
  248. ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 0);
  249. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 1);
  250. ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 1);
  251. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
  252. ASSERT_EQ(UINT, keyboard_history[3][KC_Z], 0);
  253. ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 1);
  254. ASSERT_EQ(UINT, keyboard_history[4][KC_Z], 0);
  255. ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
  256. END_TEST
  257. TEST("autoshift_hold_off")
  258. autoshift_mode = 0;
  259. process_record_user(BOT1, &pressed);
  260. pause_ms(CHORD_TIMEOUT + 1);
  261. pause_ms(LONG_PRESS_MULTIPLIER * (DANCE_TIMEOUT + 1));
  262. process_record_user(BOT1, &depressed);
  263. ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
  264. ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
  265. ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 1);
  266. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
  267. ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 0);
  268. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 0);
  269. END_TEST
  270. // LOCK
  271. TEST("lock")
  272. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  273. process_record_user(BOT1, &pressed);
  274. process_record_user(BOT2, &pressed);
  275. pause_ms(CHORD_TIMEOUT + 1);
  276. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  277. process_record_user(BOT1, &depressed);
  278. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  279. pause_ms(1);
  280. process_record_user(BOT2, &depressed);
  281. pause_ms(1);
  282. process_record_user(TOP1, &pressed);
  283. process_record_user(TOP2, &pressed);
  284. process_record_user(BOT1, &pressed);
  285. process_record_user(BOT2, &pressed);
  286. pause_ms(CHORD_TIMEOUT + 1);
  287. process_record_user(TOP1, &depressed);
  288. pause_ms(1);
  289. process_record_user(TOP2, &depressed);
  290. process_record_user(BOT1, &depressed);
  291. process_record_user(BOT2, &depressed);
  292. pause_ms(1);
  293. process_record_user(BOT1, &pressed);
  294. process_record_user(BOT2, &pressed);
  295. pause_ms(CHORD_TIMEOUT + 1);
  296. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  297. process_record_user(BOT1, &depressed);
  298. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  299. pause_ms(1);
  300. process_record_user(BOT2, &depressed);
  301. pause_ms(1000);
  302. process_record_user(BOT1, &pressed);
  303. process_record_user(BOT2, &pressed);
  304. pause_ms(CHORD_TIMEOUT + 1);
  305. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  306. process_record_user(BOT1, &depressed);
  307. pause_ms(1);
  308. process_record_user(BOT2, &depressed);
  309. pause_ms(1000);
  310. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  311. END_TEST
  312. // OSK
  313. TEST("one_shot_key_tap")
  314. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  315. process_record_user(BOT2, &pressed);
  316. process_record_user(BOT3, &pressed);
  317. pause_ms(CHORD_TIMEOUT + 1);
  318. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  319. process_record_user(BOT2, &depressed);
  320. pause_ms(1);
  321. process_record_user(BOT3, &depressed);
  322. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  323. pause_ms(1000);
  324. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  325. process_record_user(TOP1, &pressed);
  326. pause_ms(CHORD_TIMEOUT + 1);
  327. process_record_user(TOP1, &depressed);
  328. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  329. END_TEST
  330. TEST("one_shot_key_hold")
  331. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  332. process_record_user(BOT2, &pressed);
  333. process_record_user(BOT3, &pressed);
  334. pause_ms(CHORD_TIMEOUT + 1);
  335. pause_ms(DANCE_TIMEOUT + 1);
  336. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  337. process_record_user(TOP1, &pressed);
  338. pause_ms(CHORD_TIMEOUT + 1);
  339. process_record_user(TOP1, &depressed);
  340. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  341. process_record_user(BOT2, &depressed);
  342. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  343. END_TEST
  344. TEST("one_shot_key_retrotapping")
  345. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  346. process_record_user(BOT2, &pressed);
  347. process_record_user(BOT3, &pressed);
  348. pause_ms(CHORD_TIMEOUT + 1);
  349. pause_ms(DANCE_TIMEOUT + 1);
  350. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  351. pause_ms(1000);
  352. process_record_user(BOT2, &depressed);
  353. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
  354. END_TEST
  355. // OSL
  356. TEST("one_shot_layer_tap")
  357. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  358. process_record_user(BOT6, &pressed);
  359. process_record_user(BOT7, &pressed);
  360. pause_ms(CHORD_TIMEOUT + 1);
  361. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  362. process_record_user(BOT6, &depressed);
  363. pause_ms(1);
  364. process_record_user(BOT7, &depressed);
  365. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  366. pause_ms(1000);
  367. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  368. process_record_user(TOP1, &pressed);
  369. pause_ms(CHORD_TIMEOUT + 1);
  370. process_record_user(TOP1, &depressed);
  371. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  372. END_TEST
  373. TEST("one_shot_layer_hold")
  374. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  375. process_record_user(BOT6, &pressed);
  376. process_record_user(BOT7, &pressed);
  377. pause_ms(CHORD_TIMEOUT + 1);
  378. pause_ms(DANCE_TIMEOUT + 1);
  379. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  380. process_record_user(TOP1, &pressed);
  381. pause_ms(CHORD_TIMEOUT + 1);
  382. process_record_user(TOP1, &depressed);
  383. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  384. process_record_user(BOT6, &depressed);
  385. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  386. END_TEST
  387. TEST("one_shot_layer_retrotapping")
  388. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  389. process_record_user(BOT6, &pressed);
  390. process_record_user(BOT7, &pressed);
  391. pause_ms(CHORD_TIMEOUT + 1);
  392. pause_ms(DANCE_TIMEOUT + 1);
  393. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  394. pause_ms(1000);
  395. process_record_user(BOT6, &depressed);
  396. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  397. END_TEST
  398. // CMD
  399. TEST("command_mode")
  400. // start recording
  401. process_record_user(TOP5, &pressed);
  402. process_record_user(TOP6, &pressed);
  403. process_record_user(BOT5, &pressed);
  404. process_record_user(BOT6, &pressed);
  405. pause_ms(1);
  406. process_record_user(TOP5, &depressed);
  407. process_record_user(TOP6, &depressed);
  408. process_record_user(BOT5, &depressed);
  409. process_record_user(BOT6, &depressed);
  410. ASSERT_EQ(UINT, command_mode, 1);
  411. // record shift+q
  412. process_record_user(BOT1, &pressed);
  413. process_record_user(BOT2, &pressed);
  414. pause_ms(CHORD_TIMEOUT + 1);
  415. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  416. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  417. process_record_user(BOT1, &depressed);
  418. process_record_user(BOT2, &depressed);
  419. pause_ms(1000);
  420. process_record_user(TOP1, &pressed);
  421. pause_ms(CHORD_TIMEOUT + 1);
  422. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  423. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  424. process_record_user(TOP1, &depressed);
  425. pause_ms(1000);
  426. ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
  427. ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
  428. // execute
  429. process_record_user(TOP5, &pressed);
  430. process_record_user(TOP6, &pressed);
  431. process_record_user(BOT5, &pressed);
  432. process_record_user(BOT6, &pressed);
  433. pause_ms(CHORD_TIMEOUT + 1);
  434. ASSERT_EQ(UINT, command_mode, 0);
  435. // test history
  436. ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
  437. ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
  438. ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 0);
  439. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 1);
  440. ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 1);
  441. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
  442. ASSERT_EQ(UINT, keyboard_history[3][KC_Q], 1);
  443. ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 0);
  444. ASSERT_EQ(UINT, keyboard_history[4][KC_Q], 0);
  445. ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
  446. ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 255);
  447. ASSERT_EQ(UINT, keyboard_history[5][KC_LSFT], 255);
  448. END_TEST
  449. // KK
  450. TEST("key_key_dance_tap")
  451. process_record_user(BOT2, &pressed);
  452. pause_ms(CHORD_TIMEOUT + 1);
  453. process_record_user(BOT2, &depressed);
  454. ASSERT_EQ(UINT, keyboard_history[0][KC_X], 0);
  455. ASSERT_EQ(UINT, keyboard_history[0][KC_LCTL], 0);
  456. ASSERT_EQ(UINT, keyboard_history[1][KC_X], 1);
  457. ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 0);
  458. ASSERT_EQ(UINT, keyboard_history[2][KC_X], 0);
  459. ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 0);
  460. END_TEST
  461. TEST("key_key_dance_hold")
  462. process_record_user(BOT2, &pressed);
  463. pause_ms(CHORD_TIMEOUT + 1);
  464. pause_ms(DANCE_TIMEOUT + 1);
  465. process_record_user(BOT2, &depressed);
  466. ASSERT_EQ(UINT, keyboard_history[0][KC_X], 0);
  467. ASSERT_EQ(UINT, keyboard_history[0][KC_LCTL], 0);
  468. ASSERT_EQ(UINT, keyboard_history[1][KC_X], 0);
  469. ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
  470. ASSERT_EQ(UINT, keyboard_history[2][KC_X], 0);
  471. ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 0);
  472. END_TEST
  473. // KL
  474. TEST("key_layer_tap")
  475. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  476. process_record_user(BOT3, &pressed);
  477. pause_ms(CHORD_TIMEOUT + 1);
  478. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  479. process_record_user(BOT3, &depressed);
  480. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  481. pause_ms(1000);
  482. ASSERT_EQ(UINT, keyboard_history[0][KC_C], 0);
  483. ASSERT_EQ(UINT, keyboard_history[1][KC_C], 1);
  484. ASSERT_EQ(UINT, keyboard_history[2][KC_C], 0);
  485. ASSERT_EQ(UINT, keyboard_history[3][KC_C], 255);
  486. END_TEST
  487. TEST("key_layer_retrotapping")
  488. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  489. process_record_user(BOT3, &pressed);
  490. pause_ms(1000);
  491. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  492. process_record_user(BOT3, &depressed);
  493. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  494. pause_ms(1000);
  495. ASSERT_EQ(UINT, keyboard_history[0][KC_C], 0);
  496. ASSERT_EQ(UINT, keyboard_history[1][KC_C], 1);
  497. ASSERT_EQ(UINT, keyboard_history[2][KC_C], 0);
  498. ASSERT_EQ(UINT, keyboard_history[3][KC_C], 255);
  499. END_TEST
  500. TEST("key_layer_hold_quick_typist")
  501. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  502. process_record_user(BOT3, &pressed);
  503. pause_ms(CHORD_TIMEOUT + 1);
  504. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  505. pause_ms(1);
  506. process_record_user(TOP1, &pressed);
  507. pause_ms(1);
  508. process_record_user(TOP1, &depressed);
  509. pause_ms(1);
  510. process_record_user(TOP1, &pressed);
  511. pause_ms(1);
  512. process_record_user(TOP1, &depressed);
  513. pause_ms(1);
  514. process_record_user(TOP1, &pressed);
  515. pause_ms(1);
  516. process_record_user(TOP1, &depressed);
  517. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  518. pause_ms(1);
  519. process_record_user(BOT3, &depressed);
  520. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  521. ASSERT_EQ(UINT, keyboard_history[0][KC_1], 0);
  522. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  523. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
  524. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
  525. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  526. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
  527. ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
  528. ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
  529. END_TEST
  530. TEST("key_layer_hold_slow_typist")
  531. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  532. process_record_user(BOT3, &pressed);
  533. pause_ms(CHORD_TIMEOUT + 1);
  534. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  535. pause_ms(1000);
  536. process_record_user(TOP1, &pressed);
  537. pause_ms(1000);
  538. process_record_user(TOP1, &depressed);
  539. pause_ms(1000);
  540. process_record_user(TOP1, &pressed);
  541. pause_ms(1000);
  542. process_record_user(TOP1, &depressed);
  543. pause_ms(1000);
  544. process_record_user(TOP1, &pressed);
  545. pause_ms(1000);
  546. process_record_user(TOP1, &depressed);
  547. ASSERT_EQ(UINT, current_pseudolayer, NUM);
  548. pause_ms(1);
  549. process_record_user(BOT3, &depressed);
  550. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  551. ASSERT_EQ(UINT, keyboard_history[0][KC_1], 0);
  552. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  553. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
  554. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
  555. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  556. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
  557. ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
  558. ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
  559. END_TEST
  560. // KM
  561. TEST("key_mod_tap")
  562. ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
  563. ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
  564. process_record_user(BOT4, &pressed);
  565. pause_ms(CHORD_TIMEOUT + 1);
  566. ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
  567. ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
  568. process_record_user(BOT4, &depressed);
  569. ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 0);
  570. ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
  571. pause_ms(1000);
  572. ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 0);
  573. ASSERT_EQ(UINT, keyboard_history[3][KC_V], 1);
  574. ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 0);
  575. ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
  576. ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 255);
  577. ASSERT_EQ(UINT, keyboard_history[5][KC_V], 255);
  578. END_TEST
  579. TEST("key_mod_retrotapping")
  580. ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
  581. ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
  582. process_record_user(BOT4, &pressed);
  583. pause_ms(1000);
  584. ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
  585. ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
  586. process_record_user(BOT4, &depressed);
  587. ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 0);
  588. ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
  589. pause_ms(1000);
  590. ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 0);
  591. ASSERT_EQ(UINT, keyboard_history[3][KC_V], 1);
  592. ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 0);
  593. ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
  594. ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 255);
  595. ASSERT_EQ(UINT, keyboard_history[5][KC_V], 255);
  596. END_TEST
  597. TEST("key_mod_hold_quick_typist")
  598. process_record_user(BOT4, &pressed);
  599. pause_ms(CHORD_TIMEOUT + 1);
  600. pause_ms(1);
  601. process_record_user(TOP1, &pressed);
  602. pause_ms(1);
  603. process_record_user(TOP1, &depressed);
  604. pause_ms(1);
  605. process_record_user(TOP1, &pressed);
  606. pause_ms(1);
  607. process_record_user(TOP1, &depressed);
  608. pause_ms(1);
  609. process_record_user(TOP1, &pressed);
  610. pause_ms(1);
  611. process_record_user(TOP1, &depressed);
  612. pause_ms(1);
  613. process_record_user(BOT4, &depressed);
  614. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  615. ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
  616. ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
  617. ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
  618. ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
  619. ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 1);
  620. ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
  621. ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 1);
  622. ASSERT_EQ(UINT, keyboard_history[3][KC_V], 0);
  623. ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 1);
  624. ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
  625. ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 1);
  626. ASSERT_EQ(UINT, keyboard_history[5][KC_V], 0);
  627. ASSERT_EQ(UINT, keyboard_history[6][KC_LALT], 1);
  628. ASSERT_EQ(UINT, keyboard_history[6][KC_V], 0);
  629. ASSERT_EQ(UINT, keyboard_history[7][KC_LALT], 1);
  630. ASSERT_EQ(UINT, keyboard_history[7][KC_V], 0);
  631. ASSERT_EQ(UINT, keyboard_history[8][KC_LALT], 0);
  632. ASSERT_EQ(UINT, keyboard_history[8][KC_V], 0);
  633. ASSERT_EQ(UINT, keyboard_history[9][KC_LALT], 255);
  634. ASSERT_EQ(UINT, keyboard_history[9][KC_V], 255);
  635. END_TEST
  636. TEST("key_mod_hold_slow_typist")
  637. process_record_user(BOT4, &pressed);
  638. pause_ms(CHORD_TIMEOUT + 1);
  639. pause_ms(1000);
  640. process_record_user(TOP1, &pressed);
  641. pause_ms(1000);
  642. process_record_user(TOP1, &depressed);
  643. pause_ms(1000);
  644. process_record_user(TOP1, &pressed);
  645. pause_ms(1000);
  646. process_record_user(TOP1, &depressed);
  647. pause_ms(1000);
  648. process_record_user(TOP1, &pressed);
  649. pause_ms(1000);
  650. process_record_user(TOP1, &depressed);
  651. pause_ms(1000);
  652. process_record_user(BOT4, &depressed);
  653. ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
  654. ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
  655. ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
  656. ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
  657. ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
  658. ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
  659. ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 0);
  660. ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 1);
  661. ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
  662. ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 1);
  663. ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 1);
  664. ASSERT_EQ(UINT, keyboard_history[3][KC_V], 0);
  665. ASSERT_EQ(UINT, keyboard_history[3][KC_Q], 0);
  666. ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 1);
  667. ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
  668. ASSERT_EQ(UINT, keyboard_history[4][KC_Q], 1);
  669. ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 1);
  670. ASSERT_EQ(UINT, keyboard_history[5][KC_V], 0);
  671. ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 0);
  672. ASSERT_EQ(UINT, keyboard_history[6][KC_LALT], 1);
  673. ASSERT_EQ(UINT, keyboard_history[6][KC_V], 0);
  674. ASSERT_EQ(UINT, keyboard_history[6][KC_Q], 1);
  675. ASSERT_EQ(UINT, keyboard_history[7][KC_LALT], 1);
  676. ASSERT_EQ(UINT, keyboard_history[7][KC_V], 0);
  677. ASSERT_EQ(UINT, keyboard_history[7][KC_Q], 0);
  678. ASSERT_EQ(UINT, keyboard_history[8][KC_LALT], 0);
  679. ASSERT_EQ(UINT, keyboard_history[8][KC_V], 0);
  680. ASSERT_EQ(UINT, keyboard_history[8][KC_Q], 0);
  681. ASSERT_EQ(UINT, keyboard_history[9][KC_LALT], 255);
  682. ASSERT_EQ(UINT, keyboard_history[9][KC_V], 255);
  683. ASSERT_EQ(UINT, keyboard_history[9][KC_Q], 255);
  684. END_TEST
  685. // LEADER
  686. TEST("leader_triggers_global")
  687. uint8_t state = ACTIVATED;
  688. struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, leader};
  689. chord.function(&chord);
  690. ASSERT_EQ(UINT, in_leader_mode, 1);
  691. END_TEST
  692. TEST("leader_no_follow")
  693. uint8_t state = ACTIVATED;
  694. struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, leader};
  695. chord.function(&chord);
  696. ASSERT_EQ(UINT, in_leader_mode, 1);
  697. pause_ms(1000);
  698. ASSERT_EQ(UINT, in_leader_mode, 0);
  699. ASSERT_EQ(UINT, keyboard_history[1][KC_O], 255);
  700. END_TEST
  701. TEST("leader_wrong_follow")
  702. process_record_user(TOP2, &pressed);
  703. process_record_user(TOP3, &pressed);
  704. process_record_user(BOT2, &pressed);
  705. process_record_user(BOT3, &pressed);
  706. pause_ms(1);
  707. process_record_user(TOP2, &depressed);
  708. process_record_user(TOP3, &depressed);
  709. process_record_user(BOT2, &depressed);
  710. process_record_user(BOT3, &depressed);
  711. ASSERT_EQ(UINT, in_leader_mode, 1);
  712. pause_ms(1);
  713. process_record_user(TOP1, &pressed);
  714. pause_ms(1);
  715. process_record_user(TOP1, &depressed);
  716. pause_ms(1);
  717. process_record_user(TOP2, &pressed);
  718. pause_ms(1);
  719. process_record_user(TOP2, &depressed);
  720. pause_ms(LEADER_TIMEOUT);
  721. pause_ms(1);
  722. ASSERT_EQ(UINT, in_leader_mode, 0);
  723. ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 255);
  724. END_TEST
  725. TEST("leader_correct_follow")
  726. process_record_user(TOP2, &pressed);
  727. process_record_user(TOP3, &pressed);
  728. process_record_user(BOT2, &pressed);
  729. process_record_user(BOT3, &pressed);
  730. pause_ms(1);
  731. process_record_user(TOP2, &depressed);
  732. process_record_user(TOP3, &depressed);
  733. process_record_user(BOT2, &depressed);
  734. process_record_user(BOT3, &depressed);
  735. ASSERT_EQ(UINT, in_leader_mode, 1);
  736. pause_ms(1);
  737. process_record_user(TOP0, &pressed);
  738. pause_ms(1);
  739. process_record_user(TOP0, &depressed);
  740. pause_ms(1);
  741. process_record_user(TOP9, &pressed);
  742. pause_ms(1);
  743. process_record_user(TOP9, &depressed);
  744. pause_ms(LEADER_TIMEOUT);
  745. ASSERT_EQ(UINT, in_leader_mode, 1);
  746. pause_ms(1);
  747. ASSERT_EQ(UINT, in_leader_mode, 0);
  748. ASSERT_EQ(UINT, keyboard_history[1][KC_O], 0);
  749. ASSERT_EQ(UINT, keyboard_history[1][KC_P], 0);
  750. ASSERT_EQ(UINT, keyboard_history[1][KC_A], 0);
  751. ASSERT_EQ(UINT, keyboard_history[1][KC_S], 1);
  752. ASSERT_EQ(UINT, keyboard_history[2][KC_O], 0);
  753. ASSERT_EQ(UINT, keyboard_history[2][KC_P], 0);
  754. ASSERT_EQ(UINT, keyboard_history[2][KC_A], 0);
  755. ASSERT_EQ(UINT, keyboard_history[2][KC_S], 0);
  756. ASSERT_EQ(UINT, keyboard_history[3][KC_O], 255);
  757. ASSERT_EQ(UINT, keyboard_history[3][KC_P], 255);
  758. ASSERT_EQ(UINT, keyboard_history[3][KC_A], 255);
  759. ASSERT_EQ(UINT, keyboard_history[3][KC_S], 255);
  760. ASSERT_EQ(UINT, keyboard_history[4][KC_O], 255);
  761. ASSERT_EQ(UINT, keyboard_history[4][KC_P], 255);
  762. ASSERT_EQ(UINT, keyboard_history[4][KC_A], 255);
  763. ASSERT_EQ(UINT, keyboard_history[4][KC_S], 255);
  764. ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 255);
  765. END_TEST
  766. // DYNAMIC MACRO
  767. TEST("dynamic_macro_record_mode")
  768. current_pseudolayer = NUM;
  769. // record
  770. ASSERT_EQ(UINT, dynamic_macro_mode, 0);
  771. process_record_user(BOT7, &pressed);
  772. process_record_user(BOT7, &depressed);
  773. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  774. pause_ms(1000);
  775. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  776. END_TEST
  777. TEST("dynamic_macro_record_mode_off")
  778. current_pseudolayer = NUM;
  779. process_record_user(BOT7, &pressed);
  780. process_record_user(BOT7, &depressed);
  781. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  782. process_record_user(BOT9, &pressed);
  783. process_record_user(BOT9, &depressed);
  784. ASSERT_EQ(UINT, dynamic_macro_mode, 0);
  785. END_TEST
  786. TEST("dynamic_macro_record_one")
  787. current_pseudolayer = NUM;
  788. process_record_user(BOT7, &pressed);
  789. process_record_user(BOT7, &depressed);
  790. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  791. process_record_user(TOP1, &pressed);
  792. process_record_user(TOP1, &depressed);
  793. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
  794. process_record_user(BOT9, &pressed);
  795. process_record_user(BOT9, &depressed);
  796. pause_ms(1000);
  797. process_record_user(BOT0, &pressed);
  798. process_record_user(BOT0, &depressed);
  799. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  800. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
  801. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 255);
  802. pause_ms(1000);
  803. process_record_user(BOT0, &pressed);
  804. process_record_user(BOT0, &depressed);
  805. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
  806. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  807. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
  808. END_TEST
  809. TEST("dynamic_macro_record_two")
  810. current_pseudolayer = NUM;
  811. process_record_user(BOT7, &pressed);
  812. process_record_user(BOT7, &depressed);
  813. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  814. process_record_user(TOP1, &pressed);
  815. process_record_user(TOP1, &depressed);
  816. process_record_user(TOP2, &pressed);
  817. process_record_user(TOP2, &depressed);
  818. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
  819. process_record_user(BOT9, &pressed);
  820. process_record_user(BOT9, &depressed);
  821. pause_ms(1000);
  822. process_record_user(BOT0, &pressed);
  823. process_record_user(BOT0, &depressed);
  824. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  825. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 1);
  826. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 0);
  827. ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
  828. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
  829. END_TEST
  830. TEST("dynamic_macro_record_two_parts")
  831. current_pseudolayer = NUM;
  832. process_record_user(BOT7, &pressed);
  833. process_record_user(BOT7, &depressed);
  834. ASSERT_EQ(UINT, dynamic_macro_mode, 1);
  835. process_record_user(TOP1, &pressed);
  836. process_record_user(TOP1, &depressed);
  837. process_record_user(TOP2, &pressed);
  838. process_record_user(TOP2, &depressed);
  839. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
  840. process_record_user(BOT8, &pressed);
  841. process_record_user(BOT8, &depressed);
  842. process_record_user(TOP3, &pressed);
  843. process_record_user(TOP3, &depressed);
  844. process_record_user(BOT9, &pressed);
  845. process_record_user(BOT9, &depressed);
  846. pause_ms(1000);
  847. process_record_user(BOT0, &pressed);
  848. process_record_user(BOT0, &depressed);
  849. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  850. ASSERT_EQ(UINT, keyboard_history[1][KC_2], 0);
  851. ASSERT_EQ(UINT, keyboard_history[1][KC_3], 0);
  852. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 1);
  853. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 1);
  854. ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
  855. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 0);
  856. ASSERT_EQ(UINT, keyboard_history[3][KC_2], 1);
  857. ASSERT_EQ(UINT, keyboard_history[3][KC_3], 0);
  858. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  859. ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
  860. ASSERT_EQ(UINT, keyboard_history[4][KC_3], 0);
  861. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 0);
  862. ASSERT_EQ(UINT, keyboard_history[5][KC_2], 0);
  863. ASSERT_EQ(UINT, keyboard_history[5][KC_3], 1);
  864. ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
  865. ASSERT_EQ(UINT, keyboard_history[6][KC_2], 0);
  866. ASSERT_EQ(UINT, keyboard_history[6][KC_3], 0);
  867. ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
  868. END_TEST
  869. // dance + M()
  870. TEST("dance_tap")
  871. process_record_user(BOT0, &pressed);
  872. process_record_user(BOT0, &depressed);
  873. pause_ms(1000);
  874. ASSERT_EQ(UINT, keyboard_history[1][KC_9], 1);
  875. ASSERT_EQ(UINT, keyboard_history[1][KC_0], 0);
  876. ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
  877. ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
  878. ASSERT_EQ(UINT, keyboard_history[3][KC_9], 255);
  879. END_TEST
  880. TEST("dance_hold")
  881. process_record_user(BOT0, &pressed);
  882. pause_ms(1000);
  883. ASSERT_EQ(UINT, keyboard_history[1][KC_9], 1);
  884. process_record_user(BOT0, &depressed);
  885. ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
  886. END_TEST
  887. TEST("dance_tap_tap")
  888. process_record_user(BOT0, &pressed);
  889. process_record_user(BOT0, &depressed);
  890. process_record_user(BOT0, &pressed);
  891. process_record_user(BOT0, &depressed);
  892. pause_ms(1000);
  893. ASSERT_EQ(UINT, keyboard_history[1][KC_9], 0);
  894. ASSERT_EQ(UINT, keyboard_history[1][KC_0], 1);
  895. ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
  896. ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
  897. ASSERT_EQ(UINT, keyboard_history[3][KC_9], 255);
  898. END_TEST
  899. TEST("dance_tap_hold")
  900. process_record_user(BOT0, &pressed);
  901. process_record_user(BOT0, &depressed);
  902. pause_ms(1);
  903. process_record_user(BOT0, &pressed);
  904. pause_ms(1000);
  905. ASSERT_EQ(UINT, keyboard_history[1][KC_0], 1);
  906. process_record_user(BOT0, &depressed);
  907. ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
  908. END_TEST
  909. // MK
  910. TEST("multiple_keys")
  911. current_pseudolayer = NUM;
  912. process_record_user(BOT1, &pressed);
  913. process_record_user(BOT1, &depressed);
  914. ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
  915. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
  916. ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 1);
  917. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
  918. ASSERT_EQ(UINT, keyboard_history[3][KC_LCTL], 0);
  919. ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 1);
  920. ASSERT_EQ(UINT, keyboard_history[4][KC_LCTL], 0);
  921. ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
  922. ASSERT_EQ(UINT, keyboard_history[5][KC_LCTL], 255);
  923. END_TEST
  924. TEST("multiple_keys_interleaved")
  925. current_pseudolayer = NUM;
  926. process_record_user(BOT1, &pressed);
  927. pause_ms(CHORD_TIMEOUT+1);
  928. process_record_user(TOP1, &pressed);
  929. process_record_user(TOP1, &depressed);
  930. process_record_user(TOP1, &pressed);
  931. process_record_user(TOP1, &depressed);
  932. process_record_user(TOP1, &pressed);
  933. process_record_user(TOP1, &depressed);
  934. process_record_user(BOT1, &depressed);
  935. ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
  936. ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
  937. ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 1);
  938. ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
  939. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
  940. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  941. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
  942. ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
  943. ASSERT_EQ(UINT, keyboard_history[7][KC_1], 1);
  944. ASSERT_EQ(UINT, keyboard_history[8][KC_1], 0);
  945. ASSERT_EQ(UINT, keyboard_history[9][KC_LCTL], 0);
  946. ASSERT_EQ(UINT, keyboard_history[9][KC_LSFT], 1);
  947. ASSERT_EQ(UINT, keyboard_history[10][KC_LCTL], 0);
  948. ASSERT_EQ(UINT, keyboard_history[10][KC_LSFT], 0);
  949. ASSERT_EQ(UINT, keyboard_history[11][KC_LCTL], 255);
  950. END_TEST
  951. // D
  952. TEST("dance_one")
  953. current_pseudolayer = NUM;
  954. process_record_user(BOT3, &pressed);
  955. process_record_user(BOT3, &depressed);
  956. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  957. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  958. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
  959. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 255);
  960. process_record_user(BOT3, &pressed);
  961. process_record_user(BOT3, &depressed);
  962. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  963. ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
  964. ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
  965. ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
  966. ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
  967. ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
  968. END_TEST
  969. TEST("dance_two")
  970. current_pseudolayer = NUM;
  971. process_record_user(BOT3, &pressed);
  972. process_record_user(BOT3, &depressed);
  973. process_record_user(BOT3, &pressed);
  974. process_record_user(BOT3, &depressed);
  975. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  976. ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
  977. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
  978. ASSERT_EQ(UINT, keyboard_history[3][KC_2], 255);
  979. process_record_user(BOT3, &pressed);
  980. process_record_user(BOT3, &depressed);
  981. process_record_user(BOT3, &pressed);
  982. process_record_user(BOT3, &depressed);
  983. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  984. ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
  985. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
  986. ASSERT_EQ(UINT, keyboard_history[3][KC_2], 1);
  987. ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
  988. ASSERT_EQ(UINT, keyboard_history[5][KC_2], 255);
  989. END_TEST
  990. TEST("dance_three")
  991. current_pseudolayer = NUM;
  992. process_record_user(BOT3, &pressed);
  993. process_record_user(BOT3, &depressed);
  994. process_record_user(BOT3, &pressed);
  995. process_record_user(BOT3, &depressed);
  996. process_record_user(BOT3, &pressed);
  997. process_record_user(BOT3, &depressed);
  998. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  999. ASSERT_EQ(UINT, keyboard_history[1][KC_3], 1);
  1000. ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
  1001. ASSERT_EQ(UINT, keyboard_history[3][KC_3], 255);
  1002. process_record_user(BOT3, &pressed);
  1003. process_record_user(BOT3, &depressed);
  1004. process_record_user(BOT3, &pressed);
  1005. process_record_user(BOT3, &depressed);
  1006. process_record_user(BOT3, &pressed);
  1007. process_record_user(BOT3, &depressed);
  1008. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  1009. ASSERT_EQ(UINT, keyboard_history[1][KC_3], 1);
  1010. ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
  1011. ASSERT_EQ(UINT, keyboard_history[3][KC_3], 1);
  1012. ASSERT_EQ(UINT, keyboard_history[4][KC_3], 0);
  1013. ASSERT_EQ(UINT, keyboard_history[5][KC_3], 255);
  1014. END_TEST
  1015. TEST("dance_two_held")
  1016. current_pseudolayer = NUM;
  1017. process_record_user(BOT3, &pressed);
  1018. process_record_user(BOT3, &depressed);
  1019. process_record_user(BOT3, &pressed);
  1020. pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
  1021. ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
  1022. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 255);
  1023. process_record_user(BOT3, &depressed);
  1024. ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
  1025. ASSERT_EQ(UINT, keyboard_history[3][KC_2], 255);
  1026. END_TEST
  1027. // These two are leaving the chording engine, they kinda have to be tested manually
  1028. // TO
  1029. // RESET
  1030. END