dte test coverage

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