dte test coverage

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