logo

qmk_firmware

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

test_combo.cpp (4336B)

    

  1. // Copyright 2024 @Filios92
  2. // SPDX-License-Identifier: GPL-2.0-or-later
  4. #include "keyboard_report_util.hpp"
  5. #include "keycode.h"
  6. #include "test_common.h"
  7. #include "test_common.hpp"
  8. #include "test_driver.hpp"
  9. #include "test_fixture.hpp"
  10. #include "test_keymap_key.hpp"
  12. using testing::_;
  13. using testing::InSequence;
  15. class ComboRepress : public TestFixture {};
  17. TEST_F(ComboRepress, combo_repress_tapped) {
  18.     TestDriver driver;
  19.     KeymapKey  key_f(0, 0, 0, KC_F);
  20.     KeymapKey  key_g(0, 0, 1, KC_G);
  21.     set_keymap({key_f, key_g});
  23.     EXPECT_REPORT(driver, (KC_LEFT_ALT)).Times(2);
  24.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT));
  25.     EXPECT_EMPTY_REPORT(driver);
  26.     tap_combo({key_f, key_g}, 20);
  27.     VERIFY_AND_CLEAR(driver);
  28. }
  30. TEST_F(ComboRepress, combo_repress_held_released_one_key_and_repressed) {
  31.     TestDriver driver;
  32.     KeymapKey  key_f(0, 0, 0, KC_F);
  33.     KeymapKey  key_g(0, 0, 1, KC_G);
  34.     KeymapKey  key_h(0, 0, 2, KC_H);
  35.     KeymapKey  key_j(0, 0, 3, KC_J);
  36.     set_keymap({key_f, key_g, key_h, key_j});
  38.     /* Press combo F+G */
  39.     EXPECT_REPORT(driver, (KC_LEFT_ALT)).Times(2);
  40.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT));
  41.     key_f.press();
  42.     run_one_scan_loop();
  43.     key_g.press();
  44.     run_one_scan_loop();
  45.     idle_for(COMBO_TERM + 1);
  46.     VERIFY_AND_CLEAR(driver);
  48.     /* Release G */
  49.     EXPECT_NO_REPORT(driver);
  50.     key_g.release();
  51.     idle_for(80);
  52.     VERIFY_AND_CLEAR(driver);
  54.     /* Tap G */
  55.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT));
  56.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  57.     tap_key(key_g, TAPPING_TERM + 1);
  58.     VERIFY_AND_CLEAR(driver);
  60.     /* Tap G, but hold for longer */
  61.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT));
  62.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  63.     tap_key(key_g, TAPPING_TERM * 2);
  64.     VERIFY_AND_CLEAR(driver);
  66.     idle_for(500);
  68.     /* Tap other combo while holding F */
  69.     EXPECT_REPORT(driver, (KC_ESCAPE, KC_LEFT_ALT));
  70.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  71.     tap_combo({key_h, key_j}, TAPPING_TERM + 1);
  72.     VERIFY_AND_CLEAR(driver);
  74.     /* G press and hold */
  75.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT));
  76.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  77.     key_g.press();
  78.     run_one_scan_loop();
  79.     VERIFY_AND_CLEAR(driver);
  81.     /* F release and tap */
  82.     EXPECT_REPORT(driver, (KC_LEFT_ALT, KC_LEFT_SHIFT)).Times(2);
  83.     EXPECT_REPORT(driver, (KC_TAB, KC_LEFT_ALT, KC_LEFT_SHIFT));
  84.     EXPECT_REPORT(driver, (KC_LEFT_ALT));
  85.     key_f.release();
  86.     run_one_scan_loop();
  87.     tap_key(key_f);
  88.     VERIFY_AND_CLEAR(driver);
  90.     /* Release G */
  91.     EXPECT_EMPTY_REPORT(driver);
  92.     key_g.release();
  93.     run_one_scan_loop();
  94.     VERIFY_AND_CLEAR(driver);
  95. }
  97. TEST_F(ComboRepress, combo_repress_normal_combo) {
  98.     TestDriver driver;
  99.     KeymapKey  key_f(0, 0, 0, KC_F);
  100.     KeymapKey  key_g(0, 0, 1, KC_G);
  101.     KeymapKey  key_h(0, 0, 2, KC_H);
  102.     KeymapKey  key_j(0, 0, 3, KC_J);
  103.     set_keymap({key_f, key_g, key_h, key_j});
  105.     /* Press combo H+J */
  106.     EXPECT_REPORT(driver, (KC_ESCAPE));
  107.     key_h.press();
  108.     run_one_scan_loop();
  109.     key_j.press();
  110.     run_one_scan_loop();
  111.     idle_for(COMBO_TERM + 10);
  112.     VERIFY_AND_CLEAR(driver);
  114.     /* Release H */
  115.     EXPECT_NO_REPORT(driver);
  116.     key_h.release();
  117.     idle_for(80);
  118.     VERIFY_AND_CLEAR(driver);
  120.     /* Tap H */
  121.     EXPECT_REPORT(driver, (KC_H, KC_ESCAPE));
  122.     EXPECT_REPORT(driver, (KC_ESCAPE));
  123.     tap_key(key_h);
  124.     VERIFY_AND_CLEAR(driver);
  126.     /* Tap H, but hold for longer */
  127.     EXPECT_REPORT(driver, (KC_H, KC_ESCAPE));
  128.     EXPECT_REPORT(driver, (KC_ESCAPE));
  129.     tap_key(key_h, TAPPING_TERM + 1);
  130.     VERIFY_AND_CLEAR(driver);
  132.     idle_for(500);
  134.     /* Tap other combo while holding K */
  135.     EXPECT_REPORT(driver, (KC_ESCAPE, KC_LEFT_ALT)).Times(2);
  136.     EXPECT_REPORT(driver, (KC_ESCAPE, KC_TAB, KC_LEFT_ALT));
  137.     EXPECT_REPORT(driver, (KC_ESCAPE));
  138.     tap_combo({key_f, key_g}, TAPPING_TERM + 1);
  139.     VERIFY_AND_CLEAR(driver);
  141.     /* H press and hold */
  142.     EXPECT_REPORT(driver, (KC_H, KC_ESCAPE));
  143.     key_h.press();
  144.     run_one_scan_loop();
  145.     VERIFY_AND_CLEAR(driver);
  147.     /* J release and tap */
  148.     EXPECT_REPORT(driver, (KC_H));
  149.     key_j.release();
  150.     run_one_scan_loop();
  151.     VERIFY_AND_CLEAR(driver);
  153.     /* Release G */
  154.     EXPECT_EMPTY_REPORT(driver);
  155.     key_h.release();
  156.     run_one_scan_loop();
  157.     VERIFY_AND_CLEAR(driver);
  158. }