Line | Branch | Exec | Source |
---|---|---|---|
1 | #include "test.h" | ||
2 | #include "terminal/color.h" | ||
3 | #include "terminal/cursor.h" | ||
4 | #include "terminal/feature.h" | ||
5 | #include "terminal/input.h" | ||
6 | #include "terminal/key.h" | ||
7 | #include "terminal/linux.h" | ||
8 | #include "terminal/osc52.h" | ||
9 | #include "terminal/output.h" | ||
10 | #include "terminal/parse.h" | ||
11 | #include "terminal/rxvt.h" | ||
12 | #include "terminal/style.h" | ||
13 | #include "terminal/terminal.h" | ||
14 | #include "ui.h" // update_term_title() | ||
15 | #include "util/bit.h" | ||
16 | #include "util/str-array.h" | ||
17 | #include "util/unicode.h" | ||
18 | #include "util/utf8.h" | ||
19 | #include "util/xsnprintf.h" | ||
20 | |||
21 | #define TFLAG(flags) (KEYCODE_QUERY_REPLY_BIT | (flags)) | ||
22 | #define IEXPECT_KEYCODE_EQ(a, b, seq, seq_len) IEXPECT(keycode_eq, a, b, seq, seq_len) | ||
23 | #define EXPECT_PARSE_SEQ(seq, expkey) EXPECT(parse_seq, seq, STRLEN(seq), expkey) | ||
24 | #define EXPECT_PARSE_SEQN(seq, explen, expkey) EXPECT(parse_seq, seq, explen, expkey) | ||
25 | |||
26 | 1636 | static void iexpect_keycode_eq ( | |
27 | TestContext *ctx, | ||
28 | const char *file, | ||
29 | int line, | ||
30 | size_t idx, | ||
31 | KeyCode a, | ||
32 | KeyCode b, | ||
33 | const char *seq, | ||
34 | size_t seq_len | ||
35 | ) { | ||
36 |
1/2✓ Branch 0 (2→3) taken 1636 times.
✗ Branch 1 (2→5) not taken.
|
1636 | if (likely(a == b)) { |
37 | 1636 | test_pass(ctx); | |
38 | 1636 | return; | |
39 | } | ||
40 | |||
41 | ✗ | char a_str[KEYCODE_STR_BUFSIZE]; | |
42 | ✗ | char b_str[KEYCODE_STR_BUFSIZE]; | |
43 | ✗ | char seq_str[64]; | |
44 | ✗ | keycode_to_str(a, a_str); | |
45 | ✗ | keycode_to_str(b, b_str); | |
46 | ✗ | u_make_printable(seq, seq_len, seq_str, sizeof seq_str, 0); | |
47 | |||
48 | − | test_fail( | |
49 | ctx, file, line, | ||
50 | "Test #%zu: key codes not equal: 0x%02x, 0x%02x (%s, %s); input: %s", | ||
51 | ++idx, a, b, a_str, b_str, seq_str | ||
52 | ); | ||
53 | } | ||
54 | |||
55 | 291 | static void expect_parse_seq ( | |
56 | TestContext *ctx, | ||
57 | const char *file, | ||
58 | int line, | ||
59 | const char *seq, | ||
60 | ssize_t expected_length, | ||
61 | KeyCode expected_key | ||
62 | ) { | ||
63 | 291 | KeyCode key = 0x18; | |
64 | 291 | ssize_t parsed_length = term_parse_sequence(seq, strlen(seq), &key); | |
65 |
1/2✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→5) taken 291 times.
|
291 | if (unlikely(parsed_length != expected_length)) { |
66 | − | test_fail ( | |
67 | ctx, file, line, | ||
68 | "term_parse_sequence() returned %zd; expected %zd", | ||
69 | parsed_length, expected_length | ||
70 | ); | ||
71 | 14 | return; | |
72 | } | ||
73 | |||
74 | 291 | static_assert(TPARSE_PARTIAL_MATCH == -1); | |
75 |
2/2✓ Branch 0 (5→6) taken 14 times.
✓ Branch 1 (5→8) taken 277 times.
|
291 | if (expected_length <= 0) { |
76 | 14 | test_pass(ctx); | |
77 | 14 | return; | |
78 | } | ||
79 | |||
80 |
1/2✗ Branch 0 (8→9) not taken.
✓ Branch 1 (8→13) taken 277 times.
|
277 | if (unlikely(key != expected_key)) { |
81 | ✗ | char str[2][KEYCODE_STR_BUFSIZE]; | |
82 | ✗ | keycode_to_str(key, str[0]); | |
83 | ✗ | keycode_to_str(expected_key, str[1]); | |
84 | − | test_fail ( | |
85 | ctx, file, line, | ||
86 | "Key codes not equal: 0x%02x, 0x%02x (%s, %s)", | ||
87 | key, expected_key, str[0], str[1] | ||
88 | ); | ||
89 | ✗ | return; | |
90 | } | ||
91 | |||
92 |
2/2✓ Branch 0 (19→14) taken 1801 times.
✓ Branch 1 (19→20) taken 277 times.
|
2078 | for (size_t n = expected_length - 1; n != 0; n--) { |
93 | 1801 | parsed_length = term_parse_sequence(seq, n, &key); | |
94 |
1/2✓ Branch 0 (15→16) taken 1801 times.
✗ Branch 1 (15→17) not taken.
|
1801 | if (parsed_length == TPARSE_PARTIAL_MATCH) { |
95 | 1801 | continue; | |
96 | } | ||
97 | − | test_fail ( | |
98 | ctx, file, line, | ||
99 | "Parsing truncated sequence of %zu bytes returned %zd; expected -1", | ||
100 | n, parsed_length | ||
101 | ); | ||
102 | ✗ | return; | |
103 | } | ||
104 | |||
105 | 277 | test_pass(ctx); | |
106 | } | ||
107 | |||
108 | 1 | static void test_parse_rgb(TestContext *ctx) | |
109 | { | ||
110 | 1 | EXPECT_EQ(parse_rgb(STRN("f01cff")), COLOR_RGB(0xf01cff)); | |
111 | 1 | EXPECT_EQ(parse_rgb(STRN("011011")), COLOR_RGB(0x011011)); | |
112 | 1 | EXPECT_EQ(parse_rgb(STRN("12aC90")), COLOR_RGB(0x12ac90)); | |
113 | 1 | EXPECT_EQ(parse_rgb(STRN("fffffF")), COLOR_RGB(0xffffff)); | |
114 | 1 | EXPECT_EQ(parse_rgb(STRN("fa0")), COLOR_RGB(0xffaa00)); | |
115 | 1 | EXPECT_EQ(parse_rgb(STRN("123")), COLOR_RGB(0x112233)); | |
116 | 1 | EXPECT_EQ(parse_rgb(STRN("fff")), COLOR_RGB(0xffffff)); | |
117 | 1 | EXPECT_EQ(parse_rgb(STRN("ABC")), COLOR_RGB(0xaabbcc)); | |
118 | 1 | EXPECT_EQ(parse_rgb(STRN("0F0")), COLOR_RGB(0x00ff00)); | |
119 | 1 | EXPECT_EQ(parse_rgb(STRN("000")), COLOR_RGB(0x000000)); | |
120 | 1 | EXPECT_EQ(parse_rgb(STRN("fffffg")), COLOR_INVALID); | |
121 | 1 | EXPECT_EQ(parse_rgb(STRN(".")), COLOR_INVALID); | |
122 | 1 | EXPECT_EQ(parse_rgb(STRN("")), COLOR_INVALID); | |
123 | 1 | EXPECT_EQ(parse_rgb(STRN("11223")), COLOR_INVALID); | |
124 | 1 | EXPECT_EQ(parse_rgb(STRN("efg")), COLOR_INVALID); | |
125 | 1 | EXPECT_EQ(parse_rgb(STRN("12")), COLOR_INVALID); | |
126 | 1 | EXPECT_EQ(parse_rgb(STRN("ffff")), COLOR_INVALID); | |
127 | 1 | EXPECT_EQ(parse_rgb(STRN("00")), COLOR_INVALID); | |
128 | 1 | EXPECT_EQ(parse_rgb(STRN("1234567")), COLOR_INVALID); | |
129 | 1 | EXPECT_EQ(parse_rgb(STRN("123456789")), COLOR_INVALID); | |
130 | 1 | } | |
131 | |||
132 | 1 | static void test_parse_term_style(TestContext *ctx) | |
133 | { | ||
134 | 1 | static const struct { | |
135 | ssize_t expected_return; | ||
136 | const char *const strs[4]; | ||
137 | TermStyle expected_style; | ||
138 | } tests[] = { | ||
139 | {3, {"bold", "red", "yellow"}, {COLOR_RED, COLOR_YELLOW, ATTR_BOLD}}, | ||
140 | {1, {"#ff0000"}, {COLOR_RGB(0xff0000), -1, 0}}, | ||
141 | {2, {"#f00a9c", "reverse"}, {COLOR_RGB(0xf00a9c), -1, ATTR_REVERSE}}, | ||
142 | {2, {"black", "#00ffff"}, {COLOR_BLACK, COLOR_RGB(0x00ffff), 0}}, | ||
143 | {2, {"#123456", "#abcdef"}, {COLOR_RGB(0x123456), COLOR_RGB(0xabcdef), 0}}, | ||
144 | {2, {"#123", "#fa0"}, {COLOR_RGB(0x112233), COLOR_RGB(0xffaa00), 0}}, | ||
145 | {2, {"#A1B2C3", "gray"}, {COLOR_RGB(0xa1b2c3), COLOR_GRAY, 0}}, | ||
146 | {2, {"red", "strikethrough"}, {COLOR_RED, -1, ATTR_STRIKETHROUGH}}, | ||
147 | {1, {"5/5/5"}, {231, COLOR_DEFAULT, 0}}, | ||
148 | {3, {"1/3/0", "0/5/2", "italic"}, {70, 48, ATTR_ITALIC}}, | ||
149 | {2, {"-1", "-2"}, {COLOR_DEFAULT, COLOR_KEEP, 0}}, | ||
150 | {3, {"keep", "red", "keep"}, {-2, COLOR_RED, ATTR_KEEP}}, | ||
151 | {2, {"bold", "blink"}, {-1, -1, ATTR_BOLD | ATTR_BLINK}}, | ||
152 | {3, {"0", "255", "underline"}, {COLOR_BLACK, 255, ATTR_UNDERLINE}}, | ||
153 | {3, {"white", "green", "dim"}, {COLOR_WHITE, COLOR_GREEN, ATTR_DIM}}, | ||
154 | {3, {"white", "green", "lowintensity"}, {COLOR_WHITE, COLOR_GREEN, ATTR_DIM}}, | ||
155 | {2, {"lightred", "lightyellow"}, {COLOR_LIGHTRED, COLOR_LIGHTYELLOW, 0}}, | ||
156 | {2, {"darkgray", "lightgreen"}, {COLOR_DARKGRAY, COLOR_LIGHTGREEN, 0}}, | ||
157 | {2, {"lightblue", "lightcyan"}, {COLOR_LIGHTBLUE, COLOR_LIGHTCYAN, 0}}, | ||
158 | {1, {"lightmagenta"}, {COLOR_LIGHTMAGENTA, COLOR_DEFAULT, 0}}, | ||
159 | {3, {"keep", "254", "keep"}, {COLOR_KEEP, 254, ATTR_KEEP}}, | ||
160 | {2, {"keep", "keep"}, {COLOR_KEEP, COLOR_KEEP, 0}}, | ||
161 | {3, {"red", "green", "keep"}, {COLOR_RED, COLOR_GREEN, ATTR_KEEP}}, | ||
162 | {3, {"1", "2", "invisible"}, {COLOR_RED, COLOR_GREEN, ATTR_INVIS}}, | ||
163 | {2, {"default", "0/0/0"}, {COLOR_DEFAULT, 16, 0}}, | ||
164 | {2, {"2/3/4", "5/5/5"}, {110, 231, 0}}, | ||
165 | {0, {NULL}, {COLOR_DEFAULT, COLOR_DEFAULT, 0}}, | ||
166 | // Invalid: | ||
167 | {2, {"red", "blue", "invalid"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
168 | {-1, {"cyan", "magenta", "yellow"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
169 | {0, {"invalid", "default", "bold"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
170 | {1, {"italic", "invalid"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
171 | {2, {"red", "blue", ""}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
172 | {2, {"24", "#abc", "dims"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
173 | {0, {""}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
174 | {0, {"."}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
175 | {0, {"#"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
176 | {0, {"-3"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
177 | {0, {"256"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
178 | {0, {"brightred"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
179 | {0, {"lighttblack"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
180 | {0, {"lightwhite"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
181 | {0, {"#fffffg"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
182 | {0, {"#12345"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
183 | {0, {"123456"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
184 | {0, {"//0/0"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
185 | {0, {"0/0/:"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
186 | {0, {"light_"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
187 | {0, {"\xFF/0/0"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
188 | {0, {"1/2/\x9E"}, {COLOR_INVALID, COLOR_INVALID, 0}}, | ||
189 | }; | ||
190 |
2/2✓ Branch 0 (10→3) taken 49 times.
✓ Branch 1 (10→11) taken 1 times.
|
50 | FOR_EACH_I(i, tests) { |
191 | 49 | const TermStyle expected = tests[i].expected_style; | |
192 | 49 | TermStyle parsed = {COLOR_INVALID, COLOR_INVALID, 0}; | |
193 | 49 | char **strs = (char**)tests[i].strs; | |
194 | 49 | ssize_t n = parse_term_style(&parsed, strs, string_array_length(strs)); | |
195 | 49 | IEXPECT_EQ(n, tests[i].expected_return); | |
196 | 49 | IEXPECT_EQ(parsed.fg, expected.fg); | |
197 | 49 | IEXPECT_EQ(parsed.bg, expected.bg); | |
198 | 49 | IEXPECT_EQ(parsed.attr, expected.attr); | |
199 | 49 | IEXPECT_TRUE(same_style(&parsed, &expected)); | |
200 | } | ||
201 | 1 | } | |
202 | |||
203 | 1 | static void test_color_to_nearest(TestContext *ctx) | |
204 | { | ||
205 | 1 | static const struct { | |
206 | int32_t input; | ||
207 | int32_t expected_rgb; | ||
208 | int32_t expected_256; | ||
209 | int32_t expected_16; | ||
210 | } tests[] = { | ||
211 | // ECMA-48 colors | ||
212 | {0, 0, 0, 0}, | ||
213 | {5, 5, 5, 5}, | ||
214 | {7, 7, 7, 7}, | ||
215 | |||
216 | // aixterm-style colors | ||
217 | {8, 8, 8, 8}, | ||
218 | {10, 10, 10, 10}, | ||
219 | {15, 15, 15, 15}, | ||
220 | |||
221 | // xterm 256 palette colors | ||
222 | {25, 25, 25, COLOR_BLUE}, | ||
223 | {87, 87, 87, COLOR_LIGHTCYAN}, | ||
224 | {88, 88, 88, COLOR_RED}, | ||
225 | {90, 90, 90, COLOR_MAGENTA}, | ||
226 | {96, 96, 96, COLOR_MAGENTA}, | ||
227 | {178, 178, 178, COLOR_YELLOW}, | ||
228 | {179, 179, 179, COLOR_YELLOW}, | ||
229 | |||
230 | // RGB colors with exact xterm 6x6x6 cube equivalents | ||
231 | {COLOR_RGB(0x000000), 16, 16, COLOR_BLACK}, | ||
232 | {COLOR_RGB(0x000087), 18, 18, COLOR_BLUE}, | ||
233 | {COLOR_RGB(0x0000FF), 21, 21, COLOR_LIGHTBLUE}, | ||
234 | {COLOR_RGB(0x00AF87), 36, 36, COLOR_GREEN}, | ||
235 | {COLOR_RGB(0x00FF00), 46, 46, COLOR_LIGHTGREEN}, | ||
236 | {COLOR_RGB(0x870000), 88, 88, COLOR_RED}, | ||
237 | {COLOR_RGB(0xFF0000), 196, 196, COLOR_LIGHTRED}, | ||
238 | {COLOR_RGB(0xFFD700), 220, 220, COLOR_YELLOW}, | ||
239 | {COLOR_RGB(0xFFFF5F), 227, 227, COLOR_LIGHTYELLOW}, | ||
240 | {COLOR_RGB(0xFFFFFF), 231, 231, COLOR_WHITE}, | ||
241 | |||
242 | // RGB colors with exact xterm grayscale equivalents | ||
243 | {COLOR_RGB(0x080808), 232, 232, COLOR_BLACK}, | ||
244 | {COLOR_RGB(0x121212), 233, 233, COLOR_BLACK}, | ||
245 | {COLOR_RGB(0x6C6C6C), 242, 242, COLOR_DARKGRAY}, | ||
246 | {COLOR_RGB(0xA8A8A8), 248, 248, COLOR_GRAY}, | ||
247 | {COLOR_RGB(0xB2B2B2), 249, 249, COLOR_GRAY}, | ||
248 | {COLOR_RGB(0xBCBCBC), 250, 250, COLOR_WHITE}, | ||
249 | {COLOR_RGB(0xEEEEEE), 255, 255, COLOR_WHITE}, | ||
250 | |||
251 | // RGB colors with NO exact xterm equivalents | ||
252 | {COLOR_RGB(0x00FF88), COLOR_RGB(0x00FF88), 48, COLOR_LIGHTGREEN}, | ||
253 | {COLOR_RGB(0xFF0001), COLOR_RGB(0xFF0001), 196, COLOR_LIGHTRED}, | ||
254 | {COLOR_RGB(0xAABBCC), COLOR_RGB(0xAABBCC), 146, COLOR_LIGHTBLUE}, | ||
255 | {COLOR_RGB(0x010101), COLOR_RGB(0x010101), 16, COLOR_BLACK}, | ||
256 | {COLOR_RGB(0x070707), COLOR_RGB(0x070707), 232, COLOR_BLACK}, | ||
257 | {COLOR_RGB(0x080809), COLOR_RGB(0x080809), 232, COLOR_BLACK}, | ||
258 | {COLOR_RGB(0xBABABA), COLOR_RGB(0xBABABA), 250, COLOR_WHITE}, | ||
259 | {COLOR_RGB(0xEEEEED), COLOR_RGB(0xEEEEED), 255, COLOR_WHITE}, | ||
260 | {COLOR_RGB(0xEFEFEF), COLOR_RGB(0xEFEFEF), 255, COLOR_WHITE}, | ||
261 | {COLOR_RGB(0xF0F0F0), COLOR_RGB(0xF0F0F0), 255, COLOR_WHITE}, | ||
262 | {COLOR_RGB(0xF6F6F6), COLOR_RGB(0xF6F6F6), 255, COLOR_WHITE}, | ||
263 | {COLOR_RGB(0xF7F7F7), COLOR_RGB(0xF7F7F7), 231, COLOR_WHITE}, | ||
264 | {COLOR_RGB(0xFEFEFE), COLOR_RGB(0xFEFEFE), 231, COLOR_WHITE}, | ||
265 | }; | ||
266 | |||
267 |
2/2✓ Branch 0 (16→3) taken 43 times.
✓ Branch 1 (16→17) taken 1 times.
|
44 | FOR_EACH_I(i, tests) { |
268 | 43 | const int32_t c = tests[i].input; | |
269 | 43 | IEXPECT_EQ(color_to_nearest(c, TFLAG_TRUE_COLOR, false), c); | |
270 | 43 | IEXPECT_EQ(color_to_nearest(c, TFLAG_TRUE_COLOR, true), tests[i].expected_rgb); | |
271 | 43 | IEXPECT_EQ(color_to_nearest(c, TFLAG_256_COLOR, false), tests[i].expected_256); | |
272 | 43 | IEXPECT_EQ(color_to_nearest(c, TFLAG_16_COLOR, false), tests[i].expected_16); | |
273 | 43 | IEXPECT_EQ(color_to_nearest(c, TFLAG_8_COLOR, false), tests[i].expected_16 & 7); | |
274 | 43 | IEXPECT_EQ(color_to_nearest(c, 0, false), COLOR_DEFAULT); | |
275 | } | ||
276 | |||
277 | static const uint8_t color_stops[6] = {0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff}; | ||
278 | size_t count = 0; | ||
279 | |||
280 |
2/2✓ Branch 0 (40→18) taken 5 times.
✓ Branch 1 (40→41) taken 1 times.
|
6 | for (size_t i = 1; i < ARRAYLEN(color_stops); i++) { |
281 | 5 | uint8_t min = color_stops[i - 1]; | |
282 | 5 | uint8_t max = color_stops[i]; | |
283 | 5 | uint8_t mid = min + ((max - min) / 2); | |
284 |
2/2✓ Branch 0 (38→19) taken 260 times.
✓ Branch 1 (38→39) taken 5 times.
|
265 | for (unsigned int b = min; b <= max; b++, count++) { |
285 | 260 | int32_t orig = COLOR_RGB(b); | |
286 | 260 | int32_t nearest = color_to_nearest(orig, TFLAG_256_COLOR, false); | |
287 |
2/2✓ Branch 0 (20→21) taken 127 times.
✓ Branch 1 (20→22) taken 133 times.
|
260 | size_t nearest_stop_idx = (b < mid) ? i - 1 : i; |
288 | 260 | EXPECT_TRUE(nearest >= 16); | |
289 | 260 | EXPECT_TRUE(nearest <= 255); | |
290 |
2/2✓ Branch 0 (24→25) taken 220 times.
✓ Branch 1 (24→26) taken 40 times.
|
260 | if (nearest < 232) { |
291 | 220 | EXPECT_EQ(nearest, nearest_stop_idx + 16); | |
292 | } else { | ||
293 | 40 | int32_t v = orig & ~COLOR_FLAG_RGB; | |
294 | 40 | EXPECT_TRUE(v >= 0x0D); | |
295 | 40 | EXPECT_TRUE(v <= 0x34); | |
296 | 40 | EXPECT_EQ(nearest, 232 + (((b / 3) - 3) / 10)); | |
297 | } | ||
298 |
2/4✓ Branch 0 (29→30) taken 260 times.
✗ Branch 1 (29→31) not taken.
✗ Branch 2 (30→31) not taken.
✓ Branch 3 (30→34) taken 260 times.
|
260 | if (nearest == min || nearest == max) { |
299 | ✗ | EXPECT_EQ(nearest, b); | |
300 | ✗ | EXPECT_EQ(nearest, color_to_nearest(orig, TFLAG_TRUE_COLOR, true)); | |
301 | } | ||
302 | 445 | EXPECT_EQ(nearest_stop_idx, ((uint8_t)b - (b < 75 ? 7 : 35)) / 40); | |
303 | } | ||
304 | } | ||
305 | |||
306 | 1 | EXPECT_EQ(count, 255 + ARRAYLEN(color_stops) - 1); | |
307 | 1 | } | |
308 | |||
309 | 1 | static void test_color_to_str(TestContext *ctx) | |
310 | { | ||
311 | 1 | static const struct { | |
312 | char expected_string[15]; | ||
313 | uint8_t expected_len; | ||
314 | int32_t color; | ||
315 | } tests[] = { | ||
316 | {STRN("keep"), COLOR_KEEP}, | ||
317 | {STRN("default"), COLOR_DEFAULT}, | ||
318 | {STRN("black"), COLOR_BLACK}, | ||
319 | {STRN("gray"), COLOR_GRAY}, | ||
320 | {STRN("darkgray"), COLOR_DARKGRAY}, | ||
321 | {STRN("lightmagenta"), COLOR_LIGHTMAGENTA}, | ||
322 | {STRN("white"), COLOR_WHITE}, | ||
323 | {STRN("16"), 16}, | ||
324 | {STRN("255"), 255}, | ||
325 | {STRN("#abcdef"), COLOR_RGB(0xabcdef)}, | ||
326 | {STRN("#00001e"), COLOR_RGB(0x00001e)}, | ||
327 | {STRN("#000000"), COLOR_RGB(0x000000)}, | ||
328 | {STRN("#100001"), COLOR_RGB(0x100001)}, | ||
329 | {STRN("#ffffff"), COLOR_RGB(0xffffff)}, | ||
330 | }; | ||
331 | |||
332 | 1 | char buf[COLOR_STR_BUFSIZE] = ""; | |
333 |
2/2✓ Branch 0 (7→3) taken 14 times.
✓ Branch 1 (7→8) taken 1 times.
|
15 | FOR_EACH_I(i, tests) { |
334 | 14 | int32_t color = tests[i].color; | |
335 | 14 | ASSERT_TRUE(color_is_valid(color)); | |
336 | 14 | size_t len = color_to_str(buf, color); | |
337 | 14 | EXPECT_MEMEQ(buf, len, tests[i].expected_string, tests[i].expected_len); | |
338 | } | ||
339 | 1 | } | |
340 | |||
341 | 1 | static void test_term_style_to_string(TestContext *ctx) | |
342 | { | ||
343 | 1 | static const struct { | |
344 | const char *expected_string; | ||
345 | const TermStyle style; | ||
346 | } tests[] = { | ||
347 | {"red yellow bold", {COLOR_RED, COLOR_YELLOW, ATTR_BOLD}}, | ||
348 | {"#ff0000", {COLOR_RGB(0xff0000), -1, 0}}, | ||
349 | {"#f00a9c reverse", {COLOR_RGB(0xf00a9c), -1, ATTR_REVERSE}}, | ||
350 | {"black #00ffff", {COLOR_BLACK, COLOR_RGB(0x00ffff), 0}}, | ||
351 | {"#010900", {COLOR_RGB(0x010900), COLOR_DEFAULT, 0}}, | ||
352 | {"red strikethrough", {COLOR_RED, -1, ATTR_STRIKETHROUGH}}, | ||
353 | {"231", {231, COLOR_DEFAULT, 0}}, | ||
354 | {"70 48 italic", {70, 48, ATTR_ITALIC}}, | ||
355 | {"default keep", {COLOR_DEFAULT, COLOR_KEEP, 0}}, | ||
356 | {"keep red keep", {COLOR_KEEP, COLOR_RED, ATTR_KEEP}}, | ||
357 | {"88 16 blink bold", {88, 16, ATTR_BOLD | ATTR_BLINK}}, | ||
358 | {"black 255 underline", {COLOR_BLACK, 255, ATTR_UNDERLINE}}, | ||
359 | {"white green dim", {COLOR_WHITE, COLOR_GREEN, ATTR_DIM}}, | ||
360 | {"darkgray lightgreen", {COLOR_DARKGRAY, COLOR_LIGHTGREEN, 0}}, | ||
361 | {"lightmagenta", {COLOR_LIGHTMAGENTA, COLOR_DEFAULT, 0}}, | ||
362 | {"keep 254 keep", {COLOR_KEEP, 254, ATTR_KEEP}}, | ||
363 | {"default", {COLOR_DEFAULT, COLOR_DEFAULT, 0}}, | ||
364 | {"default bold", {COLOR_DEFAULT, COLOR_DEFAULT, ATTR_BOLD}}, | ||
365 | {"default default keep", {COLOR_DEFAULT, COLOR_DEFAULT, ATTR_KEEP}}, | ||
366 | }; | ||
367 | |||
368 | 1 | char buf[TERM_STYLE_BUFSIZE]; | |
369 |
2/2✓ Branch 0 (6→3) taken 19 times.
✓ Branch 1 (6→7) taken 1 times.
|
20 | FOR_EACH_I(i, tests) { |
370 | 19 | const char *str = term_style_to_string(buf, &tests[i].style); | |
371 | 19 | EXPECT_STREQ(str, tests[i].expected_string); | |
372 | } | ||
373 | |||
374 | // Ensure longest possible color string doesn't overflow the | ||
375 | // static buffer in term_style_to_string() | ||
376 | 1 | const TermStyle style = { | |
377 | .fg = COLOR_LIGHTMAGENTA, | ||
378 | .bg = COLOR_LIGHTMAGENTA, | ||
379 | .attr = ~0U | ||
380 | }; | ||
381 | |||
382 | 1 | static const char expected[] = | |
383 | "lightmagenta lightmagenta " | ||
384 | "keep underline reverse blink dim " | ||
385 | "bold invisible italic strikethrough" | ||
386 | ; | ||
387 | |||
388 | 1 | static_assert(sizeof(expected) - 1 == 94); | |
389 | 1 | const char *str = term_style_to_string(buf, &style); | |
390 | 1 | EXPECT_STREQ(str, expected); | |
391 | 1 | } | |
392 | |||
393 | 1 | static void test_cursor_mode_from_str(TestContext *ctx) | |
394 | { | ||
395 | 1 | EXPECT_EQ(cursor_mode_from_str("default"), CURSOR_MODE_DEFAULT); | |
396 | 1 | EXPECT_EQ(cursor_mode_from_str("insert"), CURSOR_MODE_INSERT); | |
397 | 1 | EXPECT_EQ(cursor_mode_from_str("overwrite"), CURSOR_MODE_OVERWRITE); | |
398 | 1 | EXPECT_EQ(cursor_mode_from_str("cmdline"), CURSOR_MODE_CMDLINE); | |
399 | 1 | EXPECT_EQ(cursor_mode_from_str(""), NR_CURSOR_MODES); | |
400 | 1 | EXPECT_EQ(cursor_mode_from_str("d"), NR_CURSOR_MODES); | |
401 | 1 | EXPECT_EQ(cursor_mode_from_str("defaults"), NR_CURSOR_MODES); | |
402 | 1 | EXPECT_EQ(cursor_mode_from_str("command"), NR_CURSOR_MODES); | |
403 | 1 | } | |
404 | |||
405 | 1 | static void test_cursor_type_from_str(TestContext *ctx) | |
406 | { | ||
407 | 1 | EXPECT_EQ(cursor_type_from_str("default"), CURSOR_DEFAULT); | |
408 | 1 | EXPECT_EQ(cursor_type_from_str("keep"), CURSOR_KEEP); | |
409 | 1 | EXPECT_EQ(cursor_type_from_str("block"), CURSOR_STEADY_BLOCK); | |
410 | 1 | EXPECT_EQ(cursor_type_from_str("bar"), CURSOR_STEADY_BAR); | |
411 | 1 | EXPECT_EQ(cursor_type_from_str("underline"), CURSOR_STEADY_UNDERLINE); | |
412 | 1 | EXPECT_EQ(cursor_type_from_str("blinking-block"), CURSOR_BLINKING_BLOCK); | |
413 | 1 | EXPECT_EQ(cursor_type_from_str("blinking-bar"), CURSOR_BLINKING_BAR); | |
414 | 1 | EXPECT_EQ(cursor_type_from_str("blinking-underline"), CURSOR_BLINKING_UNDERLINE); | |
415 | 1 | EXPECT_EQ(cursor_type_from_str(""), CURSOR_INVALID); | |
416 | 1 | EXPECT_EQ(cursor_type_from_str("b"), CURSOR_INVALID); | |
417 | 1 | EXPECT_EQ(cursor_type_from_str("bars"), CURSOR_INVALID); | |
418 | 1 | EXPECT_EQ(cursor_type_from_str("blinking-default"), CURSOR_INVALID); | |
419 | 1 | EXPECT_EQ(cursor_type_from_str("blinking-keep"), CURSOR_INVALID); | |
420 | 1 | } | |
421 | |||
422 | 1 | static void test_cursor_color_from_str(TestContext *ctx) | |
423 | { | ||
424 | 1 | EXPECT_EQ(cursor_color_from_str("keep"), COLOR_KEEP); | |
425 | 1 | EXPECT_EQ(cursor_color_from_str("default"), COLOR_DEFAULT); | |
426 | 1 | EXPECT_EQ(cursor_color_from_str("#f9a"), COLOR_RGB(0xFF99AA)); | |
427 | 1 | EXPECT_EQ(cursor_color_from_str("#123456"), COLOR_RGB(0x123456)); | |
428 | 1 | EXPECT_EQ(cursor_color_from_str("red"), COLOR_INVALID); | |
429 | 1 | EXPECT_EQ(cursor_color_from_str(""), COLOR_INVALID); | |
430 | 1 | EXPECT_EQ(cursor_color_from_str("#"), COLOR_INVALID); | |
431 | 1 | EXPECT_EQ(cursor_color_from_str("0"), COLOR_INVALID); | |
432 | 1 | EXPECT_EQ(cursor_color_from_str("#12345"), COLOR_INVALID); | |
433 | 1 | EXPECT_EQ(cursor_color_from_str("#1234567"), COLOR_INVALID); | |
434 | 1 | EXPECT_EQ(cursor_color_from_str("123456"), COLOR_INVALID); | |
435 | 1 | } | |
436 | |||
437 | 1 | static void test_cursor_color_to_str(TestContext *ctx) | |
438 | { | ||
439 | 1 | char buf[COLOR_STR_BUFSIZE]; | |
440 | 1 | EXPECT_STREQ(cursor_color_to_str(buf, COLOR_DEFAULT), "default"); | |
441 | 1 | EXPECT_STREQ(cursor_color_to_str(buf, COLOR_KEEP), "keep"); | |
442 | 1 | EXPECT_STREQ(cursor_color_to_str(buf, COLOR_RGB(0x190AFE)), "#190afe"); | |
443 | 1 | } | |
444 | |||
445 | 1 | static void test_same_cursor(TestContext *ctx) | |
446 | { | ||
447 | 1 | TermCursorStyle a = get_default_cursor_style(CURSOR_MODE_DEFAULT); | |
448 | 1 | EXPECT_EQ(a.type, CURSOR_DEFAULT); | |
449 | 1 | EXPECT_EQ(a.color, COLOR_DEFAULT); | |
450 | 1 | EXPECT_TRUE(same_cursor(&a, &a)); | |
451 | |||
452 | 1 | TermCursorStyle b = get_default_cursor_style(CURSOR_MODE_INSERT); | |
453 | 1 | EXPECT_EQ(b.type, CURSOR_KEEP); | |
454 | 1 | EXPECT_EQ(b.color, COLOR_KEEP); | |
455 | 1 | EXPECT_TRUE(same_cursor(&b, &b)); | |
456 | |||
457 | 1 | EXPECT_FALSE(same_cursor(&a, &b)); | |
458 | 1 | b.type = CURSOR_DEFAULT; | |
459 | 1 | EXPECT_FALSE(same_cursor(&a, &b)); | |
460 | 1 | b.color = COLOR_DEFAULT; | |
461 | 1 | EXPECT_TRUE(same_cursor(&a, &b)); | |
462 | 1 | } | |
463 | |||
464 | 1 | static void test_mask_style(TestContext *ctx) | |
465 | { | ||
466 | 1 | const TermStyle keep_all = term_style(COLOR_KEEP, COLOR_KEEP, ATTR_KEEP); | |
467 | 1 | const TermStyle keep_fg = term_style(COLOR_KEEP, 93, ATTR_STRIKETHROUGH); | |
468 | 1 | const TermStyle keep_bg = term_style(241, COLOR_KEEP, ATTR_REVERSE); | |
469 | 1 | const TermStyle a = term_style(COLOR_BLUE, COLOR_CYAN, ATTR_BOLD); | |
470 | 1 | const TermStyle b = term_style(100, 105, ATTR_DIM); | |
471 | |||
472 | 1 | TermStyle style = a; | |
473 | 1 | mask_style(&style, &keep_all); | |
474 | 1 | EXPECT_EQ(style.fg, a.fg); | |
475 | 1 | EXPECT_EQ(style.bg, a.bg); | |
476 | 1 | EXPECT_EQ(style.attr, a.attr); | |
477 | 1 | EXPECT_TRUE(same_style(&style, &a)); | |
478 | |||
479 | 1 | style = a; | |
480 | 1 | mask_style(&style, &keep_bg); | |
481 | 1 | EXPECT_EQ(style.fg, keep_bg.fg); | |
482 | 1 | EXPECT_EQ(style.bg, a.bg); | |
483 | 1 | EXPECT_EQ(style.attr, keep_bg.attr); | |
484 | |||
485 | 1 | style = a; | |
486 | 1 | mask_style(&style, &keep_fg); | |
487 | 1 | EXPECT_EQ(style.fg, a.fg); | |
488 | 1 | EXPECT_EQ(style.bg, keep_fg.bg); | |
489 | 1 | EXPECT_EQ(style.attr, keep_fg.attr); | |
490 | |||
491 | 1 | style = a; | |
492 | 1 | mask_style2(&style, &b, false); | |
493 | 1 | EXPECT_EQ(style.bg, a.bg); | |
494 | |||
495 | 1 | style = a; | |
496 | 1 | mask_style2(&style, &b, true); | |
497 | 1 | EXPECT_EQ(style.bg, b.bg); | |
498 | |||
499 | 1 | style = a; | |
500 | 1 | mask_style2(&style, &keep_bg, true); | |
501 | 1 | EXPECT_EQ(style.bg, a.bg); | |
502 | |||
503 | 1 | style = a; | |
504 | 1 | mask_style2(&style, &keep_bg, false); | |
505 | 1 | EXPECT_EQ(style.bg, a.bg); | |
506 | 1 | } | |
507 | |||
508 | 1 | static void test_term_parse_csi_params(TestContext *ctx) | |
509 | { | ||
510 | 1 | TermControlParams csi = {.nparams = 0}; | |
511 | 1 | StringView s = STRING_VIEW("\033[901;0;55mx"); | |
512 | 1 | size_t n = term_parse_csi_params(s.data, s.length, 2, &csi); | |
513 | 1 | EXPECT_EQ(n, s.length - 1); | |
514 | 1 | EXPECT_EQ(csi.nparams, 3); | |
515 | 1 | EXPECT_EQ(csi.params[0][0], 901); | |
516 | 1 | EXPECT_EQ(csi.params[1][0], 0); | |
517 | 1 | EXPECT_EQ(csi.params[2][0], 55); | |
518 | 1 | EXPECT_EQ(csi.nr_intermediate, 0); | |
519 | 1 | EXPECT_EQ(csi.final_byte, 'm'); | |
520 | 1 | EXPECT_FALSE(csi.have_subparams); | |
521 | 1 | EXPECT_FALSE(csi.unhandled_bytes); | |
522 | |||
523 | 1 | csi = (TermControlParams){.nparams = 0}; | |
524 | 1 | s = strview("\033[123;09;56:78:99m"); | |
525 | 1 | n = term_parse_csi_params(s.data, s.length, 2, &csi); | |
526 | 1 | EXPECT_EQ(n, s.length); | |
527 | 1 | EXPECT_EQ(csi.nparams, 3); | |
528 | 1 | static_assert(ARRAYLEN(csi.nsub) >= 4); | |
529 | 1 | static_assert(ARRAYLEN(csi.nsub) == ARRAYLEN(csi.params)); | |
530 | 1 | EXPECT_EQ(csi.nsub[0], 1); | |
531 | 1 | EXPECT_EQ(csi.nsub[1], 1); | |
532 | 1 | EXPECT_EQ(csi.nsub[2], 3); | |
533 | 1 | EXPECT_EQ(csi.nsub[3], 0); | |
534 | 1 | EXPECT_EQ(csi.params[0][0], 123); | |
535 | 1 | EXPECT_EQ(csi.params[1][0], 9); | |
536 | 1 | EXPECT_EQ(csi.params[2][0], 56); | |
537 | 1 | EXPECT_EQ(csi.params[2][1], 78); | |
538 | 1 | EXPECT_EQ(csi.params[2][2], 99); | |
539 | 1 | EXPECT_EQ(csi.params[3][0], 0); | |
540 | 1 | EXPECT_EQ(csi.nr_intermediate, 0); | |
541 | 1 | EXPECT_EQ(csi.final_byte, 'm'); | |
542 | 1 | EXPECT_TRUE(csi.have_subparams); | |
543 | 1 | EXPECT_FALSE(csi.unhandled_bytes); | |
544 | |||
545 | 1 | csi = (TermControlParams){.nparams = 0}; | |
546 | 1 | s = strview("\033[1:2:3;44:55;;6~"); | |
547 | 1 | n = term_parse_csi_params(s.data, s.length, 2, &csi); | |
548 | 1 | EXPECT_EQ(n, s.length); | |
549 | 1 | EXPECT_EQ(csi.nparams, 4); | |
550 | 1 | EXPECT_EQ(csi.nsub[0], 3); | |
551 | 1 | EXPECT_EQ(csi.nsub[1], 2); | |
552 | 1 | EXPECT_EQ(csi.nsub[2], 1); | |
553 | 1 | EXPECT_EQ(csi.params[0][0], 1); | |
554 | 1 | EXPECT_EQ(csi.params[0][1], 2); | |
555 | 1 | EXPECT_EQ(csi.params[0][2], 3); | |
556 | 1 | EXPECT_EQ(csi.params[1][0], 44); | |
557 | 1 | EXPECT_EQ(csi.params[1][1], 55); | |
558 | 1 | EXPECT_EQ(csi.params[2][0], 0); | |
559 | 1 | EXPECT_EQ(csi.params[3][0], 6); | |
560 | 1 | EXPECT_EQ(csi.nr_intermediate, 0); | |
561 | 1 | EXPECT_EQ(csi.final_byte, '~'); | |
562 | 1 | EXPECT_TRUE(csi.have_subparams); | |
563 | 1 | EXPECT_FALSE(csi.unhandled_bytes); | |
564 | |||
565 | 1 | csi = (TermControlParams){.nparams = 0}; | |
566 | 1 | s = strview("\033[+2p"); | |
567 | 1 | n = term_parse_csi_params(s.data, s.length, 2, &csi); | |
568 | 1 | EXPECT_EQ(n, s.length); | |
569 | 1 | EXPECT_EQ(csi.nparams, 1); | |
570 | 1 | EXPECT_EQ(csi.nsub[0], 1); | |
571 | 1 | EXPECT_EQ(csi.params[0][0], 2); | |
572 | 1 | EXPECT_EQ(csi.nr_intermediate, 1); | |
573 | 1 | EXPECT_EQ(csi.intermediate[0], '+'); | |
574 | 1 | EXPECT_EQ(csi.final_byte, 'p'); | |
575 | 1 | EXPECT_FALSE(csi.have_subparams); | |
576 | 1 | EXPECT_FALSE(csi.unhandled_bytes); | |
577 | |||
578 | 1 | csi = (TermControlParams){.nparams = 0}; | |
579 | 1 | s = strview("\033[?47;1$y"); | |
580 | 1 | n = term_parse_csi_params(s.data, s.length, 2, &csi); | |
581 | 1 | EXPECT_EQ(n, s.length); | |
582 | 1 | EXPECT_EQ(csi.nparams, 2); | |
583 | 1 | EXPECT_EQ(csi.params[0][0], 47); | |
584 | 1 | EXPECT_EQ(csi.params[1][0], 1); | |
585 | 1 | EXPECT_EQ(csi.nr_intermediate, 1); | |
586 | 1 | EXPECT_EQ(csi.intermediate[0], '$'); | |
587 | 1 | EXPECT_FALSE(csi.have_subparams); | |
588 | // Note: question mark param prefixes are handled in parse_csi() instead | ||
589 | // of term_parse_csi_params(), so the latter reports it as an unhandled byte | ||
590 | 1 | EXPECT_TRUE(csi.unhandled_bytes); | |
591 | 1 | } | |
592 | |||
593 | 1 | static void test_term_parse_sequence(TestContext *ctx) | |
594 | { | ||
595 | 1 | EXPECT_PARSE_SEQ("", 0); | |
596 | 1 | EXPECT_PARSE_SEQN("x", 0, 0); | |
597 | 1 | EXPECT_PARSE_SEQN("\033q", 0, 0); | |
598 | 1 | EXPECT_PARSE_SEQ("\033\\", KEY_IGNORE); | |
599 | |||
600 | 1 | EXPECT_PARSE_SEQ("\033[Z", MOD_SHIFT | KEY_TAB); | |
601 | 1 | EXPECT_PARSE_SEQ("\033[1;2A", MOD_SHIFT | KEY_UP); | |
602 | 1 | EXPECT_PARSE_SEQ("\033[1;2B", MOD_SHIFT | KEY_DOWN); | |
603 | 1 | EXPECT_PARSE_SEQ("\033[1;2C", MOD_SHIFT | KEY_RIGHT); | |
604 | 1 | EXPECT_PARSE_SEQ("\033[1;2D", MOD_SHIFT | KEY_LEFT); | |
605 | 1 | EXPECT_PARSE_SEQ("\033[1;2E", MOD_SHIFT | KEY_BEGIN); | |
606 | 1 | EXPECT_PARSE_SEQ("\033[1;2F", MOD_SHIFT | KEY_END); | |
607 | 1 | EXPECT_PARSE_SEQ("\033[1;2H", MOD_SHIFT | KEY_HOME); | |
608 | 1 | EXPECT_PARSE_SEQ("\033[1;8H", MOD_SHIFT | MOD_META | MOD_CTRL | KEY_HOME); | |
609 | 1 | EXPECT_PARSE_SEQN("\033[1;8H~", 6, MOD_SHIFT | MOD_META | MOD_CTRL | KEY_HOME); | |
610 | 1 | EXPECT_PARSE_SEQN("\033[1;8H~_", 6, MOD_SHIFT | MOD_META | MOD_CTRL | KEY_HOME); | |
611 | 1 | EXPECT_PARSE_SEQN("\033", TPARSE_PARTIAL_MATCH, 0); | |
612 | 1 | EXPECT_PARSE_SEQN("\033[", TPARSE_PARTIAL_MATCH, 0); | |
613 | 1 | EXPECT_PARSE_SEQN("\033]", TPARSE_PARTIAL_MATCH, 0); | |
614 | 1 | EXPECT_PARSE_SEQN("\033[1", TPARSE_PARTIAL_MATCH, 0); | |
615 | 1 | EXPECT_PARSE_SEQN("\033[9", TPARSE_PARTIAL_MATCH, 0); | |
616 | 1 | EXPECT_PARSE_SEQN("\033[1;", TPARSE_PARTIAL_MATCH, 0); | |
617 | 1 | EXPECT_PARSE_SEQN("\033[1[", 4, KEY_IGNORE); | |
618 | 1 | EXPECT_PARSE_SEQN("\033[1;2", TPARSE_PARTIAL_MATCH, 0); | |
619 | 1 | EXPECT_PARSE_SEQN("\033[1;8", TPARSE_PARTIAL_MATCH, 0); | |
620 | 1 | EXPECT_PARSE_SEQN("\033[1;9", TPARSE_PARTIAL_MATCH, 0); | |
621 | 1 | EXPECT_PARSE_SEQ("\033[1;_", KEY_IGNORE); | |
622 | 1 | EXPECT_PARSE_SEQ("\033[1;8Z", KEY_IGNORE); | |
623 | 1 | EXPECT_PARSE_SEQN("\033O", TPARSE_PARTIAL_MATCH, 0); | |
624 | 1 | EXPECT_PARSE_SEQN("\033[\033", 2, KEY_IGNORE); | |
625 | 1 | EXPECT_PARSE_SEQN("\033[\030", 3, KEY_IGNORE); | |
626 | 1 | EXPECT_PARSE_SEQN("\033[1\030;2A", 4, KEY_IGNORE); // Cancelled by CAN | |
627 | 1 | EXPECT_PARSE_SEQN("\033[1\031;2A", 7, MOD_SHIFT | KEY_UP); // EM ignored | |
628 | 1 | EXPECT_PARSE_SEQN("\033[1\032;2A", 4, KEY_IGNORE); // Cancelled by SUB | |
629 | 1 | EXPECT_PARSE_SEQN("\033[1\033;2A", 3, KEY_IGNORE); // Cancelled by (unconsumed) ESC | |
630 | 1 | EXPECT_PARSE_SEQN("\033[1\177;2A", 7, MOD_SHIFT | KEY_UP); // DEL ignored | |
631 | 1 | EXPECT_PARSE_SEQ("\033[A", KEY_UP); | |
632 | 1 | EXPECT_PARSE_SEQ("\033[B", KEY_DOWN); | |
633 | 1 | EXPECT_PARSE_SEQ("\033[C", KEY_RIGHT); | |
634 | 1 | EXPECT_PARSE_SEQ("\033[D", KEY_LEFT); | |
635 | 1 | EXPECT_PARSE_SEQ("\033[E", KEY_BEGIN); | |
636 | 1 | EXPECT_PARSE_SEQ("\033[F", KEY_END); | |
637 | 1 | EXPECT_PARSE_SEQ("\033[H", KEY_HOME); | |
638 | 1 | EXPECT_PARSE_SEQ("\033[L", KEY_INSERT); | |
639 | 1 | EXPECT_PARSE_SEQ("\033[P", KEY_F1); | |
640 | 1 | EXPECT_PARSE_SEQ("\033[Q", KEY_F2); | |
641 | 1 | EXPECT_PARSE_SEQ("\033[R", KEY_F3); | |
642 | 1 | EXPECT_PARSE_SEQ("\033[S", KEY_F4); | |
643 | 1 | EXPECT_PARSE_SEQ("\033O ", KEY_SPACE); | |
644 | 1 | EXPECT_PARSE_SEQ("\033OA", KEY_UP); | |
645 | 1 | EXPECT_PARSE_SEQ("\033OB", KEY_DOWN); | |
646 | 1 | EXPECT_PARSE_SEQ("\033OC", KEY_RIGHT); | |
647 | 1 | EXPECT_PARSE_SEQ("\033OD", KEY_LEFT); | |
648 | 1 | EXPECT_PARSE_SEQ("\033OE", KEY_BEGIN); | |
649 | 1 | EXPECT_PARSE_SEQ("\033OF", KEY_END); | |
650 | 1 | EXPECT_PARSE_SEQ("\033OH", KEY_HOME); | |
651 | 1 | EXPECT_PARSE_SEQ("\033OI", KEY_TAB); | |
652 | 1 | EXPECT_PARSE_SEQ("\033OJ", KEY_IGNORE); | |
653 | 1 | EXPECT_PARSE_SEQ("\033OM", KEY_ENTER); | |
654 | 1 | EXPECT_PARSE_SEQ("\033OP", KEY_F1); | |
655 | 1 | EXPECT_PARSE_SEQ("\033OQ", KEY_F2); | |
656 | 1 | EXPECT_PARSE_SEQ("\033OR", KEY_F3); | |
657 | 1 | EXPECT_PARSE_SEQ("\033OS", KEY_F4); | |
658 | 1 | EXPECT_PARSE_SEQ("\033OT", KEY_IGNORE); | |
659 | 1 | EXPECT_PARSE_SEQ("\033OX", '='); | |
660 | 1 | EXPECT_PARSE_SEQ("\033Oi", KEY_IGNORE); | |
661 | 1 | EXPECT_PARSE_SEQ("\033Oj", '*'); | |
662 | 1 | EXPECT_PARSE_SEQ("\033Ok", '+'); | |
663 | 1 | EXPECT_PARSE_SEQ("\033Ol", ','); | |
664 | 1 | EXPECT_PARSE_SEQ("\033Om", '-'); | |
665 | 1 | EXPECT_PARSE_SEQ("\033On", '.'); | |
666 | 1 | EXPECT_PARSE_SEQ("\033Oo", '/'); | |
667 | 1 | EXPECT_PARSE_SEQ("\033Op", '0'); | |
668 | 1 | EXPECT_PARSE_SEQ("\033Oq", '1'); | |
669 | 1 | EXPECT_PARSE_SEQ("\033Or", '2'); | |
670 | 1 | EXPECT_PARSE_SEQ("\033Os", '3'); | |
671 | 1 | EXPECT_PARSE_SEQ("\033Ot", '4'); | |
672 | 1 | EXPECT_PARSE_SEQ("\033Ou", '5'); | |
673 | 1 | EXPECT_PARSE_SEQ("\033Ov", '6'); | |
674 | 1 | EXPECT_PARSE_SEQ("\033Ow", '7'); | |
675 | 1 | EXPECT_PARSE_SEQ("\033Ox", '8'); | |
676 | 1 | EXPECT_PARSE_SEQ("\033Oy", '9'); | |
677 | 1 | EXPECT_PARSE_SEQ("\033Oz", KEY_IGNORE); | |
678 | 1 | EXPECT_PARSE_SEQ("\033O~", KEY_IGNORE); | |
679 | 1 | EXPECT_PARSE_SEQ("\033[1~", KEY_HOME); | |
680 | 1 | EXPECT_PARSE_SEQ("\033[2~", KEY_INSERT); | |
681 | 1 | EXPECT_PARSE_SEQ("\033[3~", KEY_DELETE); | |
682 | 1 | EXPECT_PARSE_SEQ("\033[4~", KEY_END); | |
683 | 1 | EXPECT_PARSE_SEQ("\033[5~", KEY_PAGE_UP); | |
684 | 1 | EXPECT_PARSE_SEQ("\033[6~", KEY_PAGE_DOWN); | |
685 | 1 | EXPECT_PARSE_SEQ("\033[7~", KEY_HOME); | |
686 | 1 | EXPECT_PARSE_SEQ("\033[8~", KEY_END); | |
687 | 1 | EXPECT_PARSE_SEQ("\033[10~", KEY_IGNORE); | |
688 | 1 | EXPECT_PARSE_SEQ("\033[11~", KEY_F1); | |
689 | 1 | EXPECT_PARSE_SEQ("\033[12~", KEY_F2); | |
690 | 1 | EXPECT_PARSE_SEQ("\033[13~", KEY_F3); | |
691 | 1 | EXPECT_PARSE_SEQ("\033[14~", KEY_F4); | |
692 | 1 | EXPECT_PARSE_SEQ("\033[15~", KEY_F5); | |
693 | 1 | EXPECT_PARSE_SEQ("\033[16~", KEY_IGNORE); | |
694 | 1 | EXPECT_PARSE_SEQ("\033[17~", KEY_F6); | |
695 | 1 | EXPECT_PARSE_SEQ("\033[18~", KEY_F7); | |
696 | 1 | EXPECT_PARSE_SEQ("\033[19~", KEY_F8); | |
697 | 1 | EXPECT_PARSE_SEQ("\033[20~", KEY_F9); | |
698 | 1 | EXPECT_PARSE_SEQ("\033[21~", KEY_F10); | |
699 | 1 | EXPECT_PARSE_SEQ("\033[22~", KEY_IGNORE); | |
700 | 1 | EXPECT_PARSE_SEQ("\033[23~", KEY_F11); | |
701 | 1 | EXPECT_PARSE_SEQ("\033[24~", KEY_F12); | |
702 | 1 | EXPECT_PARSE_SEQ("\033[25~", KEY_F13); | |
703 | 1 | EXPECT_PARSE_SEQ("\033[26~", KEY_F14); | |
704 | 1 | EXPECT_PARSE_SEQ("\033[27~", KEY_IGNORE); | |
705 | 1 | EXPECT_PARSE_SEQ("\033[28~", KEY_F15); | |
706 | 1 | EXPECT_PARSE_SEQ("\033[29~", KEY_F16); | |
707 | 1 | EXPECT_PARSE_SEQ("\033[30~", KEY_IGNORE); | |
708 | 1 | EXPECT_PARSE_SEQ("\033[31~", KEY_F17); | |
709 | 1 | EXPECT_PARSE_SEQ("\033[34~", KEY_F20); | |
710 | 1 | EXPECT_PARSE_SEQ("\033[35~", KEY_IGNORE); | |
711 | 1 | EXPECT_PARSE_SEQ("\033[6;3~", MOD_META | KEY_PAGE_DOWN); | |
712 | 1 | EXPECT_PARSE_SEQ("\033[6;5~", MOD_CTRL | KEY_PAGE_DOWN); | |
713 | 1 | EXPECT_PARSE_SEQ("\033[6;8~", MOD_SHIFT | MOD_META | MOD_CTRL | KEY_PAGE_DOWN); | |
714 | |||
715 | // xterm + `modifyOtherKeys` option | ||
716 | 1 | EXPECT_PARSE_SEQ("\033[27;5;9~", MOD_CTRL | KEY_TAB); | |
717 | 1 | EXPECT_PARSE_SEQ("\033[27;5;27~", MOD_CTRL | KEY_ESCAPE); | |
718 | 1 | EXPECT_PARSE_SEQ("\033[27;8;27~", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_ESCAPE); | |
719 | 1 | EXPECT_PARSE_SEQ("\033[27;1;27~", KEY_ESCAPE); // Tested in principle only; xterm never sends this | |
720 | 1 | EXPECT_PARSE_SEQ("\033[27;5;13~", MOD_CTRL | KEY_ENTER); | |
721 | 1 | EXPECT_PARSE_SEQ("\033[27;6;13~", MOD_CTRL | MOD_SHIFT | KEY_ENTER); | |
722 | 1 | EXPECT_PARSE_SEQ("\033[27;2;127~", MOD_SHIFT | KEY_BACKSPACE); | |
723 | 1 | EXPECT_PARSE_SEQ("\033[27;6;127~", MOD_CTRL | MOD_SHIFT | KEY_BACKSPACE); | |
724 | 1 | EXPECT_PARSE_SEQ("\033[27;8;127~", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_BACKSPACE); | |
725 | 1 | EXPECT_PARSE_SEQ("\033[27;2;8~", MOD_SHIFT | KEY_BACKSPACE); | |
726 | 1 | EXPECT_PARSE_SEQ("\033[27;6;8~", MOD_CTRL | MOD_SHIFT | KEY_BACKSPACE); | |
727 | 1 | EXPECT_PARSE_SEQ("\033[27;8;8~", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_BACKSPACE); | |
728 | 1 | EXPECT_PARSE_SEQ("\033[27;6;82~", MOD_CTRL | MOD_SHIFT | 'r'); | |
729 | 1 | EXPECT_PARSE_SEQ("\033[27;5;114~", MOD_CTRL | 'r'); | |
730 | 1 | EXPECT_PARSE_SEQ("\033[27;3;82~", MOD_META | MOD_SHIFT | 'r'); // Sent by tmux 3.5-76-gbbc3cc55 (xterm sends "\033[27;4;82~") | |
731 | 1 | EXPECT_PARSE_SEQ("\033[27;3;114~", MOD_META | 'r'); | |
732 | // EXPECT_PARSE_SEQ("\033[27;4;62~", MOD_META | '>'); | ||
733 | 1 | EXPECT_PARSE_SEQ("\033[27;5;46~", MOD_CTRL | '.'); | |
734 | 1 | EXPECT_PARSE_SEQ("\033[27;3;1114111~", MOD_META | UNICODE_MAX_VALID_CODEPOINT); | |
735 | 1 | EXPECT_PARSE_SEQ("\033[27;3;1114112~", KEY_IGNORE); | |
736 | 1 | EXPECT_PARSE_SEQ("\033[27;999999999999999999999;123~", KEY_IGNORE); | |
737 | 1 | EXPECT_PARSE_SEQ("\033[27;123;99999999999999999~", KEY_IGNORE); | |
738 | |||
739 | // www.leonerd.org.uk/hacks/fixterms/ | ||
740 | 1 | EXPECT_PARSE_SEQ("\033[13;3u", MOD_META | KEY_ENTER); | |
741 | 1 | EXPECT_PARSE_SEQ("\033[9;5u", MOD_CTRL | KEY_TAB); | |
742 | 1 | EXPECT_PARSE_SEQ("\033[65;3u", MOD_META | 'A'); | |
743 | 1 | EXPECT_PARSE_SEQ("\033[108;5u", MOD_CTRL | 'l'); | |
744 | 1 | EXPECT_PARSE_SEQ("\033[127765;3u", MOD_META | 127765ul); | |
745 | 1 | EXPECT_PARSE_SEQ("\033[1114111;3u", MOD_META | UNICODE_MAX_VALID_CODEPOINT); | |
746 | 1 | EXPECT_PARSE_SEQ("\033[1114112;3u", KEY_IGNORE); | |
747 | 1 | EXPECT_PARSE_SEQ("\033[11141110;3u", KEY_IGNORE); | |
748 | 1 | EXPECT_PARSE_SEQ("\033[11141111;3u", KEY_IGNORE); | |
749 | 1 | EXPECT_PARSE_SEQ("\033[2147483647;3u", KEY_IGNORE); // INT32_MAX | |
750 | 1 | EXPECT_PARSE_SEQ("\033[2147483648;3u", KEY_IGNORE); // INT32_MAX + 1 | |
751 | 1 | EXPECT_PARSE_SEQ("\033[4294967295;3u", KEY_IGNORE); // UINT32_MAX | |
752 | 1 | EXPECT_PARSE_SEQ("\033[4294967296;3u", KEY_IGNORE); // UINT32_MAX + 1 | |
753 | 1 | EXPECT_PARSE_SEQ("\033[-1;3u", KEY_IGNORE); | |
754 | 1 | EXPECT_PARSE_SEQ("\033[-2;3u", KEY_IGNORE); | |
755 | 1 | EXPECT_PARSE_SEQ("\033[ 2;3u", KEY_IGNORE); | |
756 | 1 | EXPECT_PARSE_SEQ("\033[<?>2;3u", KEY_IGNORE); | |
757 | 1 | EXPECT_PARSE_SEQ("\033[ !//.$2;3u", KEY_IGNORE); | |
758 | |||
759 | // https://sw.kovidgoyal.net/kitty/keyboard-protocol | ||
760 | 1 | EXPECT_PARSE_SEQ("\033[27u", KEY_ESCAPE); | |
761 | 1 | EXPECT_PARSE_SEQ("\033[27;5u", MOD_CTRL | KEY_ESCAPE); | |
762 | 1 | EXPECT_PARSE_SEQ("\033[27;8u", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_ESCAPE); | |
763 | 1 | EXPECT_PARSE_SEQ("\033[57359u", KEY_SCROLL_LOCK); | |
764 | 1 | EXPECT_PARSE_SEQ("\033[57360u", KEY_IGNORE); | |
765 | 1 | EXPECT_PARSE_SEQ("\033[57361u", KEY_PRINT_SCREEN); | |
766 | 1 | EXPECT_PARSE_SEQ("\033[57362u", KEY_PAUSE); | |
767 | 1 | EXPECT_PARSE_SEQ("\033[57363u", KEY_MENU); | |
768 | 1 | EXPECT_PARSE_SEQ("\033[57376u", KEY_F13); | |
769 | 1 | EXPECT_PARSE_SEQ("\033[57377u", KEY_F14); | |
770 | 1 | EXPECT_PARSE_SEQ("\033[57378u", KEY_F15); | |
771 | 1 | EXPECT_PARSE_SEQ("\033[57379u", KEY_F16); | |
772 | 1 | EXPECT_PARSE_SEQ("\033[57380u", KEY_F17); | |
773 | 1 | EXPECT_PARSE_SEQ("\033[57381u", KEY_F18); | |
774 | 1 | EXPECT_PARSE_SEQ("\033[57382u", KEY_F19); | |
775 | 1 | EXPECT_PARSE_SEQ("\033[57383u", KEY_F20); | |
776 | 1 | EXPECT_PARSE_SEQ("\033[57384u", KEY_F21); | |
777 | 1 | EXPECT_PARSE_SEQ("\033[57385u", KEY_F22); | |
778 | 1 | EXPECT_PARSE_SEQ("\033[57386u", KEY_F23); | |
779 | 1 | EXPECT_PARSE_SEQ("\033[57387u", KEY_F24); | |
780 | 1 | EXPECT_PARSE_SEQ("\033[57388u", KEY_IGNORE); // F25 | |
781 | 1 | EXPECT_PARSE_SEQ("\033[57389u", KEY_IGNORE); // F26 | |
782 | 1 | EXPECT_PARSE_SEQ("\033[57390u", KEY_IGNORE); // F27 | |
783 | 1 | EXPECT_PARSE_SEQ("\033[57391u", KEY_IGNORE); // F28 | |
784 | 1 | EXPECT_PARSE_SEQ("\033[57392u", KEY_IGNORE); // F29 | |
785 | 1 | EXPECT_PARSE_SEQ("\033[57393u", KEY_IGNORE); // F30 | |
786 | 1 | EXPECT_PARSE_SEQ("\033[57394u", KEY_IGNORE); // F31 | |
787 | 1 | EXPECT_PARSE_SEQ("\033[57395u", KEY_IGNORE); // F32 | |
788 | 1 | EXPECT_PARSE_SEQ("\033[57396u", KEY_IGNORE); // F33 | |
789 | 1 | EXPECT_PARSE_SEQ("\033[57397u", KEY_IGNORE); // F34 | |
790 | 1 | EXPECT_PARSE_SEQ("\033[57398u", KEY_IGNORE); // F35 | |
791 | 1 | EXPECT_PARSE_SEQ("\033[57399u", '0'); | |
792 | 1 | EXPECT_PARSE_SEQ("\033[57400u", '1'); | |
793 | 1 | EXPECT_PARSE_SEQ("\033[57401u", '2'); | |
794 | 1 | EXPECT_PARSE_SEQ("\033[57402u", '3'); | |
795 | 1 | EXPECT_PARSE_SEQ("\033[57403u", '4'); | |
796 | 1 | EXPECT_PARSE_SEQ("\033[57404u", '5'); | |
797 | 1 | EXPECT_PARSE_SEQ("\033[57405u", '6'); | |
798 | 1 | EXPECT_PARSE_SEQ("\033[57406u", '7'); | |
799 | 1 | EXPECT_PARSE_SEQ("\033[57407u", '8'); | |
800 | 1 | EXPECT_PARSE_SEQ("\033[57408u", '9'); | |
801 | 1 | EXPECT_PARSE_SEQ("\033[57409u", '.'); | |
802 | 1 | EXPECT_PARSE_SEQ("\033[57410u", '/'); | |
803 | 1 | EXPECT_PARSE_SEQ("\033[57411u", '*'); | |
804 | 1 | EXPECT_PARSE_SEQ("\033[57412u", '-'); | |
805 | 1 | EXPECT_PARSE_SEQ("\033[57413u", '+'); | |
806 | 1 | EXPECT_PARSE_SEQ("\033[57414u", KEY_ENTER); | |
807 | 1 | EXPECT_PARSE_SEQ("\033[57415u", '='); | |
808 | 1 | EXPECT_PARSE_SEQ("\033[57416u", KEY_IGNORE); // KP_SEPARATOR | |
809 | 1 | EXPECT_PARSE_SEQ("\033[57417u", KEY_LEFT); | |
810 | 1 | EXPECT_PARSE_SEQ("\033[57418u", KEY_RIGHT); | |
811 | 1 | EXPECT_PARSE_SEQ("\033[57419u", KEY_UP); | |
812 | 1 | EXPECT_PARSE_SEQ("\033[57420u", KEY_DOWN); | |
813 | 1 | EXPECT_PARSE_SEQ("\033[57421u", KEY_PAGE_UP); | |
814 | 1 | EXPECT_PARSE_SEQ("\033[57422u", KEY_PAGE_DOWN); | |
815 | 1 | EXPECT_PARSE_SEQ("\033[57423u", KEY_HOME); | |
816 | 1 | EXPECT_PARSE_SEQ("\033[57424u", KEY_END); | |
817 | 1 | EXPECT_PARSE_SEQ("\033[57425u", KEY_INSERT); | |
818 | 1 | EXPECT_PARSE_SEQ("\033[57426u", KEY_DELETE); | |
819 | 1 | EXPECT_PARSE_SEQ("\033[57427u", KEY_BEGIN); | |
820 | 1 | EXPECT_PARSE_SEQ("\033[57361;2u", MOD_SHIFT | KEY_PRINT_SCREEN); | |
821 | 1 | EXPECT_PARSE_SEQ("\033[3615:3620:97;6u", MOD_CTRL | MOD_SHIFT | 'a'); | |
822 | 1 | EXPECT_PARSE_SEQ("\033[97;5u", MOD_CTRL | 'a'); | |
823 | 1 | EXPECT_PARSE_SEQ("\033[97;5:1u", MOD_CTRL | 'a'); | |
824 | 1 | EXPECT_PARSE_SEQ("\033[97;5:2u", MOD_CTRL | 'a'); | |
825 | 1 | EXPECT_PARSE_SEQ("\033[97;5:3u", KEY_IGNORE); | |
826 | // TODO: EXPECT_PARSE_SEQ("\033[97;5:u", MOD_CTRL | 'a'); | ||
827 | 1 | EXPECT_PARSE_SEQ("\033[104;5u", MOD_CTRL | 'h'); | |
828 | 1 | EXPECT_PARSE_SEQ("\033[104;9u", MOD_SUPER | 'h'); | |
829 | 1 | EXPECT_PARSE_SEQ("\033[104;17u", MOD_HYPER | 'h'); | |
830 | 1 | EXPECT_PARSE_SEQ("\033[104;10u", MOD_SUPER | MOD_SHIFT | 'h'); | |
831 | 1 | EXPECT_PARSE_SEQ("\033[116;69u", MOD_CTRL | 't'); // Ignored Capslock in modifiers | |
832 | 1 | EXPECT_PARSE_SEQ("\033[116;133u", MOD_CTRL | 't'); // Ignored Numlock in modifiers | |
833 | 1 | EXPECT_PARSE_SEQ("\033[116;256u", MOD_MASK | 't'); // Ignored Capslock and Numlock | |
834 | 1 | EXPECT_PARSE_SEQ("\033[116;257u", KEY_IGNORE); // Unknown bit in modifiers | |
835 | |||
836 | // Excess params | ||
837 | 1 | EXPECT_PARSE_SEQ("\033[1;2;3;4;5;6;7;8;9m", KEY_IGNORE); | |
838 | |||
839 | // DA1 replies | ||
840 | 1 | EXPECT_PARSE_SEQ("\033[?64;15;22c", TFLAG(TFLAG_QUERY_L2 | TFLAG_QUERY_L3 | TFLAG_8_COLOR)); | |
841 | 1 | EXPECT_PARSE_SEQ("\033[?1;2c", TFLAG(TFLAG_QUERY_L2)); | |
842 | 1 | EXPECT_PARSE_SEQ("\033[?90c", KEY_IGNORE); | |
843 | |||
844 | // DA2 replies | ||
845 | 1 | EXPECT_PARSE_SEQ("\033[>0;136;0c", KEY_IGNORE); | |
846 | 1 | EXPECT_PARSE_SEQ("\033[>84;0;0c", TFLAG(TFLAG_QUERY_L3)); // tmux | |
847 | 1 | EXPECT_PARSE_SEQ("\033[>1;11801;0c", TFLAG(TFLAG_QUERY_L3)); // foot | |
848 | |||
849 | // DA3 replies | ||
850 | 1 | EXPECT_PARSE_SEQN("\033P!|464f4f54\033\\", 12, TFLAG(TFLAG_QUERY_L3)); // foot | |
851 | 1 | EXPECT_PARSE_SEQN("\033P!|464f4f54\033", 12, TFLAG(TFLAG_QUERY_L3)); | |
852 | 1 | EXPECT_PARSE_SEQN("\033P!|464f4f54", TPARSE_PARTIAL_MATCH, 0); | |
853 | |||
854 | // XTVERSION replies | ||
855 | 1 | const TermFeatureFlags tmuxflags = TFLAG ( | |
856 | TFLAG_NO_QUERY_L3 | TFLAG_ECMA48_REPEAT | TFLAG_MODIFY_OTHER_KEYS | ||
857 | | TFLAG_BS_CTRL_BACKSPACE | ||
858 | ); | ||
859 | 1 | EXPECT_PARSE_SEQN("\033P>|tmux 3.2\033\\", 12, tmuxflags); | |
860 | 1 | EXPECT_PARSE_SEQN("\033P>|tmux 3.2a\033\\", 13, tmuxflags); | |
861 | 1 | EXPECT_PARSE_SEQN("\033P>|tmux 3.2-rc2\033\\", 16, tmuxflags); | |
862 | 1 | EXPECT_PARSE_SEQN("\033P>|tmux next-3.3\033\\", 17, tmuxflags); | |
863 | 1 | EXPECT_PARSE_SEQN("\033P>|xyz\033\\", 7, TFLAG(TFLAG_QUERY_L3)); | |
864 | |||
865 | // XTMODKEYS (modifyOtherKeys mode query) replies | ||
866 | 1 | EXPECT_PARSE_SEQ("\033[>4;0m", TFLAG(TFLAG_MODIFY_OTHER_KEYS)); | |
867 | 1 | EXPECT_PARSE_SEQ("\033[>4;1m", TFLAG(TFLAG_MODIFY_OTHER_KEYS)); | |
868 | 1 | EXPECT_PARSE_SEQ("\033[>4;2m", TFLAG(TFLAG_MODIFY_OTHER_KEYS)); | |
869 | 1 | EXPECT_PARSE_SEQ("\033[>4;3m", KEY_IGNORE); | |
870 | 1 | EXPECT_PARSE_SEQ("\033[>4;m", TFLAG(TFLAG_MODIFY_OTHER_KEYS)); | |
871 | 1 | EXPECT_PARSE_SEQ("\033[>4m", TFLAG(TFLAG_MODIFY_OTHER_KEYS)); | |
872 | 1 | EXPECT_PARSE_SEQ("\033[>4;2;0m", KEY_IGNORE); | |
873 | |||
874 | // XTWINOPS replies | ||
875 | 1 | EXPECT_PARSE_SEQN("\033]ltitle\033\\", 8, KEY_IGNORE); | |
876 | 1 | EXPECT_PARSE_SEQN("\033]Licon\033\\", 7, KEY_IGNORE); | |
877 | 1 | EXPECT_PARSE_SEQ("\033]ltitle\a", KEY_IGNORE); | |
878 | 1 | EXPECT_PARSE_SEQ("\033]Licon\a", KEY_IGNORE); | |
879 | |||
880 | // DECRPM replies (to DECRQM queries) | ||
881 | 1 | EXPECT_PARSE_SEQ("\033[?2026;0$y", KEY_IGNORE); | |
882 | 1 | EXPECT_PARSE_SEQ("\033[?2026;1$y", TFLAG(TFLAG_SYNC)); | |
883 | 1 | EXPECT_PARSE_SEQ("\033[?2026;2$y", TFLAG(TFLAG_SYNC)); | |
884 | 1 | EXPECT_PARSE_SEQ("\033[?2026;3$y", KEY_IGNORE); | |
885 | 1 | EXPECT_PARSE_SEQ("\033[?2026;4$y", KEY_IGNORE); | |
886 | 1 | EXPECT_PARSE_SEQ("\033[?2026;5$y", KEY_IGNORE); | |
887 | 1 | EXPECT_PARSE_SEQ("\033[?0;1$y", KEY_IGNORE); | |
888 | 1 | EXPECT_PARSE_SEQ("\033[?1036;2$y", TFLAG(TFLAG_META_ESC)); | |
889 | 1 | EXPECT_PARSE_SEQ("\033[?1039;2$y", TFLAG(TFLAG_ALT_ESC)); | |
890 | 1 | EXPECT_PARSE_SEQ("\033[?7;2$y", KEY_IGNORE); | |
891 | 1 | EXPECT_PARSE_SEQ("\033[?25;2$y", KEY_IGNORE); | |
892 | 1 | EXPECT_PARSE_SEQ("\033[?45;2$y", KEY_IGNORE); | |
893 | 1 | EXPECT_PARSE_SEQ("\033[?67;2$y", KEY_IGNORE); | |
894 | 1 | EXPECT_PARSE_SEQ("\033[?1049;2$y", KEY_IGNORE); | |
895 | 1 | EXPECT_PARSE_SEQ("\033[?2004;2$y", KEY_IGNORE); | |
896 | |||
897 | // Invalid, DECRPM-like sequences | ||
898 | 1 | EXPECT_PARSE_SEQ("\033[?9$y", KEY_IGNORE); // Too few params | |
899 | 1 | EXPECT_PARSE_SEQ("\033[?1;2;3$y", KEY_IGNORE); // Too many params | |
900 | 1 | EXPECT_PARSE_SEQ("\033[?1;2y", KEY_IGNORE); // No '$' intermediate byte | |
901 | 1 | EXPECT_PARSE_SEQ("\033[1;2$y", KEY_IGNORE); // No '?' param prefix | |
902 | |||
903 | // XTGETTCAP replies | ||
904 | 1 | EXPECT_PARSE_SEQN("\033P1+r626365\033\\", 11, TFLAG(TFLAG_BACK_COLOR_ERASE)); | |
905 | 1 | EXPECT_PARSE_SEQN("\033P1+r74736C=1B5D323B\033\\", 20, TFLAG(TFLAG_SET_WINDOW_TITLE)); | |
906 | 1 | EXPECT_PARSE_SEQN("\033P0+r\033\\", 5, KEY_IGNORE); | |
907 | 1 | EXPECT_PARSE_SEQN("\033P0+rbbccdd\033\\", 11, KEY_IGNORE); | |
908 | |||
909 | // DECRQSS replies | ||
910 | 1 | EXPECT_PARSE_SEQN("\033P1$r0;38:2::60:70:80;48:5:255m\033\\", 31, TFLAG(TFLAG_TRUE_COLOR | TFLAG_256_COLOR)); // SGR (xterm, foot) | |
911 | 1 | EXPECT_PARSE_SEQN("\033P1$r0;38:2:60:70:80;48:5:255m\033\\", 30, TFLAG(TFLAG_TRUE_COLOR | TFLAG_256_COLOR)); // SGR (kitty) | |
912 | 1 | EXPECT_PARSE_SEQN("\033P1$r0;zm\033\\", 9, KEY_IGNORE); // Invalid SGR-like | |
913 | 1 | EXPECT_PARSE_SEQN("\033P1$r2 q\033\\", 8, KEY_IGNORE); // DECSCUSR 2 (cursor style) | |
914 | |||
915 | // Kitty keyboard protocol query replies | ||
916 | 1 | EXPECT_PARSE_SEQ("\033[?5u", TFLAG(TFLAG_KITTY_KEYBOARD)); | |
917 | 1 | EXPECT_PARSE_SEQ("\033[?1u", TFLAG(TFLAG_KITTY_KEYBOARD)); | |
918 | 1 | EXPECT_PARSE_SEQ("\033[?0u", TFLAG(TFLAG_KITTY_KEYBOARD)); | |
919 | |||
920 | // Invalid, kitty-reply-like sequences | ||
921 | 1 | EXPECT_PARSE_SEQ("\033[?u", KEY_IGNORE); // Too few params (could be valid, in theory) | |
922 | 1 | EXPECT_PARSE_SEQ("\033[?1;2u", KEY_IGNORE); // Too many params | |
923 | 1 | EXPECT_PARSE_SEQ("\033[?1:2u", KEY_IGNORE); // Sub-params | |
924 | 1 | EXPECT_PARSE_SEQ("\033[?1!u", KEY_IGNORE); // Intermediate '!' byte | |
925 | 1 | } | |
926 | |||
927 | 1 | static void test_term_parse_sequence2(TestContext *ctx) | |
928 | { | ||
929 | 1 | static const struct { | |
930 | char key_str[3]; | ||
931 | char final_byte; | ||
932 | KeyCode key; | ||
933 | } templates[] = { | ||
934 | {"1", 'A', KEY_UP}, | ||
935 | {"1", 'B', KEY_DOWN}, | ||
936 | {"1", 'C', KEY_RIGHT}, | ||
937 | {"1", 'D', KEY_LEFT}, | ||
938 | {"1", 'E', KEY_BEGIN}, | ||
939 | {"1", 'F', KEY_END}, | ||
940 | {"1", 'H', KEY_HOME}, | ||
941 | {"1", 'P', KEY_F1}, | ||
942 | {"1", 'Q', KEY_F2}, | ||
943 | {"1", 'R', KEY_F3}, // https://sw.kovidgoyal.net/kitty/keyboard-protocol/#:~:text=CSI%20R | ||
944 | {"1", 'S', KEY_F4}, | ||
945 | {"2", '~', KEY_INSERT}, | ||
946 | {"3", '~', KEY_DELETE}, | ||
947 | {"5", '~', KEY_PAGE_UP}, | ||
948 | {"6", '~', KEY_PAGE_DOWN}, | ||
949 | {"11", '~', KEY_F1}, | ||
950 | {"12", '~', KEY_F2}, | ||
951 | {"13", '~', KEY_F3}, | ||
952 | {"14", '~', KEY_F4}, | ||
953 | {"15", '~', KEY_F5}, | ||
954 | {"17", '~', KEY_F6}, | ||
955 | {"18", '~', KEY_F7}, | ||
956 | {"19", '~', KEY_F8}, | ||
957 | {"20", '~', KEY_F9}, | ||
958 | {"21", '~', KEY_F10}, | ||
959 | {"23", '~', KEY_F11}, | ||
960 | {"24", '~', KEY_F12}, | ||
961 | {"25", '~', KEY_F13}, | ||
962 | {"26", '~', KEY_F14}, | ||
963 | {"28", '~', KEY_F15}, | ||
964 | {"29", '~', KEY_F16}, | ||
965 | {"31", '~', KEY_F17}, | ||
966 | {"32", '~', KEY_F18}, | ||
967 | {"33", '~', KEY_F19}, | ||
968 | {"34", '~', KEY_F20}, | ||
969 | }; | ||
970 | |||
971 | 1 | static const struct { | |
972 | char mod_str[4]; | ||
973 | KeyCode mask; | ||
974 | } modifiers[] = { | ||
975 | {"0", KEY_IGNORE}, | ||
976 | {"1", 0}, | ||
977 | {"2", MOD_SHIFT}, | ||
978 | {"3", MOD_META}, | ||
979 | {"4", MOD_SHIFT | MOD_META}, | ||
980 | {"5", MOD_CTRL}, | ||
981 | {"6", MOD_SHIFT | MOD_CTRL}, | ||
982 | {"7", MOD_META | MOD_CTRL}, | ||
983 | {"8", MOD_SHIFT | MOD_META | MOD_CTRL}, | ||
984 | {"9", MOD_SUPER}, | ||
985 | {"10", MOD_SUPER | MOD_SHIFT}, | ||
986 | {"11", MOD_SUPER | MOD_META}, | ||
987 | {"12", MOD_SUPER | MOD_META | MOD_SHIFT}, | ||
988 | {"13", MOD_SUPER | MOD_CTRL}, | ||
989 | {"14", MOD_SUPER | MOD_CTRL | MOD_SHIFT}, | ||
990 | {"15", MOD_SUPER | MOD_META | MOD_CTRL}, | ||
991 | {"16", MOD_SUPER | MOD_META | MOD_CTRL | MOD_SHIFT}, | ||
992 | {"17", MOD_HYPER}, | ||
993 | {"18", MOD_HYPER | MOD_SHIFT}, | ||
994 | {"255", MOD_HYPER | MOD_SUPER | MOD_META | MOD_CTRL}, | ||
995 | {"256", MOD_MASK}, | ||
996 | {"257", KEY_IGNORE}, | ||
997 | {"400", KEY_IGNORE}, | ||
998 | }; | ||
999 | |||
1000 | 1 | static_assert(KEY_IGNORE != 0); | |
1001 | 1 | static_assert((KEY_IGNORE & MOD_MASK) == 0); | |
1002 | |||
1003 |
2/2✓ Branch 0 (21→22) taken 35 times.
✓ Branch 1 (21→23) taken 1 times.
|
36 | FOR_EACH_I(i, templates) { |
1004 |
2/2✓ Branch 0 (19→3) taken 805 times.
✓ Branch 1 (19→20) taken 35 times.
|
840 | FOR_EACH_I(j, modifiers) { |
1005 | 805 | char seq[16]; | |
1006 | 1610 | size_t seq_length = xsnprintf ( | |
1007 | seq, | ||
1008 | sizeof seq, | ||
1009 | "\033[%s;%s%c", | ||
1010 | 805 | templates[i].key_str, | |
1011 | 805 | modifiers[j].mod_str, | |
1012 | 805 | templates[i].final_byte | |
1013 | ); | ||
1014 | 805 | KeyCode key = 24; | |
1015 | 805 | ssize_t parsed_length = term_parse_sequence(seq, seq_length, &key); | |
1016 | 805 | KeyCode mods = modifiers[j].mask; | |
1017 |
2/2✓ Branch 0 (5→6) taken 700 times.
✓ Branch 1 (5→7) taken 105 times.
|
805 | KeyCode expected_key = mods | (mods == KEY_IGNORE ? 0 : templates[i].key); |
1018 | 805 | IEXPECT_EQ(parsed_length, seq_length); | |
1019 | 805 | IEXPECT_KEYCODE_EQ(key, expected_key, seq, seq_length); | |
1020 | // Truncated | ||
1021 | 805 | key = 25; | |
1022 |
2/2✓ Branch 0 (14→10) taken 5080 times.
✓ Branch 1 (14→15) taken 805 times.
|
5885 | for (size_t n = seq_length - 1; n != 0; n--) { |
1023 | 5080 | parsed_length = term_parse_sequence(seq, n, &key); | |
1024 | 5080 | EXPECT_EQ(parsed_length, TPARSE_PARTIAL_MATCH); | |
1025 | 5080 | EXPECT_EQ(key, 25); | |
1026 | } | ||
1027 | // Overlength | ||
1028 | 805 | key = 26; | |
1029 | 805 | seq[seq_length++] = '~'; | |
1030 | 805 | parsed_length = term_parse_sequence(seq, seq_length, &key); | |
1031 | 805 | IEXPECT_EQ(parsed_length, seq_length - 1); | |
1032 | 805 | IEXPECT_KEYCODE_EQ(key, expected_key, seq, seq_length); | |
1033 | } | ||
1034 | } | ||
1035 | 1 | } | |
1036 | |||
1037 | 1 | static void test_rxvt_parse_key(TestContext *ctx) | |
1038 | { | ||
1039 | 1 | static const struct { | |
1040 | char escape_sequence[8]; | ||
1041 | KeyCode key; | ||
1042 | } templates[] = { | ||
1043 | {"\033\033[2_", KEY_INSERT}, | ||
1044 | {"\033\033[3_", KEY_DELETE}, | ||
1045 | {"\033\033[5_", KEY_PAGE_UP}, | ||
1046 | {"\033\033[6_", KEY_PAGE_DOWN}, | ||
1047 | {"\033\033[7_", KEY_HOME}, | ||
1048 | {"\033\033[8_", KEY_END}, | ||
1049 | }; | ||
1050 | |||
1051 | 1 | static const struct { | |
1052 | char ch; | ||
1053 | KeyCode mask; | ||
1054 | } modifiers[] = { | ||
1055 | {'~', 0}, | ||
1056 | {'^', MOD_CTRL}, | ||
1057 | {'$', MOD_SHIFT}, | ||
1058 | {'@', MOD_SHIFT | MOD_CTRL}, | ||
1059 | }; | ||
1060 | |||
1061 |
2/2✓ Branch 0 (26→24) taken 6 times.
✓ Branch 1 (26→33) taken 1 times.
|
7 | FOR_EACH_I(i, templates) { |
1062 |
2/2✓ Branch 0 (24→3) taken 24 times.
✓ Branch 1 (24→25) taken 6 times.
|
30 | FOR_EACH_I(j, modifiers) { |
1063 | 24 | char seq[8]; | |
1064 | 24 | memcpy(seq, templates[i].escape_sequence, 8); | |
1065 | 24 | ASSERT_EQ(seq[7], '\0'); | |
1066 | 24 | char *underscore = strchr(seq, '_'); | |
1067 | 24 | ASSERT_NONNULL(underscore); | |
1068 | 24 | *underscore = modifiers[j].ch; | |
1069 | 24 | size_t seq_length = strlen(seq); | |
1070 | 24 | KeyCode key; | |
1071 | |||
1072 | // Double ESC | ||
1073 | 24 | ssize_t parsed_length = rxvt_parse_key(seq, seq_length, &key); | |
1074 | 24 | EXPECT_EQ(parsed_length, seq_length); | |
1075 | 24 | EXPECT_EQ(key, modifiers[j].mask | templates[i].key | MOD_META); | |
1076 | |||
1077 | // Single ESC | ||
1078 | 24 | parsed_length = rxvt_parse_key(seq + 1, seq_length - 1, &key); | |
1079 | 24 | EXPECT_EQ(parsed_length, seq_length - 1); | |
1080 | 24 | EXPECT_EQ(key, modifiers[j].mask | templates[i].key); | |
1081 | |||
1082 | // Truncated (double ESC) | ||
1083 |
2/2✓ Branch 0 (16→12) taken 96 times.
✓ Branch 1 (16→17) taken 24 times.
|
120 | for (size_t n = seq_length - 1; n != 0; n--) { |
1084 | 96 | key = 25; | |
1085 | 96 | parsed_length = rxvt_parse_key(seq, n, &key); | |
1086 | 96 | EXPECT_EQ(parsed_length, TPARSE_PARTIAL_MATCH); | |
1087 | 96 | EXPECT_EQ(key, 25); | |
1088 | } | ||
1089 | |||
1090 | // Truncated (single ESC) | ||
1091 |
2/2✓ Branch 0 (22→18) taken 72 times.
✓ Branch 1 (22→23) taken 24 times.
|
96 | for (size_t n = seq_length - 2; n != 0; n--) { |
1092 | 72 | key = 25; | |
1093 | 72 | parsed_length = rxvt_parse_key(seq + 1, n, &key); | |
1094 | 72 | EXPECT_EQ(parsed_length, TPARSE_PARTIAL_MATCH); | |
1095 | 72 | EXPECT_EQ(key, 25); | |
1096 | } | ||
1097 | } | ||
1098 | } | ||
1099 | |||
1100 | static const struct { | ||
1101 | char NONSTRING seq[6]; | ||
1102 | uint8_t seq_length; | ||
1103 | int8_t expected_length; | ||
1104 | KeyCode expected_key; | ||
1105 | } tests[] = { | ||
1106 | {STRN("\033Oa"), 3, MOD_CTRL | KEY_UP}, | ||
1107 | {STRN("\033Ob"), 3, MOD_CTRL | KEY_DOWN}, | ||
1108 | {STRN("\033Oc"), 3, MOD_CTRL | KEY_RIGHT}, | ||
1109 | {STRN("\033Od"), 3, MOD_CTRL | KEY_LEFT}, | ||
1110 | {STRN("\033O"), TPARSE_PARTIAL_MATCH, 0}, | ||
1111 | {STRN("\033[a"), 3, MOD_SHIFT | KEY_UP}, | ||
1112 | {STRN("\033[b"), 3, MOD_SHIFT | KEY_DOWN}, | ||
1113 | {STRN("\033[c"), 3, MOD_SHIFT | KEY_RIGHT}, | ||
1114 | {STRN("\033[d"), 3, MOD_SHIFT | KEY_LEFT}, | ||
1115 | {STRN("\033["), TPARSE_PARTIAL_MATCH, 0}, | ||
1116 | {STRN("\033[1;5A"), 6, MOD_CTRL | KEY_UP}, | ||
1117 | {STRN("\033[1;5"), TPARSE_PARTIAL_MATCH, 0}, | ||
1118 | {STRN("\033\033[@"), 4, KEY_IGNORE}, | ||
1119 | {STRN("\033\033["), TPARSE_PARTIAL_MATCH, 0}, | ||
1120 | {STRN("\033\033"), TPARSE_PARTIAL_MATCH, 0}, | ||
1121 | {STRN("\033"), TPARSE_PARTIAL_MATCH, 0}, | ||
1122 | }; | ||
1123 | |||
1124 |
2/2✓ Branch 0 (33→27) taken 16 times.
✓ Branch 1 (33→34) taken 1 times.
|
17 | FOR_EACH_I(i, tests) { |
1125 | 16 | const char *seq = tests[i].seq; | |
1126 | 16 | const size_t seq_length = tests[i].seq_length; | |
1127 | 16 | KeyCode key = 0x18; | |
1128 | 16 | ssize_t parsed_length = rxvt_parse_key(seq, seq_length, &key); | |
1129 |
2/2✓ Branch 0 (28→29) taken 10 times.
✓ Branch 1 (28→30) taken 6 times.
|
16 | KeyCode expected_key = (parsed_length > 0) ? tests[i].expected_key : 0x18; |
1130 | 16 | IEXPECT_EQ(parsed_length, tests[i].expected_length); | |
1131 | 16 | IEXPECT_KEYCODE_EQ(key, expected_key, seq, seq_length); | |
1132 | } | ||
1133 | 1 | } | |
1134 | |||
1135 | 1 | static void test_linux_parse_key(TestContext *ctx) | |
1136 | { | ||
1137 | 1 | static const struct { | |
1138 | char NONSTRING seq[6]; | ||
1139 | uint8_t seq_length; | ||
1140 | int8_t expected_length; | ||
1141 | KeyCode expected_key; | ||
1142 | } tests[] = { | ||
1143 | {STRN("\033[1;5A"), 6, MOD_CTRL | KEY_UP}, | ||
1144 | {STRN("\033[[A"), 4, KEY_F1}, | ||
1145 | {STRN("\033[[B"), 4, KEY_F2}, | ||
1146 | {STRN("\033[[C"), 4, KEY_F3}, | ||
1147 | {STRN("\033[[D"), 4, KEY_F4}, | ||
1148 | {STRN("\033[[E"), 4, KEY_F5}, | ||
1149 | {STRN("\033[[F"), 0, 0}, | ||
1150 | {STRN("\033[["), TPARSE_PARTIAL_MATCH, 0}, | ||
1151 | {STRN("\033["), TPARSE_PARTIAL_MATCH, 0}, | ||
1152 | {STRN("\033"), TPARSE_PARTIAL_MATCH, 0}, | ||
1153 | }; | ||
1154 | |||
1155 |
2/2✓ Branch 0 (9→3) taken 10 times.
✓ Branch 1 (9→10) taken 1 times.
|
11 | FOR_EACH_I(i, tests) { |
1156 | 10 | const char *seq = tests[i].seq; | |
1157 | 10 | const size_t seq_length = tests[i].seq_length; | |
1158 | 10 | KeyCode key = 0x18; | |
1159 | 10 | ssize_t parsed_length = linux_parse_key(seq, seq_length, &key); | |
1160 |
2/2✓ Branch 0 (4→5) taken 6 times.
✓ Branch 1 (4→6) taken 4 times.
|
10 | KeyCode expected_key = (parsed_length > 0) ? tests[i].expected_key : 0x18; |
1161 | 10 | IEXPECT_EQ(parsed_length, tests[i].expected_length); | |
1162 | 10 | IEXPECT_KEYCODE_EQ(key, expected_key, seq, seq_length); | |
1163 | } | ||
1164 | 1 | } | |
1165 | |||
1166 | 1 | static void test_keycode_to_string(TestContext *ctx) | |
1167 | { | ||
1168 | 1 | static const struct { | |
1169 | const char *str; | ||
1170 | KeyCode key; | ||
1171 | } tests[] = { | ||
1172 | {"a", 'a'}, | ||
1173 | {"Z", 'Z'}, | ||
1174 | {"0", '0'}, | ||
1175 | {"{", '{'}, | ||
1176 | {"space", KEY_SPACE}, | ||
1177 | {"enter", KEY_ENTER}, | ||
1178 | {"tab", KEY_TAB}, | ||
1179 | {"escape", KEY_ESCAPE}, | ||
1180 | {"backspace", KEY_BACKSPACE}, | ||
1181 | {"insert", KEY_INSERT}, | ||
1182 | {"delete", KEY_DELETE}, | ||
1183 | {"home", KEY_HOME}, | ||
1184 | {"end", KEY_END}, | ||
1185 | {"pgup", KEY_PAGE_UP}, | ||
1186 | {"pgdown", KEY_PAGE_DOWN}, | ||
1187 | {"begin", KEY_BEGIN}, | ||
1188 | {"left", KEY_LEFT}, | ||
1189 | {"right", KEY_RIGHT}, | ||
1190 | {"up", KEY_UP}, | ||
1191 | {"down", KEY_DOWN}, | ||
1192 | {"scrlock", KEY_SCROLL_LOCK}, | ||
1193 | {"print", KEY_PRINT_SCREEN}, | ||
1194 | {"pause", KEY_PAUSE}, | ||
1195 | {"menu", KEY_MENU}, | ||
1196 | {"C-a", MOD_CTRL | 'a'}, | ||
1197 | {"C-s", MOD_CTRL | 's'}, | ||
1198 | {"M-a", MOD_META | 'a'}, | ||
1199 | {"M-S-{", MOD_META | MOD_SHIFT | '{'}, | ||
1200 | {"C-S-a", MOD_CTRL | MOD_SHIFT | 'a'}, | ||
1201 | {"M-S-a", MOD_META | MOD_SHIFT | 'a'}, | ||
1202 | {"F1", KEY_F1}, | ||
1203 | {"F5", KEY_F5}, | ||
1204 | {"F12", KEY_F12}, | ||
1205 | {"F13", KEY_F13}, | ||
1206 | {"F16", KEY_F16}, | ||
1207 | {"F20", KEY_F20}, | ||
1208 | {"F24", KEY_F24}, | ||
1209 | {"M-enter", MOD_META | KEY_ENTER}, | ||
1210 | {"M-space", MOD_META | KEY_SPACE}, | ||
1211 | {"S-tab", MOD_SHIFT | KEY_TAB}, | ||
1212 | {"C-M-S-F12", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_F12}, | ||
1213 | {"C-M-F16", MOD_CTRL | MOD_META | KEY_F16}, | ||
1214 | {"C-S-F20", MOD_CTRL | MOD_SHIFT | KEY_F20}, | ||
1215 | {"C-S-F24", MOD_CTRL | MOD_SHIFT | KEY_F24}, | ||
1216 | {"C-M-S-up", MOD_CTRL | MOD_META | MOD_SHIFT | KEY_UP}, | ||
1217 | {"C-M-delete", MOD_CTRL | MOD_META | KEY_DELETE}, | ||
1218 | {"C-home", MOD_CTRL | KEY_HOME}, | ||
1219 | {"s-space", MOD_SUPER | ' '}, | ||
1220 | {"H-end", MOD_HYPER | KEY_END}, | ||
1221 | #if __STDC_VERSION__ >= 201112L | ||
1222 | {(const char*)u8"ก", 0x0E01}, | ||
1223 | {(const char*)u8"C-ก", MOD_CTRL | 0x0E01}, | ||
1224 | {(const char*)u8"M-Ф", MOD_META | 0x0424}, | ||
1225 | #endif | ||
1226 | }; | ||
1227 | |||
1228 | 1 | char buf[KEYCODE_STR_BUFSIZE]; | |
1229 | 1 | ASSERT_TRUE(sizeof(buf) >= sizeof("QUERY REPLY; 0x12345678")); | |
1230 | 1 | EXPECT_EQ(KEYCODE_STR_BUFSIZE, next_pow2(sizeof("QUERY REPLY; 0x12345678"))); | |
1231 | |||
1232 |
2/2✓ Branch 0 (12→5) taken 52 times.
✓ Branch 1 (12→13) taken 1 times.
|
53 | FOR_EACH_I(i, tests) { |
1233 | 52 | const char *str = tests[i].str; | |
1234 | 52 | size_t len = strlen(str); | |
1235 | 52 | ASSERT_TRUE(len < sizeof(buf)); | |
1236 | 52 | size_t buflen = keycode_to_str(tests[i].key, buf); | |
1237 | 52 | IEXPECT_STREQ(buf, str); | |
1238 | 52 | IEXPECT_EQ(buflen, len); | |
1239 | 52 | IEXPECT_EQ(keycode_from_str(str), tests[i].key); | |
1240 | } | ||
1241 | |||
1242 | 1 | EXPECT_EQ(keycode_to_str(KEYCODE_DETECTED_PASTE, buf), 19); | |
1243 | 1 | EXPECT_STREQ(buf, "INVALID; 0x00110029"); | |
1244 | 1 | EXPECT_EQ(keycode_to_str(KEYCODE_BRACKETED_PASTE, buf), 19); | |
1245 | 1 | EXPECT_STREQ(buf, "INVALID; 0x0011002A"); | |
1246 | 1 | EXPECT_EQ(keycode_to_str(KEY_IGNORE, buf), 19); | |
1247 | 1 | EXPECT_STREQ(buf, "INVALID; 0x0011002B"); | |
1248 | 1 | EXPECT_EQ(keycode_to_str(UINT32_MAX, buf), 23); | |
1249 | 1 | EXPECT_STREQ(buf, "QUERY REPLY; 0xFFFFFFFF"); | |
1250 | |||
1251 | // These combos aren't round-trippable by the code above and can't end | ||
1252 | // up in real bindings, since the letters are normalized to lower case | ||
1253 | // by keycode_from_str(). We still test them nevertheless; for the sake | ||
1254 | // of completeness and catching unexpected changes. | ||
1255 | 1 | EXPECT_EQ(keycode_to_str(MOD_CTRL | 'A', buf), 3); | |
1256 | 1 | EXPECT_STREQ(buf, "C-A"); | |
1257 | 1 | EXPECT_EQ(keycode_to_str(MOD_CTRL | MOD_SHIFT | 'A', buf), 5); | |
1258 | 1 | EXPECT_STREQ(buf, "C-S-A"); | |
1259 | 1 | EXPECT_EQ(keycode_to_str(MOD_META | MOD_SHIFT | 'A', buf), 5); | |
1260 | 1 | EXPECT_STREQ(buf, "M-S-A"); | |
1261 | 1 | } | |
1262 | |||
1263 | 1 | static void test_parse_key_string(TestContext *ctx) | |
1264 | { | ||
1265 | 1 | EXPECT_EQ(keycode_from_str("^I"), MOD_CTRL | 'i'); | |
1266 | 1 | EXPECT_EQ(keycode_from_str("^M"), MOD_CTRL | 'm'); | |
1267 | 1 | EXPECT_EQ(keycode_from_str("C-I"), MOD_CTRL | 'i'); | |
1268 | 1 | EXPECT_EQ(keycode_from_str("C-M"), MOD_CTRL | 'm'); | |
1269 | 1 | EXPECT_EQ(keycode_from_str("C-F1"), MOD_CTRL | KEY_F1); | |
1270 | 1 | EXPECT_EQ(keycode_from_str("C-M-S-F20"), MOD_CTRL | MOD_META | MOD_SHIFT | KEY_F20); | |
1271 | 1 | EXPECT_EQ(keycode_from_str("C-M-S-F24"), MOD_CTRL | MOD_META | MOD_SHIFT | KEY_F24); | |
1272 | 1 | EXPECT_EQ(keycode_from_str("s-m"), MOD_SUPER | 'm'); | |
1273 | 1 | EXPECT_EQ(keycode_from_str("H-y"), MOD_HYPER | 'y'); | |
1274 | 1 | EXPECT_EQ(keycode_from_str("H-y"), MOD_HYPER | 'y'); | |
1275 | 1 | EXPECT_EQ(keycode_from_str("H-S-z"), MOD_HYPER | MOD_SHIFT | 'z'); | |
1276 | 1 | EXPECT_EQ(keycode_from_str("s-S-t"), MOD_SUPER | MOD_SHIFT | 't'); | |
1277 | 1 | EXPECT_EQ(keycode_from_str("S-print"), MOD_SHIFT | KEY_PRINT_SCREEN); | |
1278 | 1 | EXPECT_EQ(keycode_from_str("C-S-scrlock"), MOD_CTRL | MOD_SHIFT | KEY_SCROLL_LOCK); | |
1279 | 1 | EXPECT_EQ(keycode_from_str("tab"), KEY_TAB); | |
1280 | 1 | EXPECT_EQ(keycode_from_str("enter"), KEY_ENTER); | |
1281 | 1 | EXPECT_EQ(keycode_from_str("space"), KEY_SPACE); | |
1282 | 1 | EXPECT_EQ(keycode_from_str("escape"), KEY_ESCAPE); | |
1283 | 1 | EXPECT_EQ(keycode_from_str("backspace"), KEY_BACKSPACE); | |
1284 | 1 | EXPECT_EQ(keycode_from_str("insert"), KEY_INSERT); | |
1285 | 1 | EXPECT_EQ(keycode_from_str("delete"), KEY_DELETE); | |
1286 | 1 | EXPECT_EQ(keycode_from_str("up"), KEY_UP); | |
1287 | 1 | EXPECT_EQ(keycode_from_str("down"), KEY_DOWN); | |
1288 | 1 | EXPECT_EQ(keycode_from_str("right"), KEY_RIGHT); | |
1289 | 1 | EXPECT_EQ(keycode_from_str("left"), KEY_LEFT); | |
1290 | 1 | EXPECT_EQ(keycode_from_str("begin"), KEY_BEGIN); | |
1291 | 1 | EXPECT_EQ(keycode_from_str("end"), KEY_END); | |
1292 | 1 | EXPECT_EQ(keycode_from_str("pgdown"), KEY_PAGE_DOWN); | |
1293 | 1 | EXPECT_EQ(keycode_from_str("home"), KEY_HOME); | |
1294 | 1 | EXPECT_EQ(keycode_from_str("pgup"), KEY_PAGE_UP); | |
1295 | 1 | EXPECT_EQ(keycode_from_str("scrlock"), KEY_SCROLL_LOCK); | |
1296 | 1 | EXPECT_EQ(keycode_from_str("print"), KEY_PRINT_SCREEN); | |
1297 | 1 | EXPECT_EQ(keycode_from_str("pause"), KEY_PAUSE); | |
1298 | 1 | EXPECT_EQ(keycode_from_str("menu"), KEY_MENU); | |
1299 | 1 | EXPECT_EQ(keycode_from_str("f1"), KEY_F1); | |
1300 | 1 | EXPECT_EQ(keycode_from_str("f2"), KEY_F2); | |
1301 | 1 | EXPECT_EQ(keycode_from_str("f3"), KEY_F3); | |
1302 | 1 | EXPECT_EQ(keycode_from_str("f4"), KEY_F4); | |
1303 | 1 | EXPECT_EQ(keycode_from_str("f5"), KEY_F5); | |
1304 | 1 | EXPECT_EQ(keycode_from_str("f6"), KEY_F6); | |
1305 | 1 | EXPECT_EQ(keycode_from_str("f7"), KEY_F7); | |
1306 | 1 | EXPECT_EQ(keycode_from_str("f8"), KEY_F8); | |
1307 | 1 | EXPECT_EQ(keycode_from_str("f9"), KEY_F9); | |
1308 | 1 | EXPECT_EQ(keycode_from_str("f10"), KEY_F10); | |
1309 | 1 | EXPECT_EQ(keycode_from_str("f11"), KEY_F11); | |
1310 | 1 | EXPECT_EQ(keycode_from_str("f12"), KEY_F12); | |
1311 | 1 | EXPECT_EQ(keycode_from_str("f13"), KEY_F13); | |
1312 | 1 | EXPECT_EQ(keycode_from_str("f14"), KEY_F14); | |
1313 | 1 | EXPECT_EQ(keycode_from_str("f15"), KEY_F15); | |
1314 | 1 | EXPECT_EQ(keycode_from_str("f16"), KEY_F16); | |
1315 | 1 | EXPECT_EQ(keycode_from_str("f17"), KEY_F17); | |
1316 | 1 | EXPECT_EQ(keycode_from_str("f18"), KEY_F18); | |
1317 | 1 | EXPECT_EQ(keycode_from_str("f19"), KEY_F19); | |
1318 | 1 | EXPECT_EQ(keycode_from_str("f20"), KEY_F20); | |
1319 | 1 | EXPECT_EQ(keycode_from_str("f21"), KEY_F21); | |
1320 | 1 | EXPECT_EQ(keycode_from_str("f22"), KEY_F22); | |
1321 | 1 | EXPECT_EQ(keycode_from_str("f23"), KEY_F23); | |
1322 | 1 | EXPECT_EQ(keycode_from_str("f24"), KEY_F24); | |
1323 | |||
1324 | 1 | EXPECT_EQ(keycode_from_str("C-"), KEY_NONE); | |
1325 | 1 | EXPECT_EQ(keycode_from_str("C-M-"), KEY_NONE); | |
1326 | 1 | EXPECT_EQ(keycode_from_str("paste"), KEY_NONE); | |
1327 | 1 | EXPECT_EQ(keycode_from_str("???"), KEY_NONE); | |
1328 | 1 | EXPECT_EQ(keycode_from_str("F0"), KEY_NONE); | |
1329 | 1 | EXPECT_EQ(keycode_from_str("F25"), KEY_NONE); | |
1330 | 1 | EXPECT_EQ(keycode_from_str("F01"), KEY_NONE); | |
1331 | 1 | EXPECT_EQ(keycode_from_str("\t"), KEY_NONE); | |
1332 | 1 | EXPECT_EQ(keycode_from_str("\n"), KEY_NONE); | |
1333 | 1 | EXPECT_EQ(keycode_from_str("\r"), KEY_NONE); | |
1334 | 1 | EXPECT_EQ(keycode_from_str("\x1f"), KEY_NONE); | |
1335 | 1 | EXPECT_EQ(keycode_from_str("\x7f"), KEY_NONE); | |
1336 | 1 | EXPECT_EQ(keycode_from_str("C-\t"), KEY_NONE); | |
1337 | 1 | EXPECT_EQ(keycode_from_str("C-\r"), KEY_NONE); | |
1338 | 1 | EXPECT_EQ(keycode_from_str("C-\x7f"), KEY_NONE); | |
1339 | |||
1340 | // Special cases for normalization: | ||
1341 | 1 | EXPECT_EQ(keycode_from_str("C-A"), MOD_CTRL | 'a'); | |
1342 | 1 | EXPECT_EQ(keycode_from_str("C-S-A"), MOD_CTRL | MOD_SHIFT | 'a'); | |
1343 | 1 | EXPECT_EQ(keycode_from_str("M-A"), MOD_META | MOD_SHIFT | 'a'); | |
1344 | 1 | EXPECT_EQ(keycode_from_str("C-?"), MOD_CTRL | '?'); | |
1345 | 1 | EXPECT_EQ(keycode_from_str("C-H"), MOD_CTRL | 'h'); | |
1346 | 1 | EXPECT_EQ(keycode_from_str("M-C-?"), MOD_META | MOD_CTRL | '?'); | |
1347 | 1 | EXPECT_EQ(keycode_from_str("M-C-H"), MOD_META | MOD_CTRL | 'h'); | |
1348 | 1 | } | |
1349 | |||
1350 | 26 | static bool clear_obuf(TermOutputBuffer *obuf) | |
1351 | { | ||
1352 |
1/2✓ Branch 0 (2→3) taken 26 times.
✗ Branch 1 (2→4) not taken.
|
26 | if (unlikely(obuf_avail(obuf) <= 8)) { |
1353 | return false; | ||
1354 | } | ||
1355 | 26 | memset(obuf->buf, '\0', obuf->count + 8); | |
1356 | 26 | obuf->count = 0; | |
1357 | 26 | obuf->x = 0; | |
1358 | 26 | return true; | |
1359 | } | ||
1360 | |||
1361 | 1 | static void test_term_init(TestContext *ctx) | |
1362 | { | ||
1363 | 1 | const TermFeatureFlags expected_xterm_flags = | |
1364 | TFLAG_256_COLOR | | ||
1365 | TFLAG_16_COLOR | | ||
1366 | TFLAG_8_COLOR | | ||
1367 | TFLAG_BACK_COLOR_ERASE | | ||
1368 | TFLAG_SET_WINDOW_TITLE | | ||
1369 | TFLAG_OSC52_COPY | ||
1370 | ; | ||
1371 | |||
1372 | 1 | Terminal term = {.obuf = TERM_OUTPUT_INIT}; | |
1373 | 1 | term_init(&term, "xterm-256color", NULL); | |
1374 | 1 | EXPECT_EQ(term.width, 80); | |
1375 | 1 | EXPECT_EQ(term.height, 24); | |
1376 | 1 | EXPECT_EQ(term.ncv_attributes, 0); | |
1377 | 1 | EXPECT_PTREQ(term.parse_input, term_parse_sequence); | |
1378 | 1 | EXPECT_EQ(term.features, expected_xterm_flags); | |
1379 | |||
1380 | 1 | term_init(&term, "ansi", NULL); | |
1381 | 1 | EXPECT_EQ(term.width, 80); | |
1382 | 1 | EXPECT_EQ(term.height, 24); | |
1383 | 1 | EXPECT_EQ(term.ncv_attributes, ATTR_UNDERLINE); | |
1384 | 1 | EXPECT_PTREQ(term.parse_input, term_parse_sequence); | |
1385 | 1 | EXPECT_EQ(term.features, TFLAG_8_COLOR | TFLAG_NCV_UNDERLINE); | |
1386 | |||
1387 | 1 | term_init(&term, "ansi-m", NULL); | |
1388 | 1 | EXPECT_EQ(term.width, 80); | |
1389 | 1 | EXPECT_EQ(term.height, 24); | |
1390 | 1 | EXPECT_EQ(term.ncv_attributes, 0); | |
1391 | 1 | EXPECT_PTREQ(term.parse_input, term_parse_sequence); | |
1392 | 1 | EXPECT_EQ(term.features, 0); | |
1393 | 1 | } | |
1394 | |||
1395 | 1 | static void test_term_put_str(TestContext *ctx) | |
1396 | { | ||
1397 | 1 | Terminal term = { | |
1398 | .width = 80, | ||
1399 | .height = 24, | ||
1400 | .obuf = TERM_OUTPUT_INIT, | ||
1401 | }; | ||
1402 | |||
1403 | // Fill start of buffer with zeroes, to allow using EXPECT_STREQ() below | ||
1404 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1405 | 1 | ASSERT_TRUE(256 <= TERM_OUTBUF_SIZE); | |
1406 | 1 | memset(obuf->buf, 0, 256); | |
1407 | |||
1408 | 1 | obuf->width = 0; | |
1409 | 1 | term_put_str(obuf, "this should write nothing because obuf->width == 0"); | |
1410 | 1 | EXPECT_EQ(obuf->count, 0); | |
1411 | 1 | EXPECT_EQ(obuf->x, 0); | |
1412 | |||
1413 | 1 | term_output_reset(&term, 0, 80, 0); | |
1414 | 1 | EXPECT_EQ(obuf->tab_mode, TAB_CONTROL); | |
1415 | 1 | EXPECT_EQ(obuf->tab_width, 8); | |
1416 | 1 | EXPECT_EQ(obuf->x, 0); | |
1417 | 1 | EXPECT_EQ(obuf->width, 80); | |
1418 | 1 | EXPECT_EQ(obuf->scroll_x, 0); | |
1419 | 1 | EXPECT_EQ(term.width, 80); | |
1420 | 1 | EXPECT_EQ(obuf->can_clear, true); | |
1421 | |||
1422 | 1 | term_put_str(obuf, "1\xF0\x9F\xA7\xB2 \t xyz \t\r \xC2\xB6"); | |
1423 | 1 | EXPECT_EQ(obuf->count, 20); | |
1424 | 1 | EXPECT_EQ(obuf->x, 17); | |
1425 | 1 | EXPECT_STREQ(obuf->buf, "1\xF0\x9F\xA7\xB2 ^I xyz ^I^M \xC2\xB6"); | |
1426 | |||
1427 | 1 | EXPECT_TRUE(term_put_char(obuf, 0x10FFFF)); | |
1428 | 1 | EXPECT_EQ(obuf->count, 24); | |
1429 | 1 | EXPECT_EQ(obuf->x, 21); | |
1430 | 1 | EXPECT_STREQ(obuf->buf + 20, "<" "??" ">"); | |
1431 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1432 | 1 | } | |
1433 | |||
1434 | 1 | static void test_term_clear_eol(TestContext *ctx) | |
1435 | { | ||
1436 | 1 | Terminal term = { | |
1437 | .width = 80, | ||
1438 | .height = 24, | ||
1439 | .obuf = TERM_OUTPUT_INIT, | ||
1440 | }; | ||
1441 | |||
1442 | // BCE with non-default bg | ||
1443 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1444 | 1 | term.features = TFLAG_BACK_COLOR_ERASE; | |
1445 | 1 | obuf->style = (TermStyle){.bg = COLOR_RED}; | |
1446 | 1 | term_output_reset(&term, 0, 80, 0); | |
1447 | 1 | EXPECT_EQ(term_clear_eol(&term), TERM_CLEAR_EOL_USED_EL); | |
1448 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[K", 3); | |
1449 | 1 | EXPECT_EQ(obuf->x, 80); | |
1450 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1451 | |||
1452 | // No BCE, but with REP | ||
1453 | 1 | term.features = TFLAG_ECMA48_REPEAT; | |
1454 | 1 | obuf->style = (TermStyle){.bg = COLOR_RED}; | |
1455 | 1 | term_output_reset(&term, 0, 40, 0); | |
1456 | 1 | EXPECT_EQ(term_clear_eol(&term), -40); | |
1457 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, " \033[39b", 6); | |
1458 | 1 | EXPECT_EQ(obuf->x, 40); | |
1459 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1460 | |||
1461 | // No BCE with non-default bg | ||
1462 | 1 | term.features = 0; | |
1463 | 1 | obuf->style = (TermStyle){.bg = COLOR_RED}; | |
1464 | 1 | term_output_reset(&term, 0, 80, 0); | |
1465 | 1 | EXPECT_EQ(term_clear_eol(&term), 80); | |
1466 | 1 | EXPECT_EQ(obuf->count, 80); | |
1467 | 1 | EXPECT_EQ(obuf->x, 80); | |
1468 | 1 | EXPECT_EQ(obuf->buf[0], ' '); | |
1469 | 1 | EXPECT_EQ(obuf->buf[79], ' '); | |
1470 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1471 | |||
1472 | // No BCE with default bg/attrs | ||
1473 | 1 | term.features = 0; | |
1474 | 1 | obuf->style = (TermStyle){.bg = COLOR_DEFAULT}; | |
1475 | 1 | term_output_reset(&term, 0, 80, 0); | |
1476 | 1 | EXPECT_EQ(term_clear_eol(&term), TERM_CLEAR_EOL_USED_EL); | |
1477 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[K", 3); | |
1478 | 1 | EXPECT_EQ(obuf->x, 80); | |
1479 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1480 | |||
1481 | // No BCE with ATTR_REVERSE | ||
1482 | 1 | term.features = 0; | |
1483 | 1 | obuf->style = (TermStyle){.bg = COLOR_DEFAULT, .attr = ATTR_REVERSE}; | |
1484 | 1 | term_output_reset(&term, 0, 80, 0); | |
1485 | 1 | EXPECT_EQ(term_clear_eol(&term), 80); | |
1486 | 1 | EXPECT_EQ(obuf->count, 80); | |
1487 | 1 | EXPECT_EQ(obuf->x, 80); | |
1488 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1489 | |||
1490 | // x >= scroll_x + width | ||
1491 | 1 | term_output_reset(&term, 0, 20, 10); | |
1492 | 1 | EXPECT_EQ(obuf->width, 20); | |
1493 | 1 | EXPECT_EQ(obuf->scroll_x, 10); | |
1494 | 1 | obuf->x = 30; | |
1495 | 1 | EXPECT_EQ(term_clear_eol(&term), 0); | |
1496 | 1 | EXPECT_EQ(obuf->count, 0); | |
1497 | 1 | EXPECT_EQ(obuf->x, 30); | |
1498 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1499 | 1 | } | |
1500 | |||
1501 | 1 | static void test_term_move_cursor(TestContext *ctx) | |
1502 | { | ||
1503 | 1 | TermOutputBuffer obuf = TERM_OUTPUT_INIT; | |
1504 | 1 | term_move_cursor(&obuf, 12, 5); | |
1505 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, "\033[6;13H", 7); | |
1506 | 1 | EXPECT_EQ(obuf.x, 0); | |
1507 | 1 | ASSERT_TRUE(clear_obuf(&obuf)); | |
1508 | |||
1509 | 1 | term_move_cursor(&obuf, 0, 22); | |
1510 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, "\033[23H", 5); | |
1511 | 1 | EXPECT_EQ(obuf.x, 0); | |
1512 | 1 | ASSERT_TRUE(clear_obuf(&obuf)); | |
1513 | 1 | } | |
1514 | |||
1515 | 1 | static void test_term_set_bytes(TestContext *ctx) | |
1516 | { | ||
1517 | 1 | Terminal term = { | |
1518 | .width = 80, | ||
1519 | .height = 24, | ||
1520 | .obuf = TERM_OUTPUT_INIT, | ||
1521 | .features = TFLAG_ECMA48_REPEAT, | ||
1522 | }; | ||
1523 | |||
1524 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1525 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1526 | 1 | term_output_reset(&term, 0, 80, 0); | |
1527 | |||
1528 | 1 | EXPECT_EQ(term_set_bytes(&term, 'x', 40), TERM_SET_BYTES_REP); | |
1529 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "x\033[39b", 6); | |
1530 | 1 | EXPECT_EQ(obuf->x, 40); | |
1531 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1532 | |||
1533 | 1 | const size_t repmin = ECMA48_REP_MIN - 1; | |
1534 | 1 | EXPECT_EQ(repmin, 5); | |
1535 | 1 | EXPECT_EQ(term_set_bytes(&term, '-', repmin), TERM_SET_BYTES_MEMSET); | |
1536 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "-----", repmin); | |
1537 | 1 | EXPECT_EQ(obuf->x, repmin); | |
1538 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1539 | |||
1540 | 1 | EXPECT_EQ(term_set_bytes(&term, '\n', 8), TERM_SET_BYTES_MEMSET); | |
1541 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\n\n\n\n\n\n\n\n", 8); | |
1542 | 1 | EXPECT_EQ(obuf->x, 8); | |
1543 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1544 | 1 | } | |
1545 | |||
1546 | 1 | static void test_term_set_style(TestContext *ctx) | |
1547 | { | ||
1548 | 1 | Terminal term = {.obuf = TERM_OUTPUT_INIT}; | |
1549 | 1 | term_init(&term, "tmux", "truecolor"); | |
1550 | 1 | EXPECT_TRUE(term.features & TFLAG_TRUE_COLOR); | |
1551 | 1 | EXPECT_EQ(term.ncv_attributes, 0); | |
1552 | |||
1553 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1554 | 1 | ASSERT_TRUE(TERM_OUTBUF_SIZE >= 64); | |
1555 | 1 | memset(obuf->buf, '?', 64); | |
1556 | |||
1557 | 1 | TermStyle style = { | |
1558 | .fg = COLOR_RED, | ||
1559 | .bg = COLOR_YELLOW, | ||
1560 | .attr = ATTR_BOLD | ATTR_REVERSE, | ||
1561 | }; | ||
1562 | |||
1563 | 1 | term_set_style(&term, style); | |
1564 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;1;7;31;43m", 14); | |
1565 | 1 | EXPECT_EQ(obuf->x, 0); | |
1566 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1567 | |||
1568 | 1 | style.attr = 0; | |
1569 | 1 | style.fg = COLOR_RGB(0x12ef46); | |
1570 | 1 | term_set_style(&term, style); | |
1571 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;38;2;18;239;70;43m", 22); | |
1572 | 1 | EXPECT_EQ(obuf->x, 0); | |
1573 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1574 | |||
1575 | 1 | style.fg = 144; | |
1576 | 1 | style.bg = COLOR_DEFAULT; | |
1577 | 1 | term_set_style(&term, style); | |
1578 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;38;5;144m", 13); | |
1579 | 1 | EXPECT_EQ(obuf->x, 0); | |
1580 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1581 | |||
1582 | 1 | style.fg = COLOR_GRAY; | |
1583 | 1 | style.bg = COLOR_RGB(0x00b91f); | |
1584 | 1 | term_set_style(&term, style); | |
1585 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;37;48;2;0;185;31m", 21); | |
1586 | 1 | EXPECT_EQ(obuf->x, 0); | |
1587 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1588 | |||
1589 | 1 | style.fg = COLOR_WHITE; | |
1590 | 1 | style.bg = COLOR_DARKGRAY; | |
1591 | 1 | style.attr = ATTR_ITALIC; | |
1592 | 1 | term_set_style(&term, style); | |
1593 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;3;97;100m", 13); | |
1594 | 1 | EXPECT_EQ(obuf->x, 0); | |
1595 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1596 | |||
1597 | // Ensure longest sequence doesn't trigger assertion | ||
1598 | 1 | static const char longest[] = | |
1599 | "\033[0;" | ||
1600 | "1;2;3;4;5;7;8;9;" | ||
1601 | "38;2;100;101;199;" | ||
1602 | "48;2;200;202;255m" | ||
1603 | ; | ||
1604 | 1 | const size_t n = sizeof(longest) - 1; | |
1605 | 1 | ASSERT_EQ(n, 54); | |
1606 | 1 | style.fg = COLOR_RGB(0x6465C7); | |
1607 | 1 | style.bg = COLOR_RGB(0xC8CAFF); | |
1608 | 1 | style.attr = ~0u; | |
1609 | 1 | term_set_style(&term, style); | |
1610 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, longest, n); | |
1611 | 1 | EXPECT_EQ(obuf->x, 0); | |
1612 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1613 | |||
1614 | 1 | style.fg = COLOR_DEFAULT; | |
1615 | 1 | style.bg = COLOR_DEFAULT; | |
1616 | 1 | style.attr = ATTR_REVERSE | ATTR_DIM | ATTR_UNDERLINE | ATTR_KEEP; | |
1617 | 1 | term.ncv_attributes = ATTR_DIM | ATTR_STRIKETHROUGH; | |
1618 | 1 | term_set_style(&term, style); | |
1619 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;2;4;7m", 10); | |
1620 | 1 | EXPECT_EQ(obuf->x, 0); | |
1621 | 1 | style.attr &= ~ATTR_KEEP; | |
1622 | 1 | EXPECT_TRUE(same_style(&obuf->style, &style)); | |
1623 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1624 | |||
1625 | 1 | style.fg = COLOR_BLUE; | |
1626 | 1 | term_set_style(&term, style); | |
1627 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, "\033[0;4;7;34m", 11); | |
1628 | 1 | EXPECT_EQ(obuf->x, 0); | |
1629 | 1 | style.attr &= ~ATTR_DIM; | |
1630 | 1 | EXPECT_TRUE(same_style(&obuf->style, &style)); | |
1631 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1632 | 1 | } | |
1633 | |||
1634 | 1 | static void test_term_osc52_copy(TestContext *ctx) | |
1635 | { | ||
1636 | 1 | TermOutputBuffer obuf = TERM_OUTPUT_INIT; | |
1637 | 1 | StringView text = strview("foobar"); | |
1638 | 1 | EXPECT_TRUE(term_osc52_copy(&obuf, text, TCOPY_CLIPBOARD | TCOPY_PRIMARY)); | |
1639 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, "\033]52;pc;Zm9vYmFy\033\\", 18); | |
1640 | 1 | EXPECT_EQ(obuf.x, 0); | |
1641 | 1 | ASSERT_TRUE(clear_obuf(&obuf)); | |
1642 | |||
1643 | 1 | text = strview("\xF0\x9F\xA5\xA3"); | |
1644 | 1 | EXPECT_TRUE(term_osc52_copy(&obuf, text, TCOPY_PRIMARY)); | |
1645 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, "\033]52;p;8J+low==\033\\", 17); | |
1646 | 1 | EXPECT_EQ(obuf.x, 0); | |
1647 | 1 | ASSERT_TRUE(clear_obuf(&obuf)); | |
1648 | |||
1649 | 1 | text = strview(""); | |
1650 | 1 | EXPECT_TRUE(term_osc52_copy(&obuf, text, TCOPY_CLIPBOARD)); | |
1651 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, "\033]52;c;\033\\", 9); | |
1652 | 1 | EXPECT_EQ(obuf.x, 0); | |
1653 | 1 | ASSERT_TRUE(clear_obuf(&obuf)); | |
1654 | 1 | } | |
1655 | |||
1656 | 1 | static void test_term_set_cursor_style(TestContext *ctx) | |
1657 | { | ||
1658 | 1 | Terminal term = { | |
1659 | .width = 80, | ||
1660 | .height = 24, | ||
1661 | .obuf = TERM_OUTPUT_INIT, | ||
1662 | }; | ||
1663 | |||
1664 | 1 | TermCursorStyle style = { | |
1665 | .type = CURSOR_STEADY_BAR, | ||
1666 | .color = COLOR_RGB(0x22AACC), | ||
1667 | }; | ||
1668 | |||
1669 | 1 | static const char expected[] = "\033[6 q\033]12;rgb:22/aa/cc\033\\"; | |
1670 | 1 | size_t expected_len = sizeof(expected) - 1; | |
1671 | 1 | ASSERT_EQ(expected_len, 24); | |
1672 | |||
1673 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1674 | 1 | memset(obuf->buf, '@', expected_len + 16); | |
1675 | |||
1676 | 1 | term_set_cursor_style(&term, style); | |
1677 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, expected, expected_len); | |
1678 | 1 | EXPECT_EQ(obuf->x, 0); | |
1679 | 1 | EXPECT_EQ(obuf->cursor_style.type, style.type); | |
1680 | 1 | EXPECT_EQ(obuf->cursor_style.color, style.color); | |
1681 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1682 | 1 | } | |
1683 | |||
1684 | 1 | static void test_term_restore_cursor_style(TestContext *ctx) | |
1685 | { | ||
1686 | 1 | Terminal term = { | |
1687 | .width = 80, | ||
1688 | .height = 24, | ||
1689 | .obuf = TERM_OUTPUT_INIT, | ||
1690 | }; | ||
1691 | |||
1692 | 1 | static const char expected[] = "\033[0 q\033]112\033\\"; | |
1693 | 1 | size_t expected_len = sizeof(expected) - 1; | |
1694 | 1 | ASSERT_EQ(expected_len, 12); | |
1695 | |||
1696 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1697 | 1 | memset(obuf->buf, '@', expected_len + 16); | |
1698 | |||
1699 | 1 | term_restore_cursor_style(&term); | |
1700 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, expected, expected_len); | |
1701 | 1 | EXPECT_EQ(obuf->x, 0); | |
1702 | 1 | ASSERT_TRUE(clear_obuf(obuf)); | |
1703 | 1 | } | |
1704 | |||
1705 | 1 | static void test_term_begin_sync_update(TestContext *ctx) | |
1706 | { | ||
1707 | 1 | Terminal term = {.obuf = TERM_OUTPUT_INIT}; | |
1708 | 1 | term_init(&term, "xterm-kitty", NULL); | |
1709 | 1 | EXPECT_TRUE(term.features & TFLAG_SYNC); | |
1710 | |||
1711 | 1 | static const char expected[] = | |
1712 | "\033[?2026h" | ||
1713 | "\033[?1049h" | ||
1714 | "\033[?25l" | ||
1715 | "\033[?25h" | ||
1716 | "\033[?1049l" | ||
1717 | "\033[?2026l" | ||
1718 | ; | ||
1719 | |||
1720 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1721 | 1 | memset(obuf->buf, '.', 128); | |
1722 | |||
1723 | 1 | term_begin_sync_update(&term); | |
1724 | 1 | term_use_alt_screen_buffer(&term); | |
1725 | 1 | term_hide_cursor(&term); | |
1726 | 1 | term_show_cursor(&term); | |
1727 | 1 | term_use_normal_screen_buffer(&term); | |
1728 | 1 | term_end_sync_update(&term); | |
1729 | |||
1730 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, expected, sizeof(expected) - 1); | |
1731 | 1 | EXPECT_EQ(obuf->x, 0); | |
1732 | 1 | } | |
1733 | |||
1734 | 1 | static void test_term_put_level_1_queries(TestContext *ctx) | |
1735 | { | ||
1736 | 1 | enum { | |
1737 | // Short aliases for TermFeatureFlags: | ||
1738 | BCE = TFLAG_BACK_COLOR_ERASE, | ||
1739 | TITLE = TFLAG_SET_WINDOW_TITLE, | ||
1740 | OSC52 = TFLAG_OSC52_COPY, | ||
1741 | C8 = TFLAG_8_COLOR, | ||
1742 | C16 = TFLAG_16_COLOR | C8, | ||
1743 | C256 = TFLAG_256_COLOR | C16, | ||
1744 | }; | ||
1745 | |||
1746 | 1 | Terminal term = {.obuf = TERM_OUTPUT_INIT}; | |
1747 | 1 | TermOutputBuffer *obuf = &term.obuf; | |
1748 | 1 | term_init(&term, "xterm-256color", NULL); | |
1749 | 1 | EXPECT_UINT_EQ(term.features, (C256 | BCE | TITLE | OSC52)); | |
1750 | 1 | EXPECT_EQ(obuf->count, 0); | |
1751 | |||
1752 | // Basic level 1 queries | ||
1753 | 1 | static const char level1[] = "\033[c"; | |
1754 | 1 | term_put_initial_queries(&term, 1); | |
1755 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, level1, sizeof(level1) - 1); | |
1756 | |||
1757 | // All queries (forced by emit_all=true) | ||
1758 | 1 | static const char full[] = | |
1759 | // term_put_initial_queries() | ||
1760 | "\033[c" | ||
1761 | // term_put_level_2_queries() | ||
1762 | "\033[>0q" | ||
1763 | "\033[>c" | ||
1764 | "\033[?u" | ||
1765 | "\033[?1036$p" | ||
1766 | "\033[?1039$p" | ||
1767 | "\033[?2026$p" | ||
1768 | // term_put_level_2_queries() debug | ||
1769 | "\033[?4m" | ||
1770 | "\033[?7$p" | ||
1771 | "\033[?25$p" | ||
1772 | "\033[?45$p" | ||
1773 | "\033[?67$p" | ||
1774 | "\033[?1049$p" | ||
1775 | "\033[?2004$p" | ||
1776 | "\033[18t" | ||
1777 | // term_put_level_3_queries() | ||
1778 | "\033[0;38;2;60;70;80;48;5;255m" | ||
1779 | "\033P$qm\033\\" | ||
1780 | "\033[0m" | ||
1781 | "\033P+q626365\033\\" | ||
1782 | "\033P+q726570\033\\" | ||
1783 | "\033P+q74736C\033\\" | ||
1784 | "\033P+q4D73\033\\" | ||
1785 | // term_put_level_3_queries() debug | ||
1786 | "\033P$q q\033\\" | ||
1787 | ; | ||
1788 | |||
1789 | 1 | obuf->count = 0; | |
1790 | 1 | term_put_initial_queries(&term, 6); | |
1791 | 1 | EXPECT_MEMEQ(obuf->buf, obuf->count, full, sizeof(full) - 1); | |
1792 | |||
1793 | 1 | EXPECT_EQ(obuf->scroll_x, 0); | |
1794 | 1 | EXPECT_EQ(obuf->x, 0); | |
1795 | 1 | } | |
1796 | |||
1797 | 1 | static void test_update_term_title(TestContext *ctx) | |
1798 | { | ||
1799 | 1 | static const char prefix[] = "\033]2;"; | |
1800 | 1 | static const char suffix[] = " - dte\033\\"; | |
1801 | 1 | size_t plen = sizeof(prefix) - 1; | |
1802 | 1 | size_t slen = sizeof(suffix) - 1; | |
1803 | 1 | TermOutputBuffer obuf = TERM_OUTPUT_INIT; | |
1804 | |||
1805 | 1 | static const char expected1[] = "\033]2;example filename - dte\033\\"; | |
1806 | 1 | update_term_title(&obuf, "example filename", false); | |
1807 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, expected1, sizeof(expected1) - 1); | |
1808 | 1 | EXPECT_EQ(obuf.x, 0); | |
1809 | 1 | obuf.count = 0; | |
1810 | |||
1811 | // Control char escaping | ||
1812 | 1 | static const char expected2[] = "\033]2;x^I^H^[y - dte\033\\"; | |
1813 | 1 | update_term_title(&obuf, "x\t\b\033y", false); | |
1814 | 1 | EXPECT_MEMEQ(obuf.buf, obuf.count, expected2, sizeof(expected2) - 1); | |
1815 | 1 | EXPECT_EQ(obuf.x, 0); | |
1816 | 1 | obuf.count = 0; | |
1817 | |||
1818 | // Very long filename, for edge case coverage | ||
1819 | 1 | char filename[TERM_OUTBUF_SIZE]; | |
1820 | 1 | memset(filename, 'a', sizeof(filename)); | |
1821 | 1 | filename[sizeof(filename) - 1] = '\0'; | |
1822 | 1 | update_term_title(&obuf, filename, false); | |
1823 | |||
1824 | 1 | size_t tlen = obuf.count - (plen + slen); | |
1825 | 1 | EXPECT_EQ(sizeof(filename), 8192); | |
1826 | 1 | EXPECT_EQ(obuf.count, 8188); | |
1827 | 1 | EXPECT_EQ(tlen, 8176); | |
1828 | 1 | EXPECT_MEMEQ(obuf.buf, plen, prefix, plen); | |
1829 | 1 | EXPECT_MEMEQ(obuf.buf + plen, tlen, filename, tlen); | |
1830 | 1 | EXPECT_MEMEQ(obuf.buf + plen + tlen, slen, suffix, slen); | |
1831 | 1 | } | |
1832 | |||
1833 | 1 | static void test_is_newly_detected_feature(TestContext *ctx) | |
1834 | { | ||
1835 | 1 | EXPECT_FALSE(is_newly_detected_feature(1, 1, 1)); | |
1836 | 1 | EXPECT_FALSE(is_newly_detected_feature(1, 2, 1)); | |
1837 | 1 | EXPECT_FALSE(is_newly_detected_feature(3, 1, 1)); | |
1838 | 1 | EXPECT_FALSE(is_newly_detected_feature(1, 3, 1)); | |
1839 | 1 | EXPECT_FALSE(is_newly_detected_feature(0, 6, 1)); | |
1840 | 1 | EXPECT_TRUE(is_newly_detected_feature(0, 1, 1)); | |
1841 | 1 | EXPECT_TRUE(is_newly_detected_feature(2, 1, 1)); | |
1842 | 1 | EXPECT_TRUE(is_newly_detected_feature(3, 4, 4)); | |
1843 | 1 | } | |
1844 | |||
1845 | static const TestEntry tests[] = { | ||
1846 | TEST(test_parse_rgb), | ||
1847 | TEST(test_parse_term_style), | ||
1848 | TEST(test_color_to_nearest), | ||
1849 | TEST(test_color_to_str), | ||
1850 | TEST(test_term_style_to_string), | ||
1851 | TEST(test_cursor_mode_from_str), | ||
1852 | TEST(test_cursor_type_from_str), | ||
1853 | TEST(test_cursor_color_from_str), | ||
1854 | TEST(test_cursor_color_to_str), | ||
1855 | TEST(test_same_cursor), | ||
1856 | TEST(test_mask_style), | ||
1857 | TEST(test_term_parse_csi_params), | ||
1858 | TEST(test_term_parse_sequence), | ||
1859 | TEST(test_term_parse_sequence2), | ||
1860 | TEST(test_rxvt_parse_key), | ||
1861 | TEST(test_linux_parse_key), | ||
1862 | TEST(test_keycode_to_string), | ||
1863 | TEST(test_parse_key_string), | ||
1864 | TEST(test_term_init), | ||
1865 | TEST(test_term_put_str), | ||
1866 | TEST(test_term_clear_eol), | ||
1867 | TEST(test_term_move_cursor), | ||
1868 | TEST(test_term_set_bytes), | ||
1869 | TEST(test_term_set_style), | ||
1870 | TEST(test_term_osc52_copy), | ||
1871 | TEST(test_term_set_cursor_style), | ||
1872 | TEST(test_term_restore_cursor_style), | ||
1873 | TEST(test_term_begin_sync_update), | ||
1874 | TEST(test_term_put_level_1_queries), | ||
1875 | TEST(test_update_term_title), | ||
1876 | TEST(test_is_newly_detected_feature), | ||
1877 | }; | ||
1878 | |||
1879 | const TestGroup terminal_tests = TEST_GROUP(tests); | ||
1880 |