aboutsummaryrefslogtreecommitdiff
path: root/users/dennytom/chording_engine/tests
diff options
context:
space:
mode:
Diffstat (limited to 'users/dennytom/chording_engine/tests')
-rw-r--r--users/dennytom/chording_engine/tests/minunit.h288
-rw-r--r--users/dennytom/chording_engine/tests/test.c1259
-rw-r--r--users/dennytom/chording_engine/tests/test_full.sh11
-rw-r--r--users/dennytom/chording_engine/tests/test_keymap_def.json145
-rw-r--r--users/dennytom/chording_engine/tests/test_quick.sh6
5 files changed, 1709 insertions, 0 deletions
diff --git a/users/dennytom/chording_engine/tests/minunit.h b/users/dennytom/chording_engine/tests/minunit.h
new file mode 100644
index 000000000..ed71b6253
--- /dev/null
+++ b/users/dennytom/chording_engine/tests/minunit.h
@@ -0,0 +1,288 @@
1#define mu_assert(message, test) \
2 do { \
3 if (!(test)) { \
4 return message; \
5 } \
6 } while (0)
7
8#define RED "\033[0;31m"
9#define GREEN "\033[0;32m"
10#define NC "\033[0m"
11
12enum ASSERT_TYPES {
13 UINT,
14 INT
15};
16
17#define BUFF_SIZE 1024
18char buffer[BUFF_SIZE];
19
20#define ASSERT_EQ(type, actual, expected) \
21 do { \
22 if (actual != expected) { \
23 switch (type) { \
24 case UINT: \
25 snprintf(buffer, BUFF_SIZE, "\nline %d\nvar %s\nactual = %u\nexpected = %u\n", __LINE__, #actual, actual, expected); \
26 break; \
27 case INT: \
28 snprintf(buffer, BUFF_SIZE, "\nline %d\nvar %s\nactual = %d\nexpected = %d\n", __LINE__, #actual, actual, expected); \
29 break; \
30 default: \
31 snprintf(buffer, BUFF_SIZE, "\nline %d\nunsupported ASSERT_EQ type\n", __LINE__); \
32 break; \
33 } \
34 printf("%s\n", buffer); \
35 passed = false; \
36 all_passed = false; \
37 } \
38 } while (0)
39
40#include <stdio.h>
41#include <stdint.h>
42#include <stddef.h>
43#include <stdbool.h>
44#include <string.h>
45
46#define MATRIX_ROWS 2
47#define MATRIX_COLS 10
48#define LAYOUT_test( \
49 k09, k08, k07, k06, k05, k04, k03, k02, k01, k00, \
50 k19, k18, k17, k16, k15, k14, k13, k12, k11, k10 \
51) { \
52 { k00, k01, k02, k03, k04, k05, k06, k07, k08, k09}, \
53 { k10, k11, k12, k13, k14, k15, k16, k17, k18, k19}, \
54}
55
56#define PROGMEM
57#define memcpy_P memcpy
58const struct Chord* pgm_read_word(const struct Chord* const* chord) {return *chord;}
59
60typedef struct {
61 uint8_t col;
62 uint8_t row;
63} keypos_t;
64
65typedef struct {
66 keypos_t key;
67 bool pressed;
68 uint16_t time;
69} keyevent_t;
70
71typedef struct {
72 bool interrupted :1;
73 bool reserved2 :1;
74 bool reserved1 :1;
75 bool reserved0 :1;
76 uint8_t count :4;
77} tap_t;
78
79typedef struct {
80 keyevent_t event;
81 tap_t tap;
82} keyrecord_t;
83
84keyrecord_t pressed = {{{0,0},true,0}, {0,0,0,0,0}};
85keyrecord_t depressed = {{{0,0},false,0}, {0,0,0,0,0}};
86
87enum keycodes {
88 KC_NO,
89 KC_TILDE,
90 KC_GRAVE,
91 KC_EXCLAIM,
92 KC_1,
93 KC_AT,
94 KC_2,
95 KC_HASH,
96 KC_3,
97 KC_DOLLAR,
98 KC_4,
99 KC_PERCENT,
100 KC_5,
101 KC_CIRCUMFLEX,
102 KC_6,
103 KC_AMPERSAND,
104 KC_7,
105 KC_ASTERISK,
106 KC_8,
107 KC_LEFT_PAREN,
108 KC_9,
109 KC_RIGHT_PAREN,
110 KC_0,
111 KC_UNDERSCORE,
112 KC_MINUS,
113 KC_PLUS,
114 KC_EQUAL,
115 KC_LEFT_CURLY_BRACE,
116 KC_LBRACKET,
117 KC_RIGHT_CURLY_BRACE,
118 KC_RBRACKET,
119 KC_PIPE,
120 KC_BSLASH,
121 KC_COLON,
122 KC_SCOLON,
123 KC_DOUBLE_QUOTE,
124 KC_QUOTE,
125 KC_LEFT_ANGLE_BRACKET,
126 KC_COMMA,
127 KC_RIGHT_ANGLE_BRACKET,
128 KC_DOT,
129 KC_QUESTION,
130 KC_SLASH,
131 KC_Q,
132 KC_W,
133 KC_E,
134 KC_R,
135 KC_T,
136 KC_Y,
137 KC_U,
138 KC_I,
139 KC_O,
140 KC_P,
141 KC_A,
142 KC_S,
143 KC_D,
144 KC_F,
145 KC_G,
146 KC_H,
147 KC_J,
148 KC_K,
149 KC_L,
150 KC_Z,
151 KC_X,
152 KC_C,
153 KC_V,
154 KC_B,
155 KC_N,
156 KC_M,
157 KC_ESC,
158 KC_LSFT,
159 KC_LCTL,
160 KC_LGUI,
161 KC_LALT,
162 KC_RALT,
163 KC_RCTL,
164 KC_RGUI,
165 KC_RSFT,
166 KC_TAB,
167 KC_DEL,
168 KC_INS,
169 KC_BSPC,
170 KC_ENTER,
171 KC_SPACE,
172 KC_F1,
173 KC_F2,
174 KC_F3,
175 KC_F4,
176 KC_F5,
177 KC_F6,
178 KC_F7,
179 KC_F8,
180 KC_F9,
181 KC_F10,
182 KC_F11,
183 KC_F12,
184 KC_LEFT,
185 KC_DOWN,
186 KC_UP,
187 KC_RIGHT,
188
189 SAFE_RANGE
190};
191
192#define HISTORY 20
193
194int16_t current_time;
195uint8_t keyboard_history[HISTORY][SAFE_RANGE-1];
196int16_t time_history[HISTORY];
197uint8_t history_index;
198
199void register_code(int16_t keycode) {
200 history_index++;
201 for (int j = 0; j < SAFE_RANGE-1; j++) {
202 keyboard_history[history_index][j] = keyboard_history[history_index-1][j];
203 }
204 keyboard_history[history_index][keycode] = 1;
205 time_history[history_index] = current_time;
206};
207void unregister_code(int16_t keycode) {
208 history_index++;
209 for (int j = 0; j < SAFE_RANGE-1; j++) {
210 keyboard_history[history_index][j] = keyboard_history[history_index-1][j];
211 }
212 keyboard_history[history_index][keycode] = 0;
213 time_history[history_index] = current_time;
214};
215void send_keyboard_report(void) { /*still don't know what this does*/ };
216void matrix_scan_user (void);
217void wait_ms(uint16_t ms) {
218 current_time += ms;
219};
220uint16_t timer_read(void) {
221 uint16_t result = current_time;
222 return result;
223};
224uint16_t timer_elapsed(uint16_t timer) {
225 uint16_t result = current_time - timer;
226 return result;
227};
228void layer_move(int16_t layer) { /*ignoring for now*/ };
229void clear_keyboard(void) {
230 history_index++;
231 for (int j = 0; j < SAFE_RANGE-1; j++) {
232 keyboard_history[history_index][j] = 0;
233 }
234 time_history[history_index] = current_time;
235};
236void reset_keyboard(void) { /*ignoring for now*/ };
237
238void pause_ms(uint16_t ms) {
239 for (int i = 0; i < ms; i++) {
240 current_time++;
241 matrix_scan_user();
242 }
243};
244
245#define TEST(name) \
246 do { \
247 printf("%s\n", name); \
248 passed = true; \
249 do { \
250 uint8_t clear_state = ACTIVATED; \
251 struct Chord clear_chord PROGMEM = {0, QWERTY, &clear_state, NULL, 0, 0, clear}; \
252 clear_chord.function(&clear_chord); \
253 } while (0); \
254 current_time = 0; \
255 history_index = 0; \
256 for (int j = 0; j < SAFE_RANGE-1; j++) { \
257 keyboard_history[0][j] = 0; \
258 } \
259 time_history[0] = 0; \
260 for (int i = 1; i < HISTORY; i++) { \
261 for (int j = 0; j < SAFE_RANGE-1; j++) { \
262 keyboard_history[i][j] = -1; \
263 } \
264 time_history[i] = -1; \
265 }
266
267#define END_TEST \
268 if (passed) { \
269 printf(GREEN"PASSED"NC"\n"); \
270 } else { \
271 printf(RED"FAILED"NC"\n"); \
272 } \
273 } while(0);
274
275#define MAIN \
276int main(int argc, char **argv) { \
277 bool passed = true; \
278 bool all_passed = true;
279
280#define END \
281 printf("\n"); \
282 if (all_passed) { \
283 printf(GREEN"ALL TESTS PASSED"NC"\n"); \
284 } else { \
285 printf(RED"TESTS FAILED"NC"\n"); \
286 } \
287 return 1 - all_passed; \
288} \ No newline at end of file
diff --git a/users/dennytom/chording_engine/tests/test.c b/users/dennytom/chording_engine/tests/test.c
new file mode 100644
index 000000000..0cc172f0a
--- /dev/null
+++ b/users/dennytom/chording_engine/tests/test.c
@@ -0,0 +1,1259 @@
1#include "minunit.h"
2#include "test_keymap.c"
3
4MAIN
5
6// CLEAR_KB
7TEST("clear")
8 for (int i = 0; i < NUMBER_OF_CHORDS; i++) {
9 struct Chord* chord_ptr = (struct Chord*) pgm_read_word (&list_of_chords[i]);
10 struct Chord chord_storage;
11 memcpy_P(&chord_storage, chord_ptr, sizeof(struct Chord));
12 struct Chord* chord = &chord_storage;
13
14 *chord->state = READY;
15
16 if (chord->counter) {
17 *chord->counter = 1;
18 }
19 }
20
21 history_index++;
22 for (int j = 0; j < SAFE_RANGE-1; j++) {
23 keyboard_history[history_index][j] = 1;
24 }
25
26 current_pseudolayer = 5;
27 lock_next = true;
28 autoshift_mode = false;
29 command_mode = 1;
30 in_leader_mode = true;
31 dynamic_macro_mode = true;
32 a_key_went_through = true;
33
34 for (int i = 0; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
35 dynamic_macro_buffer[i] = 1;
36 }
37
38 uint8_t clear_state = ACTIVATED;
39 struct Chord clear_chord PROGMEM = {0, QWERTY, &clear_state, NULL, 0, 0, clear};
40 clear_chord.function(&clear_chord);
41
42 for (int i = 0; i < NUMBER_OF_CHORDS; i++) {
43 struct Chord* chord_ptr = (struct Chord*) pgm_read_word (&list_of_chords[i]);
44 struct Chord chord_storage;
45 memcpy_P(&chord_storage, chord_ptr, sizeof(struct Chord));
46 struct Chord* chord = &chord_storage;
47
48 ASSERT_EQ(UINT, *chord->state, IDLE);
49
50 if (chord->counter) {
51 ASSERT_EQ(UINT, *chord->counter, 0);
52 }
53 }
54
55 for (int j = 0; j < SAFE_RANGE-1; j++) {
56 ASSERT_EQ(UINT, keyboard_history[history_index][j], 0);
57 }
58
59 ASSERT_EQ(UINT, current_pseudolayer, 1);
60 ASSERT_EQ(UINT, lock_next, false);
61 ASSERT_EQ(UINT, autoshift_mode, true);
62 ASSERT_EQ(UINT, command_mode, 0);
63 ASSERT_EQ(UINT, in_leader_mode, false);
64 ASSERT_EQ(UINT, leader_ind, 0);
65 ASSERT_EQ(UINT, dynamic_macro_mode, false);
66 ASSERT_EQ(UINT, a_key_went_through, false);
67
68 for (int i = 0; i < DYNAMIC_MACRO_MAX_LENGTH; i++) {
69 ASSERT_EQ(UINT, dynamic_macro_buffer[i], 0);
70 }
71END_TEST
72
73TEST("pause_ms")
74 pause_ms(500);
75 ASSERT_EQ(UINT, current_time, 500);
76END_TEST
77
78// KC
79TEST("single_dance_held_states")
80 ASSERT_EQ(UINT, state_1, IDLE);
81 process_record_user(TOP1, &pressed);
82 pause_ms(CHORD_TIMEOUT);
83 ASSERT_EQ(UINT, state_1, IDLE);
84 pause_ms(1);
85 ASSERT_EQ(UINT, state_1, ACTIVATED);
86 pause_ms(DANCE_TIMEOUT);
87 ASSERT_EQ(UINT, state_1, ACTIVATED);
88 pause_ms(1);
89 ASSERT_EQ(UINT, state_1, PRESS_FROM_ACTIVE);
90 pause_ms(DANCE_TIMEOUT);
91 ASSERT_EQ(UINT, state_1, PRESS_FROM_ACTIVE);
92 pause_ms(1);
93 ASSERT_EQ(UINT, state_1, FINISHED_FROM_ACTIVE);
94 process_record_user(TOP1, &depressed);
95 ASSERT_EQ(UINT, state_1, IDLE);
96END_TEST
97
98TEST("single_dance_held_codes")
99 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
100 process_record_user(TOP1, &pressed);
101 pause_ms(CHORD_TIMEOUT);
102 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
103 pause_ms(1);
104 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
105 pause_ms(DANCE_TIMEOUT);
106 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
107 pause_ms(1);
108 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
109 pause_ms(DANCE_TIMEOUT);
110 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
111 pause_ms(1);
112 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
113 process_record_user(TOP1, &depressed);
114 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
115END_TEST
116
117TEST("single_dance_tapped_states")
118 ASSERT_EQ(UINT, state_1, IDLE);
119 process_record_user(TOP1, &pressed);
120 pause_ms(CHORD_TIMEOUT);
121 ASSERT_EQ(UINT, state_1, IDLE);
122 pause_ms(1);
123 ASSERT_EQ(UINT, state_1, ACTIVATED);
124 process_record_user(TOP1, &depressed);
125 ASSERT_EQ(UINT, state_1, IDLE);
126END_TEST
127
128TEST("single_dance_tapped_codes")
129 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
130 process_record_user(TOP1, &pressed);
131 pause_ms(CHORD_TIMEOUT);
132 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
133 pause_ms(1);
134 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
135 process_record_user(TOP1, &depressed);
136 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
137END_TEST
138
139// I can not actually track the states if the tap is faster than chord timeout
140
141TEST("single_dance_tapped_fast_codes")
142 ASSERT_EQ(UINT, state_0, IDLE);
143 process_record_user(TOP1, &pressed);
144 pause_ms(1);
145 process_record_user(TOP1, &depressed);
146 ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
147 ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 1);
148 ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 0);
149END_TEST
150
151TEST("subchords_are_ignored")
152 ASSERT_EQ(UINT, state_0, IDLE);
153 process_record_user(TOP1, &pressed);
154 pause_ms(1);
155 process_record_user(TOP2, &pressed);
156 pause_ms(CHORD_TIMEOUT + 1);
157 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
158 ASSERT_EQ(UINT, keyboard_history[history_index][KC_W], 0);
159 ASSERT_EQ(UINT, keyboard_history[history_index][KC_ESC], 1);
160END_TEST
161
162TEST("multiple_chords_at_once")
163 ASSERT_EQ(UINT, state_0, IDLE);
164 process_record_user(TOP1, &pressed);
165 pause_ms(1);
166 process_record_user(TOP3, &pressed);
167 pause_ms(CHORD_TIMEOUT + 1);
168 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 1);
169 ASSERT_EQ(UINT, keyboard_history[history_index][KC_E], 1);
170END_TEST
171
172// MO
173TEST("momentary_layer")
174 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
175 process_record_user(BOT7, &pressed);
176 pause_ms(1);
177 process_record_user(BOT8, &pressed);
178 pause_ms(CHORD_TIMEOUT + 1);
179 ASSERT_EQ(UINT, current_pseudolayer, NUM);
180 process_record_user(BOT7, &depressed);
181 pause_ms(1);
182 process_record_user(BOT8, &depressed);
183 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
184END_TEST
185
186TEST("momentary_layer_reset")
187 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
188 process_record_user(BOT7, &pressed);
189 pause_ms(1);
190 process_record_user(BOT8, &pressed);
191 pause_ms(CHORD_TIMEOUT + 1);
192 ASSERT_EQ(UINT, current_pseudolayer, NUM);
193 pause_ms(DANCE_TIMEOUT + 1);
194 ASSERT_EQ(UINT, current_pseudolayer, NUM);
195 process_record_user(BOT7, &depressed);
196 pause_ms(1);
197 process_record_user(BOT8, &depressed);
198 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
199END_TEST
200
201TEST("momentary_layer_alt")
202 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
203
204 process_record_user(TOP8, &pressed);
205 pause_ms(1);
206 process_record_user(TOP9, &pressed);
207 pause_ms(1);
208 process_record_user(TOP0, &pressed);
209 pause_ms(1);
210 process_record_user(BOT8, &pressed);
211 pause_ms(1);
212 process_record_user(BOT9, &pressed);
213 pause_ms(1);
214 process_record_user(BOT0, &pressed);
215 pause_ms(CHORD_TIMEOUT + 1);
216
217 ASSERT_EQ(UINT, current_pseudolayer, NUM);
218
219 process_record_user(TOP8, &depressed);
220 pause_ms(1);
221 process_record_user(TOP9, &depressed);
222 pause_ms(1);
223 process_record_user(TOP0, &depressed);
224 pause_ms(1);
225 process_record_user(BOT8, &depressed);
226 pause_ms(1);
227 process_record_user(BOT9, &depressed);
228 pause_ms(1);
229 process_record_user(BOT0, &depressed);
230
231 ASSERT_EQ(UINT, current_pseudolayer, FNC);
232END_TEST
233
234// DF
235TEST("permanent_layer")
236 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
237 process_record_user(BOT9, &pressed);
238 pause_ms(1);
239 process_record_user(BOT0, &pressed);
240 pause_ms(CHORD_TIMEOUT + 1);
241 ASSERT_EQ(UINT, current_pseudolayer, NUM);
242 process_record_user(BOT9, &depressed);
243 pause_ms(1);
244 process_record_user(BOT0, &depressed);
245 ASSERT_EQ(UINT, current_pseudolayer, NUM);
246 pause_ms(1000);
247 ASSERT_EQ(UINT, current_pseudolayer, NUM);
248END_TEST
249
250// AT
251TEST("autoshift_toggle")
252 ASSERT_EQ(UINT, autoshift_mode, 1);
253 uint8_t state = ACTIVATED;
254 struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, autoshift_toggle};
255 chord.function(&chord);
256 ASSERT_EQ(UINT, autoshift_mode, 0);
257 state = ACTIVATED;
258 chord.function(&chord);
259 ASSERT_EQ(UINT, autoshift_mode, 1);
260END_TEST
261
262// AS
263TEST("autoshift_tap")
264 process_record_user(BOT1, &pressed);
265 pause_ms(CHORD_TIMEOUT + 1);
266 process_record_user(BOT1, &depressed);
267
268 ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
269 ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
270
271 ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 1);
272 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
273
274 ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 0);
275 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 0);
276END_TEST
277
278TEST("autoshift_hold")
279 process_record_user(BOT1, &pressed);
280 pause_ms(CHORD_TIMEOUT + 1);
281 pause_ms(LONG_PRESS_MULTIPLIER * (DANCE_TIMEOUT + 1));
282 process_record_user(BOT1, &depressed);
283
284 ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
285 ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
286
287 ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 0);
288 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 1);
289
290 ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 1);
291 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
292
293 ASSERT_EQ(UINT, keyboard_history[3][KC_Z], 0);
294 ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 1);
295
296 ASSERT_EQ(UINT, keyboard_history[4][KC_Z], 0);
297 ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
298END_TEST
299
300TEST("autoshift_hold_off")
301 autoshift_mode = 0;
302 process_record_user(BOT1, &pressed);
303 pause_ms(CHORD_TIMEOUT + 1);
304 pause_ms(LONG_PRESS_MULTIPLIER * (DANCE_TIMEOUT + 1));
305 process_record_user(BOT1, &depressed);
306
307 ASSERT_EQ(UINT, keyboard_history[0][KC_Z], 0);
308 ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
309
310 ASSERT_EQ(UINT, keyboard_history[1][KC_Z], 1);
311 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
312
313 ASSERT_EQ(UINT, keyboard_history[2][KC_Z], 0);
314 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 0);
315END_TEST
316
317// LOCK
318TEST("lock")
319 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
320 process_record_user(BOT1, &pressed);
321 process_record_user(BOT2, &pressed);
322 pause_ms(CHORD_TIMEOUT + 1);
323 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
324 process_record_user(BOT1, &depressed);
325 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
326 pause_ms(1);
327 process_record_user(BOT2, &depressed);
328 pause_ms(1);
329 process_record_user(TOP1, &pressed);
330 process_record_user(TOP2, &pressed);
331 process_record_user(BOT1, &pressed);
332 process_record_user(BOT2, &pressed);
333 pause_ms(CHORD_TIMEOUT + 1);
334 process_record_user(TOP1, &depressed);
335 pause_ms(1);
336 process_record_user(TOP2, &depressed);
337 process_record_user(BOT1, &depressed);
338 process_record_user(BOT2, &depressed);
339 pause_ms(1);
340 process_record_user(BOT1, &pressed);
341 process_record_user(BOT2, &pressed);
342 pause_ms(CHORD_TIMEOUT + 1);
343 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
344 process_record_user(BOT1, &depressed);
345 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
346 pause_ms(1);
347 process_record_user(BOT2, &depressed);
348 pause_ms(1000);
349 process_record_user(BOT1, &pressed);
350 process_record_user(BOT2, &pressed);
351 pause_ms(CHORD_TIMEOUT + 1);
352 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
353 process_record_user(BOT1, &depressed);
354 pause_ms(1);
355 process_record_user(BOT2, &depressed);
356 pause_ms(1000);
357 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
358END_TEST
359
360// OSK
361TEST("one_shot_key_tap")
362 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
363 process_record_user(BOT2, &pressed);
364 process_record_user(BOT3, &pressed);
365 pause_ms(CHORD_TIMEOUT + 1);
366 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
367 process_record_user(BOT2, &depressed);
368 pause_ms(1);
369 process_record_user(BOT3, &depressed);
370 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
371 pause_ms(1000);
372 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
373
374 process_record_user(TOP1, &pressed);
375 pause_ms(CHORD_TIMEOUT + 1);
376 process_record_user(TOP1, &depressed);
377 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
378END_TEST
379
380TEST("one_shot_key_hold")
381 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
382 process_record_user(BOT2, &pressed);
383 process_record_user(BOT3, &pressed);
384 pause_ms(CHORD_TIMEOUT + 1);
385 pause_ms(DANCE_TIMEOUT + 1);
386 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
387
388 process_record_user(TOP1, &pressed);
389 pause_ms(CHORD_TIMEOUT + 1);
390 process_record_user(TOP1, &depressed);
391 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
392
393 process_record_user(BOT2, &depressed);
394 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
395END_TEST
396
397TEST("one_shot_key_retrotapping")
398 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
399 process_record_user(BOT2, &pressed);
400 process_record_user(BOT3, &pressed);
401 pause_ms(CHORD_TIMEOUT + 1);
402 pause_ms(DANCE_TIMEOUT + 1);
403 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
404
405 pause_ms(1000);
406
407 process_record_user(BOT2, &depressed);
408 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 1);
409END_TEST
410
411// OSL
412TEST("one_shot_layer_tap")
413 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
414 process_record_user(BOT6, &pressed);
415 process_record_user(BOT7, &pressed);
416 pause_ms(CHORD_TIMEOUT + 1);
417 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
418 process_record_user(BOT6, &depressed);
419 pause_ms(1);
420 process_record_user(BOT7, &depressed);
421 ASSERT_EQ(UINT, current_pseudolayer, NUM);
422 pause_ms(1000);
423 ASSERT_EQ(UINT, current_pseudolayer, NUM);
424
425 process_record_user(TOP1, &pressed);
426 pause_ms(CHORD_TIMEOUT + 1);
427 process_record_user(TOP1, &depressed);
428 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
429END_TEST
430
431TEST("one_shot_layer_hold")
432 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
433 process_record_user(BOT6, &pressed);
434 process_record_user(BOT7, &pressed);
435 pause_ms(CHORD_TIMEOUT + 1);
436 pause_ms(DANCE_TIMEOUT + 1);
437 ASSERT_EQ(UINT, current_pseudolayer, NUM);
438
439 process_record_user(TOP1, &pressed);
440 pause_ms(CHORD_TIMEOUT + 1);
441 process_record_user(TOP1, &depressed);
442 ASSERT_EQ(UINT, current_pseudolayer, NUM);
443
444 process_record_user(BOT6, &depressed);
445 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
446END_TEST
447
448TEST("one_shot_layer_retrotapping")
449 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
450 process_record_user(BOT6, &pressed);
451 process_record_user(BOT7, &pressed);
452 pause_ms(CHORD_TIMEOUT + 1);
453 pause_ms(DANCE_TIMEOUT + 1);
454 ASSERT_EQ(UINT, current_pseudolayer, NUM);
455
456 pause_ms(1000);
457
458 process_record_user(BOT6, &depressed);
459 ASSERT_EQ(UINT, current_pseudolayer, NUM);
460END_TEST
461
462// CMD
463TEST("command_mode")
464 // start recording
465 process_record_user(TOP5, &pressed);
466 process_record_user(TOP6, &pressed);
467 process_record_user(BOT5, &pressed);
468 process_record_user(BOT6, &pressed);
469 pause_ms(1);
470 process_record_user(TOP5, &depressed);
471 process_record_user(TOP6, &depressed);
472 process_record_user(BOT5, &depressed);
473 process_record_user(BOT6, &depressed);
474
475 ASSERT_EQ(UINT, command_mode, 1);
476
477 // record shift+q
478 process_record_user(BOT1, &pressed);
479 process_record_user(BOT2, &pressed);
480 pause_ms(CHORD_TIMEOUT + 1);
481 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
482 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
483 process_record_user(BOT1, &depressed);
484 process_record_user(BOT2, &depressed);
485 pause_ms(1000);
486
487 process_record_user(TOP1, &pressed);
488 pause_ms(CHORD_TIMEOUT + 1);
489 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
490 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
491 process_record_user(TOP1, &depressed);
492 pause_ms(1000);
493
494
495 ASSERT_EQ(UINT, keyboard_history[history_index][KC_Q], 0);
496 ASSERT_EQ(UINT, keyboard_history[history_index][KC_LSFT], 0);
497 // execute
498 process_record_user(TOP5, &pressed);
499 process_record_user(TOP6, &pressed);
500 process_record_user(BOT5, &pressed);
501 process_record_user(BOT6, &pressed);
502 pause_ms(CHORD_TIMEOUT + 1);
503
504 ASSERT_EQ(UINT, command_mode, 0);
505
506 // test history
507 ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
508 ASSERT_EQ(UINT, keyboard_history[0][KC_LSFT], 0);
509
510 ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 0);
511 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 1);
512
513 ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 1);
514 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
515
516 ASSERT_EQ(UINT, keyboard_history[3][KC_Q], 1);
517 ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 0);
518
519 ASSERT_EQ(UINT, keyboard_history[4][KC_Q], 0);
520 ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
521
522 ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 255);
523 ASSERT_EQ(UINT, keyboard_history[5][KC_LSFT], 255);
524END_TEST
525
526// KK
527TEST("key_key_dance_tap")
528 process_record_user(BOT2, &pressed);
529 pause_ms(CHORD_TIMEOUT + 1);
530 process_record_user(BOT2, &depressed);
531
532 ASSERT_EQ(UINT, keyboard_history[0][KC_X], 0);
533 ASSERT_EQ(UINT, keyboard_history[0][KC_LCTL], 0);
534
535 ASSERT_EQ(UINT, keyboard_history[1][KC_X], 1);
536 ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 0);
537
538 ASSERT_EQ(UINT, keyboard_history[2][KC_X], 0);
539 ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 0);
540END_TEST
541
542TEST("key_key_dance_hold")
543 process_record_user(BOT2, &pressed);
544 pause_ms(CHORD_TIMEOUT + 1);
545 pause_ms(DANCE_TIMEOUT + 1);
546 process_record_user(BOT2, &depressed);
547
548 ASSERT_EQ(UINT, keyboard_history[0][KC_X], 0);
549 ASSERT_EQ(UINT, keyboard_history[0][KC_LCTL], 0);
550
551 ASSERT_EQ(UINT, keyboard_history[1][KC_X], 0);
552 ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
553
554 ASSERT_EQ(UINT, keyboard_history[2][KC_X], 0);
555 ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 0);
556END_TEST
557
558// KL
559TEST("key_layer_tap")
560 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
561 process_record_user(BOT3, &pressed);
562 pause_ms(CHORD_TIMEOUT + 1);
563 ASSERT_EQ(UINT, current_pseudolayer, NUM);
564 process_record_user(BOT3, &depressed);
565 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
566 pause_ms(1000);
567
568 ASSERT_EQ(UINT, keyboard_history[0][KC_C], 0);
569 ASSERT_EQ(UINT, keyboard_history[1][KC_C], 1);
570 ASSERT_EQ(UINT, keyboard_history[2][KC_C], 0);
571 ASSERT_EQ(UINT, keyboard_history[3][KC_C], 255);
572END_TEST
573
574TEST("key_layer_retrotapping")
575 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
576 process_record_user(BOT3, &pressed);
577 pause_ms(1000);
578 ASSERT_EQ(UINT, current_pseudolayer, NUM);
579 process_record_user(BOT3, &depressed);
580 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
581 pause_ms(1000);
582
583 ASSERT_EQ(UINT, keyboard_history[0][KC_C], 0);
584 ASSERT_EQ(UINT, keyboard_history[1][KC_C], 1);
585 ASSERT_EQ(UINT, keyboard_history[2][KC_C], 0);
586 ASSERT_EQ(UINT, keyboard_history[3][KC_C], 255);
587END_TEST
588
589TEST("key_layer_hold_quick_typist")
590 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
591 process_record_user(BOT3, &pressed);
592 pause_ms(CHORD_TIMEOUT + 1);
593 ASSERT_EQ(UINT, current_pseudolayer, NUM);
594
595 pause_ms(1);
596 process_record_user(TOP1, &pressed);
597 pause_ms(1);
598 process_record_user(TOP1, &depressed);
599 pause_ms(1);
600 process_record_user(TOP1, &pressed);
601 pause_ms(1);
602 process_record_user(TOP1, &depressed);
603 pause_ms(1);
604 process_record_user(TOP1, &pressed);
605 pause_ms(1);
606 process_record_user(TOP1, &depressed);
607 ASSERT_EQ(UINT, current_pseudolayer, NUM);
608 pause_ms(1);
609
610 process_record_user(BOT3, &depressed);
611 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
612
613 ASSERT_EQ(UINT, keyboard_history[0][KC_1], 0);
614 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
615 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
616 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
617 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
618 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
619 ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
620 ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
621END_TEST
622
623TEST("key_layer_hold_slow_typist")
624 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
625 process_record_user(BOT3, &pressed);
626 pause_ms(CHORD_TIMEOUT + 1);
627 ASSERT_EQ(UINT, current_pseudolayer, NUM);
628
629 pause_ms(1000);
630 process_record_user(TOP1, &pressed);
631 pause_ms(1000);
632 process_record_user(TOP1, &depressed);
633 pause_ms(1000);
634 process_record_user(TOP1, &pressed);
635 pause_ms(1000);
636 process_record_user(TOP1, &depressed);
637 pause_ms(1000);
638 process_record_user(TOP1, &pressed);
639 pause_ms(1000);
640 process_record_user(TOP1, &depressed);
641 ASSERT_EQ(UINT, current_pseudolayer, NUM);
642 pause_ms(1);
643
644 process_record_user(BOT3, &depressed);
645 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
646
647 ASSERT_EQ(UINT, keyboard_history[0][KC_1], 0);
648 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
649 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
650 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
651 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
652 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
653 ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
654 ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
655END_TEST
656
657// KM
658TEST("key_mod_tap")
659 ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
660 ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
661 process_record_user(BOT4, &pressed);
662 pause_ms(CHORD_TIMEOUT + 1);
663 ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
664 ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
665 process_record_user(BOT4, &depressed);
666 ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 0);
667 ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
668 pause_ms(1000);
669
670 ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 0);
671 ASSERT_EQ(UINT, keyboard_history[3][KC_V], 1);
672 ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 0);
673 ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
674 ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 255);
675 ASSERT_EQ(UINT, keyboard_history[5][KC_V], 255);
676END_TEST
677
678TEST("key_mod_retrotapping")
679 ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
680 ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
681 process_record_user(BOT4, &pressed);
682 pause_ms(1000);
683 ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
684 ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
685 process_record_user(BOT4, &depressed);
686 ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 0);
687 ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
688 pause_ms(1000);
689
690 ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 0);
691 ASSERT_EQ(UINT, keyboard_history[3][KC_V], 1);
692 ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 0);
693 ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
694 ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 255);
695 ASSERT_EQ(UINT, keyboard_history[5][KC_V], 255);
696END_TEST
697
698TEST("key_mod_hold_quick_typist")
699 process_record_user(BOT4, &pressed);
700 pause_ms(CHORD_TIMEOUT + 1);
701
702 pause_ms(1);
703 process_record_user(TOP1, &pressed);
704 pause_ms(1);
705 process_record_user(TOP1, &depressed);
706 pause_ms(1);
707 process_record_user(TOP1, &pressed);
708 pause_ms(1);
709 process_record_user(TOP1, &depressed);
710 pause_ms(1);
711 process_record_user(TOP1, &pressed);
712 pause_ms(1);
713 process_record_user(TOP1, &depressed);
714 pause_ms(1);
715
716 process_record_user(BOT4, &depressed);
717 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
718
719 ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
720 ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
721 ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
722 ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
723 ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 1);
724 ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
725 ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 1);
726 ASSERT_EQ(UINT, keyboard_history[3][KC_V], 0);
727 ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 1);
728 ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
729 ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 1);
730 ASSERT_EQ(UINT, keyboard_history[5][KC_V], 0);
731 ASSERT_EQ(UINT, keyboard_history[6][KC_LALT], 1);
732 ASSERT_EQ(UINT, keyboard_history[6][KC_V], 0);
733 ASSERT_EQ(UINT, keyboard_history[7][KC_LALT], 1);
734 ASSERT_EQ(UINT, keyboard_history[7][KC_V], 0);
735 ASSERT_EQ(UINT, keyboard_history[8][KC_LALT], 0);
736 ASSERT_EQ(UINT, keyboard_history[8][KC_V], 0);
737 ASSERT_EQ(UINT, keyboard_history[9][KC_LALT], 255);
738 ASSERT_EQ(UINT, keyboard_history[9][KC_V], 255);
739END_TEST
740
741TEST("key_mod_hold_slow_typist")
742 process_record_user(BOT4, &pressed);
743 pause_ms(CHORD_TIMEOUT + 1);
744
745 pause_ms(1000);
746 process_record_user(TOP1, &pressed);
747 pause_ms(1000);
748 process_record_user(TOP1, &depressed);
749 pause_ms(1000);
750 process_record_user(TOP1, &pressed);
751 pause_ms(1000);
752 process_record_user(TOP1, &depressed);
753 pause_ms(1000);
754 process_record_user(TOP1, &pressed);
755 pause_ms(1000);
756 process_record_user(TOP1, &depressed);
757 pause_ms(1000);
758
759 process_record_user(BOT4, &depressed);
760 ASSERT_EQ(UINT, current_pseudolayer, QWERTY);
761
762 ASSERT_EQ(UINT, keyboard_history[0][KC_LALT], 0);
763 ASSERT_EQ(UINT, keyboard_history[0][KC_V], 0);
764 ASSERT_EQ(UINT, keyboard_history[0][KC_Q], 0);
765 ASSERT_EQ(UINT, keyboard_history[1][KC_LALT], 1);
766 ASSERT_EQ(UINT, keyboard_history[1][KC_V], 0);
767 ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 0);
768 ASSERT_EQ(UINT, keyboard_history[2][KC_LALT], 1);
769 ASSERT_EQ(UINT, keyboard_history[2][KC_V], 0);
770 ASSERT_EQ(UINT, keyboard_history[2][KC_Q], 1);
771 ASSERT_EQ(UINT, keyboard_history[3][KC_LALT], 1);
772 ASSERT_EQ(UINT, keyboard_history[3][KC_V], 0);
773 ASSERT_EQ(UINT, keyboard_history[3][KC_Q], 0);
774 ASSERT_EQ(UINT, keyboard_history[4][KC_LALT], 1);
775 ASSERT_EQ(UINT, keyboard_history[4][KC_V], 0);
776 ASSERT_EQ(UINT, keyboard_history[4][KC_Q], 1);
777 ASSERT_EQ(UINT, keyboard_history[5][KC_LALT], 1);
778 ASSERT_EQ(UINT, keyboard_history[5][KC_V], 0);
779 ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 0);
780 ASSERT_EQ(UINT, keyboard_history[6][KC_LALT], 1);
781 ASSERT_EQ(UINT, keyboard_history[6][KC_V], 0);
782 ASSERT_EQ(UINT, keyboard_history[6][KC_Q], 1);
783 ASSERT_EQ(UINT, keyboard_history[7][KC_LALT], 1);
784 ASSERT_EQ(UINT, keyboard_history[7][KC_V], 0);
785 ASSERT_EQ(UINT, keyboard_history[7][KC_Q], 0);
786 ASSERT_EQ(UINT, keyboard_history[8][KC_LALT], 0);
787 ASSERT_EQ(UINT, keyboard_history[8][KC_V], 0);
788 ASSERT_EQ(UINT, keyboard_history[8][KC_Q], 0);
789 ASSERT_EQ(UINT, keyboard_history[9][KC_LALT], 255);
790 ASSERT_EQ(UINT, keyboard_history[9][KC_V], 255);
791 ASSERT_EQ(UINT, keyboard_history[9][KC_Q], 255);
792END_TEST
793
794// LEADER
795TEST("leader_triggers_global")
796 uint8_t state = ACTIVATED;
797 struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, leader};
798 chord.function(&chord);
799
800 ASSERT_EQ(UINT, in_leader_mode, 1);
801END_TEST
802
803TEST("leader_no_follow")
804 uint8_t state = ACTIVATED;
805 struct Chord chord PROGMEM = {0, QWERTY, &state, NULL, 0, 0, leader};
806 chord.function(&chord);
807
808 ASSERT_EQ(UINT, in_leader_mode, 1);
809
810 pause_ms(1000);
811
812 ASSERT_EQ(UINT, in_leader_mode, 0);
813 ASSERT_EQ(UINT, keyboard_history[1][KC_O], 255);
814END_TEST
815
816TEST("leader_wrong_follow")
817 process_record_user(TOP2, &pressed);
818 process_record_user(TOP3, &pressed);
819 process_record_user(BOT2, &pressed);
820 process_record_user(BOT3, &pressed);
821 pause_ms(1);
822 process_record_user(TOP2, &depressed);
823 process_record_user(TOP3, &depressed);
824 process_record_user(BOT2, &depressed);
825 process_record_user(BOT3, &depressed);
826
827 ASSERT_EQ(UINT, in_leader_mode, 1);
828
829 pause_ms(1);
830 process_record_user(TOP1, &pressed);
831 pause_ms(1);
832 process_record_user(TOP1, &depressed);
833 pause_ms(1);
834 process_record_user(TOP2, &pressed);
835 pause_ms(1);
836 process_record_user(TOP2, &depressed);
837
838 pause_ms(LEADER_TIMEOUT);
839 pause_ms(1);
840
841 ASSERT_EQ(UINT, in_leader_mode, 0);
842 ASSERT_EQ(UINT, keyboard_history[1][KC_Q], 255);
843END_TEST
844
845TEST("leader_correct_follow")
846 process_record_user(TOP2, &pressed);
847 process_record_user(TOP3, &pressed);
848 process_record_user(BOT2, &pressed);
849 process_record_user(BOT3, &pressed);
850 pause_ms(1);
851 process_record_user(TOP2, &depressed);
852 process_record_user(TOP3, &depressed);
853 process_record_user(BOT2, &depressed);
854 process_record_user(BOT3, &depressed);
855
856 ASSERT_EQ(UINT, in_leader_mode, 1);
857
858 pause_ms(1);
859 process_record_user(TOP0, &pressed);
860 pause_ms(1);
861 process_record_user(TOP0, &depressed);
862 pause_ms(1);
863 process_record_user(TOP9, &pressed);
864 pause_ms(1);
865 process_record_user(TOP9, &depressed);
866
867 pause_ms(LEADER_TIMEOUT);
868 ASSERT_EQ(UINT, in_leader_mode, 1);
869
870 pause_ms(1);
871 ASSERT_EQ(UINT, in_leader_mode, 0);
872
873 ASSERT_EQ(UINT, keyboard_history[1][KC_O], 0);
874 ASSERT_EQ(UINT, keyboard_history[1][KC_P], 0);
875 ASSERT_EQ(UINT, keyboard_history[1][KC_A], 0);
876 ASSERT_EQ(UINT, keyboard_history[1][KC_S], 1);
877
878 ASSERT_EQ(UINT, keyboard_history[2][KC_O], 0);
879 ASSERT_EQ(UINT, keyboard_history[2][KC_P], 0);
880 ASSERT_EQ(UINT, keyboard_history[2][KC_A], 0);
881 ASSERT_EQ(UINT, keyboard_history[2][KC_S], 0);
882
883 ASSERT_EQ(UINT, keyboard_history[3][KC_O], 255);
884 ASSERT_EQ(UINT, keyboard_history[3][KC_P], 255);
885 ASSERT_EQ(UINT, keyboard_history[3][KC_A], 255);
886 ASSERT_EQ(UINT, keyboard_history[3][KC_S], 255);
887
888 ASSERT_EQ(UINT, keyboard_history[4][KC_O], 255);
889 ASSERT_EQ(UINT, keyboard_history[4][KC_P], 255);
890 ASSERT_EQ(UINT, keyboard_history[4][KC_A], 255);
891 ASSERT_EQ(UINT, keyboard_history[4][KC_S], 255);
892
893 ASSERT_EQ(UINT, keyboard_history[5][KC_Q], 255);
894END_TEST
895
896// DYNAMIC MACRO
897TEST("dynamic_macro_record_mode")
898 current_pseudolayer = NUM;
899
900 // record
901 ASSERT_EQ(UINT, dynamic_macro_mode, 0);
902 process_record_user(BOT7, &pressed);
903 process_record_user(BOT7, &depressed);
904 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
905 pause_ms(1000);
906 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
907END_TEST
908
909TEST("dynamic_macro_record_mode_off")
910 current_pseudolayer = NUM;
911
912 process_record_user(BOT7, &pressed);
913 process_record_user(BOT7, &depressed);
914 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
915
916 process_record_user(BOT9, &pressed);
917 process_record_user(BOT9, &depressed);
918 ASSERT_EQ(UINT, dynamic_macro_mode, 0);
919END_TEST
920
921TEST("dynamic_macro_record_one")
922 current_pseudolayer = NUM;
923
924 process_record_user(BOT7, &pressed);
925 process_record_user(BOT7, &depressed);
926 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
927
928 process_record_user(TOP1, &pressed);
929 process_record_user(TOP1, &depressed);
930
931 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
932
933 process_record_user(BOT9, &pressed);
934 process_record_user(BOT9, &depressed);
935
936 pause_ms(1000);
937
938 process_record_user(BOT0, &pressed);
939 process_record_user(BOT0, &depressed);
940
941 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
942 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
943 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 255);
944
945 pause_ms(1000);
946
947 process_record_user(BOT0, &pressed);
948 process_record_user(BOT0, &depressed);
949
950 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
951 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
952 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
953END_TEST
954
955TEST("dynamic_macro_record_two")
956 current_pseudolayer = NUM;
957
958 process_record_user(BOT7, &pressed);
959 process_record_user(BOT7, &depressed);
960 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
961
962 process_record_user(TOP1, &pressed);
963 process_record_user(TOP1, &depressed);
964
965 process_record_user(TOP2, &pressed);
966 process_record_user(TOP2, &depressed);
967
968 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
969
970 process_record_user(BOT9, &pressed);
971 process_record_user(BOT9, &depressed);
972
973 pause_ms(1000);
974
975 process_record_user(BOT0, &pressed);
976 process_record_user(BOT0, &depressed);
977
978 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
979 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 1);
980 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 0);
981 ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
982 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
983END_TEST
984
985TEST("dynamic_macro_record_two_parts")
986 current_pseudolayer = NUM;
987
988 process_record_user(BOT7, &pressed);
989 process_record_user(BOT7, &depressed);
990 ASSERT_EQ(UINT, dynamic_macro_mode, 1);
991
992 process_record_user(TOP1, &pressed);
993 process_record_user(TOP1, &depressed);
994
995 process_record_user(TOP2, &pressed);
996 process_record_user(TOP2, &depressed);
997
998 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 255);
999
1000 process_record_user(BOT8, &pressed);
1001 process_record_user(BOT8, &depressed);
1002
1003 process_record_user(TOP3, &pressed);
1004 process_record_user(TOP3, &depressed);
1005
1006 process_record_user(BOT9, &pressed);
1007 process_record_user(BOT9, &depressed);
1008
1009 pause_ms(1000);
1010
1011 process_record_user(BOT0, &pressed);
1012 process_record_user(BOT0, &depressed);
1013
1014 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
1015 ASSERT_EQ(UINT, keyboard_history[1][KC_2], 0);
1016 ASSERT_EQ(UINT, keyboard_history[1][KC_3], 0);
1017
1018 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 1);
1019 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 1);
1020 ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
1021
1022 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 0);
1023 ASSERT_EQ(UINT, keyboard_history[3][KC_2], 1);
1024 ASSERT_EQ(UINT, keyboard_history[3][KC_3], 0);
1025
1026 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
1027 ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
1028 ASSERT_EQ(UINT, keyboard_history[4][KC_3], 0);
1029
1030 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 0);
1031 ASSERT_EQ(UINT, keyboard_history[5][KC_2], 0);
1032 ASSERT_EQ(UINT, keyboard_history[5][KC_3], 1);
1033
1034 ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
1035 ASSERT_EQ(UINT, keyboard_history[6][KC_2], 0);
1036 ASSERT_EQ(UINT, keyboard_history[6][KC_3], 0);
1037
1038 ASSERT_EQ(UINT, keyboard_history[7][KC_1], 255);
1039END_TEST
1040
1041// dance + M()
1042
1043TEST("dance_tap")
1044 process_record_user(BOT0, &pressed);
1045 process_record_user(BOT0, &depressed);
1046
1047 pause_ms(1000);
1048
1049 ASSERT_EQ(UINT, keyboard_history[1][KC_9], 1);
1050 ASSERT_EQ(UINT, keyboard_history[1][KC_0], 0);
1051 ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
1052 ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
1053 ASSERT_EQ(UINT, keyboard_history[3][KC_9], 255);
1054END_TEST
1055
1056TEST("dance_hold")
1057 process_record_user(BOT0, &pressed);
1058 pause_ms(1000);
1059
1060 ASSERT_EQ(UINT, keyboard_history[1][KC_9], 1);
1061
1062 process_record_user(BOT0, &depressed);
1063 ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
1064END_TEST
1065
1066TEST("dance_tap_tap")
1067 process_record_user(BOT0, &pressed);
1068 process_record_user(BOT0, &depressed);
1069 process_record_user(BOT0, &pressed);
1070 process_record_user(BOT0, &depressed);
1071
1072 pause_ms(1000);
1073
1074 ASSERT_EQ(UINT, keyboard_history[1][KC_9], 0);
1075 ASSERT_EQ(UINT, keyboard_history[1][KC_0], 1);
1076 ASSERT_EQ(UINT, keyboard_history[2][KC_9], 0);
1077 ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
1078 ASSERT_EQ(UINT, keyboard_history[3][KC_9], 255);
1079END_TEST
1080
1081TEST("dance_tap_hold")
1082 process_record_user(BOT0, &pressed);
1083 process_record_user(BOT0, &depressed);
1084 pause_ms(1);
1085 process_record_user(BOT0, &pressed);
1086 pause_ms(1000);
1087
1088 ASSERT_EQ(UINT, keyboard_history[1][KC_0], 1);
1089
1090 process_record_user(BOT0, &depressed);
1091 ASSERT_EQ(UINT, keyboard_history[2][KC_0], 0);
1092END_TEST
1093
1094// MK
1095TEST("multiple_keys")
1096 current_pseudolayer = NUM;
1097
1098 process_record_user(BOT1, &pressed);
1099 process_record_user(BOT1, &depressed);
1100
1101 ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
1102 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
1103
1104 ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 1);
1105 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
1106
1107 ASSERT_EQ(UINT, keyboard_history[3][KC_LCTL], 0);
1108 ASSERT_EQ(UINT, keyboard_history[3][KC_LSFT], 1);
1109
1110 ASSERT_EQ(UINT, keyboard_history[4][KC_LCTL], 0);
1111 ASSERT_EQ(UINT, keyboard_history[4][KC_LSFT], 0);
1112
1113 ASSERT_EQ(UINT, keyboard_history[5][KC_LCTL], 255);
1114END_TEST
1115
1116TEST("multiple_keys_interleaved")
1117 current_pseudolayer = NUM;
1118
1119 process_record_user(BOT1, &pressed);
1120 pause_ms(CHORD_TIMEOUT+1);
1121
1122 process_record_user(TOP1, &pressed);
1123 process_record_user(TOP1, &depressed);
1124 process_record_user(TOP1, &pressed);
1125 process_record_user(TOP1, &depressed);
1126 process_record_user(TOP1, &pressed);
1127 process_record_user(TOP1, &depressed);
1128
1129 process_record_user(BOT1, &depressed);
1130
1131 ASSERT_EQ(UINT, keyboard_history[1][KC_LCTL], 1);
1132 ASSERT_EQ(UINT, keyboard_history[1][KC_LSFT], 0);
1133
1134 ASSERT_EQ(UINT, keyboard_history[2][KC_LCTL], 1);
1135 ASSERT_EQ(UINT, keyboard_history[2][KC_LSFT], 1);
1136
1137 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
1138 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
1139 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 1);
1140 ASSERT_EQ(UINT, keyboard_history[6][KC_1], 0);
1141 ASSERT_EQ(UINT, keyboard_history[7][KC_1], 1);
1142 ASSERT_EQ(UINT, keyboard_history[8][KC_1], 0);
1143
1144 ASSERT_EQ(UINT, keyboard_history[9][KC_LCTL], 0);
1145 ASSERT_EQ(UINT, keyboard_history[9][KC_LSFT], 1);
1146
1147 ASSERT_EQ(UINT, keyboard_history[10][KC_LCTL], 0);
1148 ASSERT_EQ(UINT, keyboard_history[10][KC_LSFT], 0);
1149
1150 ASSERT_EQ(UINT, keyboard_history[11][KC_LCTL], 255);
1151END_TEST
1152
1153// D
1154TEST("dance_one")
1155 current_pseudolayer = NUM;
1156
1157 process_record_user(BOT3, &pressed);
1158 process_record_user(BOT3, &depressed);
1159
1160 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1161
1162 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
1163 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
1164 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 255);
1165
1166 process_record_user(BOT3, &pressed);
1167 process_record_user(BOT3, &depressed);
1168
1169 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1170
1171 ASSERT_EQ(UINT, keyboard_history[1][KC_1], 1);
1172 ASSERT_EQ(UINT, keyboard_history[2][KC_1], 0);
1173 ASSERT_EQ(UINT, keyboard_history[3][KC_1], 1);
1174 ASSERT_EQ(UINT, keyboard_history[4][KC_1], 0);
1175 ASSERT_EQ(UINT, keyboard_history[5][KC_1], 255);
1176END_TEST
1177
1178TEST("dance_two")
1179 current_pseudolayer = NUM;
1180
1181 process_record_user(BOT3, &pressed);
1182 process_record_user(BOT3, &depressed);
1183 process_record_user(BOT3, &pressed);
1184 process_record_user(BOT3, &depressed);
1185
1186 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1187
1188 ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
1189 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
1190 ASSERT_EQ(UINT, keyboard_history[3][KC_2], 255);
1191
1192 process_record_user(BOT3, &pressed);
1193 process_record_user(BOT3, &depressed);
1194 process_record_user(BOT3, &pressed);
1195 process_record_user(BOT3, &depressed);
1196
1197 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1198
1199 ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
1200 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
1201 ASSERT_EQ(UINT, keyboard_history[3][KC_2], 1);
1202 ASSERT_EQ(UINT, keyboard_history[4][KC_2], 0);
1203 ASSERT_EQ(UINT, keyboard_history[5][KC_2], 255);
1204END_TEST
1205
1206TEST("dance_three")
1207 current_pseudolayer = NUM;
1208
1209 process_record_user(BOT3, &pressed);
1210 process_record_user(BOT3, &depressed);
1211 process_record_user(BOT3, &pressed);
1212 process_record_user(BOT3, &depressed);
1213 process_record_user(BOT3, &pressed);
1214 process_record_user(BOT3, &depressed);
1215
1216 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1217
1218 ASSERT_EQ(UINT, keyboard_history[1][KC_3], 1);
1219 ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
1220 ASSERT_EQ(UINT, keyboard_history[3][KC_3], 255);
1221
1222 process_record_user(BOT3, &pressed);
1223 process_record_user(BOT3, &depressed);
1224 process_record_user(BOT3, &pressed);
1225 process_record_user(BOT3, &depressed);
1226 process_record_user(BOT3, &pressed);
1227 process_record_user(BOT3, &depressed);
1228
1229 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1230
1231 ASSERT_EQ(UINT, keyboard_history[1][KC_3], 1);
1232 ASSERT_EQ(UINT, keyboard_history[2][KC_3], 0);
1233 ASSERT_EQ(UINT, keyboard_history[3][KC_3], 1);
1234 ASSERT_EQ(UINT, keyboard_history[4][KC_3], 0);
1235 ASSERT_EQ(UINT, keyboard_history[5][KC_3], 255);
1236END_TEST
1237
1238TEST("dance_two_held")
1239 current_pseudolayer = NUM;
1240
1241 process_record_user(BOT3, &pressed);
1242 process_record_user(BOT3, &depressed);
1243 process_record_user(BOT3, &pressed);
1244
1245 pause_ms(CHORD_TIMEOUT+DANCE_TIMEOUT+2);
1246
1247 ASSERT_EQ(UINT, keyboard_history[1][KC_2], 1);
1248 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 255);
1249
1250 process_record_user(BOT3, &depressed);
1251 ASSERT_EQ(UINT, keyboard_history[2][KC_2], 0);
1252 ASSERT_EQ(UINT, keyboard_history[3][KC_2], 255);
1253END_TEST
1254
1255// These two are leaving the chording engine, they kinda have to be tested manually
1256// TO
1257// RESET
1258
1259END
diff --git a/users/dennytom/chording_engine/tests/test_full.sh b/users/dennytom/chording_engine/tests/test_full.sh
new file mode 100644
index 000000000..ea93aec8f
--- /dev/null
+++ b/users/dennytom/chording_engine/tests/test_full.sh
@@ -0,0 +1,11 @@
1#!/bin/sh
2cd ..
3python3 parser.py tests/test_keymap_def.json tests/test_keymap.c && \
4gcc -g tests/test.c -o tests/test && \
5tests/test && \
6python3 parser.py ../../../keyboards/butterstick/keymaps/tomas/keymap_def.json ../../../keyboards/butterstick/keymaps/tomas/keymap.c && \
7python3 parser.py ../../../keyboards/georgi/keymaps/tomas/keymap_def.json ../../../keyboards/georgi/keymaps/tomas/keymap.c && \
8python3 parser.py ../../../keyboards/georgi/keymaps/buttery/keymap_def.json ../../../keyboards/georgi/keymaps/buttery/keymap.c && \
9cd ../../../ && \
10make butterstick && \
11make georgi \ No newline at end of file
diff --git a/users/dennytom/chording_engine/tests/test_keymap_def.json b/users/dennytom/chording_engine/tests/test_keymap_def.json
new file mode 100644
index 000000000..eae2ed37c
--- /dev/null
+++ b/users/dennytom/chording_engine/tests/test_keymap_def.json
@@ -0,0 +1,145 @@
1{
2 "keys": [
3 "TOP1", "TOP2", "TOP3", "TOP4", "TOP5", "TOP6", "TOP7", "TOP8", "TOP9", "TOP0",
4 "BOT1", "BOT2", "BOT3", "BOT4", "BOT5", "BOT6", "BOT7", "BOT8", "BOT9", "BOT0"
5 ],
6 "parameters": {
7 "do_not_include_QMK": true,
8 "layout_function_name": "LAYOUT_test",
9 "chord_timeout": 100,
10 "dance_timeout": 200,
11 "leader_timeout": 750,
12 "tap_timeout": 50,
13 "command_max_length": 5,
14 "leader_max_length": 5,
15 "dynamic_macro_max_length": 20,
16 "string_max_length": 16,
17 "long_press_multiplier": 3,
18 "default_pseudolayer": "QWERTY"
19 },
20 "layers": [
21 {
22 "type": "auto"
23 },
24 {
25 "type": "manual",
26 "keycodes": ["KC_1", "KC_2", "KC_3", "KC_4", "KC_5", "KC_6", "KC_7", "KC_8", "KC_9", "KC_0",
27 "KC_Q", "KC_W", "KC_E", "KC_R", "KC_T", "KC_Y", "KC_U", "KC_I", "KC_O", "KC_P"
28 ]
29 }
30 ],
31 "chord_sets": [
32 {
33 "name": "rows",
34 "chords": [
35 ["TOP1"], ["TOP2"], ["TOP3"], ["TOP4"], ["TOP5"], ["TOP6"], ["TOP7"], ["TOP8"], ["TOP9"], ["TOP0"],
36 ["TOP1", "BOT1"], ["TOP2", "BOT2"], ["TOP3", "BOT3"], ["TOP4", "BOT4"], ["TOP5", "BOT5"], ["TOP6", "BOT6"], ["TOP7", "BOT7"], ["TOP8", "BOT8"], ["TOP9", "BOT9"], ["TOP0", "BOT0"],
37 ["BOT1"], ["BOT2"], ["BOT3"], ["BOT4"], ["BOT5"], ["BOT6"], ["BOT7"], ["BOT8"], ["BOT9"], ["BOT0"]
38 ]
39 },
40 {
41 "name": "cols",
42 "chords": [
43 ["TOP1", "TOP2"], ["TOP2", "TOP3"], ["TOP3", "TOP4"], ["TOP4", "TOP5"], ["TOP5", "TOP6"], ["TOP6", "TOP7"], ["TOP7", "TOP8"], ["TOP8", "TOP9"], ["TOP9", "TOP0"],
44 ["TOP1", "TOP2", "BOT1", "BOT2"], ["TOP2", "TOP3", "BOT2", "BOT3"], ["TOP3", "TOP4", "BOT3", "BOT4"], ["TOP4", "TOP5", "BOT4", "BOT5"], ["TOP5", "TOP6", "BOT5", "BOT6"], ["TOP6", "TOP7", "BOT6", "BOT7"], ["TOP7", "TOP8", "BOT7", "BOT8"], ["TOP8", "TOP9", "BOT8", "BOT9"], ["TOP9", "TOP0", "BOT9", "BOT0"],
45 ["BOT1", "BOT2"], ["BOT2", "BOT3"], ["BOT3", "BOT4"], ["BOT4", "BOT5"], ["BOT5", "BOT6"], ["BOT6", "BOT7"], ["BOT7", "BOT8"], ["BOT8", "BOT9"], ["BOT9", "BOT0"]
46 ]
47 },
48 {
49 "name": "asetniop",
50 "chords": [
51 ["TOP1"], ["TOP2"], ["TOP3"], ["TOP4"], ["TOP7"], ["TOP8"], ["TOP9"], ["TOP0"],
52 ["TOP1", "TOP2"], ["TOP2", "TOP3"], ["TOP3", "TOP4"], ["TOP4", "TOP7"], ["TOP7", "TOP8"], ["TOP8", "TOP9"], ["TOP9", "TOP0"],
53 ["TOP1", "TOP3"], ["TOP2", "TOP4"], ["TOP3", "TOP7"], ["TOP4", "TOP8"], ["TOP7", "TOP9"], ["TOP8", "TOP0"],
54 ["TOP1", "TOP4"], ["TOP2", "TOP7"], ["TOP3", "TOP8"], ["TOP4", "TOP9"], ["TOP7", "TOP0"],
55 ["TOP1", "TOP7"], ["TOP2", "TOP8"], ["TOP3", "TOP9"], ["TOP4", "TOP0"],
56 ["TOP1", "TOP8"], ["TOP2", "TOP9"], ["TOP3", "TOP0"],
57 ["TOP1", "TOP9"], ["TOP2", "TOP0"],
58 ["TOP1", "TOP0"]
59 ]
60 }
61 ],
62 "pseudolayers": [
63 {
64 "name": "ALWAYS_ON",
65 "chords": [
66 {
67 "type": "visual",
68 "chord": [
69 " ", " ", " ", " ", " ", " ", " ", "X", "X", "X",
70 " ", " ", " ", " ", " ", " ", " ", "X", "X", "X"
71 ],
72 "keycode": "MO(FNC, NUM)"
73 }
74 ]
75 },
76 {
77 "name": "QWERTY",
78 "chords": [
79 {
80 "type": "chord_set",
81 "set": "rows",
82 "keycodes": [
83 "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
84 "A", "S", "D", "F", "G", "H", "J", "K", "L", ";",
85 "AS(Z)", "KK(X, LCTL)", "KL(C, NUM)", "KM(V, LALT)", "B", "N", "M", "COMMA", ".", "M(double_dance, KC_9, KC_0)"
86 ]
87 },
88 {
89 "type": "chord_set",
90 "set": "cols",
91 "keycodes": [
92 "ESC", "", "", "", "", "", "", "", "",
93 "", "LEAD", "", "", "CMD", "", "", "", "",
94 "LSFT", "O(LSFT)", "", "", "", "O(NUM)", "MO(NUM)", "", "DF(NUM)"
95 ]
96 },
97 {
98 "type": "visual",
99 "chord": [
100 "X", "X", " ", " ", " ", " ", " ", " ", " ", " ",
101 "X", "X", " ", " ", " ", " ", " ", " ", " ", " "
102 ],
103 "keycode": "LOCK"
104 }
105 ]
106 },
107 {
108 "name": "NUM",
109 "chords": [
110 {
111 "type": "chord_set",
112 "set": "rows",
113 "keycodes": [
114 "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
115 "", "", "", "", "", "", "", "", "", "",
116 "", "KC_LEFT", "D(KC_1, KC_2, KC_3)", "", "", "", "DM_RECORD", "DM_NEXT", "DM_END", "DM_PLAY"
117 ]
118 },
119 {
120 "type": "simple",
121 "chord": ["BOT1"],
122 "keycode": "MK(KC_LCTL, KC_LSFT)"
123 }
124 ]
125 },
126 {
127 "name": "FNC",
128 "chords": []
129 }
130 ],
131 "leader_sequences": [
132 {
133 "name": "fnc_L1",
134 "function": "void fnc_L1(void) { key_in(KC_A); clear_keyboard(); }",
135 "sequence": ["KC_O", "KC_P"]
136 },
137 {
138 "name": "fnc_L2",
139 "function": "void fnc_L2(void) { key_in(KC_S); clear_keyboard(); }",
140 "sequence": ["KC_P", "KC_O"]
141 }
142 ],
143 "extra_code": "void double_dance(const struct Chord* self) {\n switch (*self->state) {\n case ACTIVATED:\n *self->counter = (*self->counter + 1) % 2;\n break;\n case PRESS_FROM_ACTIVE:\n if (*self->counter == 1) {\n key_in(self->value1);\n } else {\n key_in(self->value2);\n }\n *self->state = FINISHED_FROM_ACTIVE;\n break;\n case FINISHED:\n if (*self->counter == 1) {\n tap_key(self->value1);\n } else {\n tap_key(self->value2);\n }\n *self->counter = 0;\n *self->state = IDLE;\n break;\n case RESTART:\n if (*self->counter == 1) {\n key_out(self->value1);\n } else {\n key_out(self->value2);\n }\n *self->counter = 0;\n break;\n default:\n break;\n }\n}\n",
144 "extra_dependencies": []
145} \ No newline at end of file
diff --git a/users/dennytom/chording_engine/tests/test_quick.sh b/users/dennytom/chording_engine/tests/test_quick.sh
new file mode 100644
index 000000000..3740122e2
--- /dev/null
+++ b/users/dennytom/chording_engine/tests/test_quick.sh
@@ -0,0 +1,6 @@
1#!/bin/sh
2
3cd ..
4python3 parser.py tests/test_keymap_def.json tests/test_keymap.c && \
5gcc -g tests/test.c -o tests/test && \
6tests/test \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-02 20:59:59 +0000