Mercurial

comparison third_party/libuv/test/test-tty-escape-sequence-processing.c @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
1 /* Copyright libuv project contributors. All rights reserved.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to
5 * deal in the Software without restriction, including without limitation the
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 * sell copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 * IN THE SOFTWARE.
20 */
21
22 #ifdef _WIN32
23
24 #include "task.h"
25 #include "uv.h"
26
27 #include <io.h>
28 #include <windows.h>
29
30 #include <errno.h>
31 #include <string.h>
32
33 #define ESC "\033"
34 #define CSI ESC "["
35 #define ST ESC "\\"
36 #define BEL "\x07"
37 #define HELLO "Hello"
38
39 #define FOREGROUND_WHITE (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
40 #define FOREGROUND_BLACK 0
41 #define FOREGROUND_YELLOW (FOREGROUND_RED | FOREGROUND_GREEN)
42 #define FOREGROUND_CYAN (FOREGROUND_GREEN | FOREGROUND_BLUE)
43 #define FOREGROUND_MAGENTA (FOREGROUND_RED | FOREGROUND_BLUE)
44 #define BACKGROUND_WHITE (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
45 #define BACKGROUND_BLACK 0
46 #define BACKGROUND_YELLOW (BACKGROUND_RED | BACKGROUND_GREEN)
47 #define BACKGROUND_CYAN (BACKGROUND_GREEN | BACKGROUND_BLUE)
48 #define BACKGROUND_MAGENTA (BACKGROUND_RED | BACKGROUND_BLUE)
49
50 #define F_INTENSITY 1
51 #define FB_INTENSITY 2
52 #define B_INTENSITY 5
53 #define INVERSE 7
54 #define F_INTENSITY_OFF1 21
55 #define F_INTENSITY_OFF2 22
56 #define B_INTENSITY_OFF 25
57 #define INVERSE_OFF 27
58 #define F_BLACK 30
59 #define F_RED 31
60 #define F_GREEN 32
61 #define F_YELLOW 33
62 #define F_BLUE 34
63 #define F_MAGENTA 35
64 #define F_CYAN 36
65 #define F_WHITE 37
66 #define F_DEFAULT 39
67 #define B_BLACK 40
68 #define B_RED 41
69 #define B_GREEN 42
70 #define B_YELLOW 43
71 #define B_BLUE 44
72 #define B_MAGENTA 45
73 #define B_CYAN 46
74 #define B_WHITE 47
75 #define B_DEFAULT 49
76
77 #define CURSOR_SIZE_SMALL 25
78 #define CURSOR_SIZE_MIDDLE 50
79 #define CURSOR_SIZE_LARGE 100
80
81 struct screen_info {
82 CONSOLE_SCREEN_BUFFER_INFO csbi;
83 int top;
84 int width;
85 int height;
86 int length;
87 WORD default_attr;
88 };
89
90 struct captured_screen {
91 char* text;
92 WORD* attributes;
93 struct screen_info si;
94 };
95
96 static void get_screen_info(uv_tty_t* tty_out, struct screen_info* si) {
97 ASSERT(GetConsoleScreenBufferInfo(tty_out->handle, &(si->csbi)));
98 si->width = si->csbi.dwSize.X;
99 si->height = si->csbi.srWindow.Bottom - si->csbi.srWindow.Top + 1;
100 si->length = si->width * si->height;
101 si->default_attr = si->csbi.wAttributes;
102 si->top = si->csbi.srWindow.Top;
103 }
104
105 static void set_cursor_position(uv_tty_t* tty_out, COORD pos) {
106 HANDLE handle = tty_out->handle;
107 CONSOLE_SCREEN_BUFFER_INFO info;
108 ASSERT(GetConsoleScreenBufferInfo(handle, &info));
109 pos.X -= 1;
110 pos.Y += info.srWindow.Top - 1;
111 ASSERT(SetConsoleCursorPosition(handle, pos));
112 }
113
114 static void get_cursor_position(uv_tty_t* tty_out, COORD* cursor_position) {
115 HANDLE handle = tty_out->handle;
116 CONSOLE_SCREEN_BUFFER_INFO info;
117 ASSERT(GetConsoleScreenBufferInfo(handle, &info));
118 cursor_position->X = info.dwCursorPosition.X + 1;
119 cursor_position->Y = info.dwCursorPosition.Y - info.srWindow.Top + 1;
120 }
121
122 static void set_cursor_to_home(uv_tty_t* tty_out) {
123 COORD origin = {1, 1};
124 set_cursor_position(tty_out, origin);
125 }
126
127 static CONSOLE_CURSOR_INFO get_cursor_info(uv_tty_t* tty_out) {
128 HANDLE handle = tty_out->handle;
129 CONSOLE_CURSOR_INFO info;
130 ASSERT(GetConsoleCursorInfo(handle, &info));
131 return info;
132 }
133
134 static void set_cursor_size(uv_tty_t* tty_out, DWORD size) {
135 CONSOLE_CURSOR_INFO info = get_cursor_info(tty_out);
136 info.dwSize = size;
137 ASSERT(SetConsoleCursorInfo(tty_out->handle, &info));
138 }
139
140 static DWORD get_cursor_size(uv_tty_t* tty_out) {
141 return get_cursor_info(tty_out).dwSize;
142 }
143
144 static void set_cursor_visibility(uv_tty_t* tty_out, BOOL visible) {
145 CONSOLE_CURSOR_INFO info = get_cursor_info(tty_out);
146 info.bVisible = visible;
147 ASSERT(SetConsoleCursorInfo(tty_out->handle, &info));
148 }
149
150 static BOOL get_cursor_visibility(uv_tty_t* tty_out) {
151 return get_cursor_info(tty_out).bVisible;
152 }
153
154 static BOOL is_scrolling(uv_tty_t* tty_out, struct screen_info si) {
155 CONSOLE_SCREEN_BUFFER_INFO info;
156 ASSERT(GetConsoleScreenBufferInfo(tty_out->handle, &info));
157 return info.srWindow.Top != si.top;
158 }
159
160 static void write_console(uv_tty_t* tty_out, char* src) {
161 int r;
162 uv_buf_t buf;
163
164 buf.base = src;
165 buf.len = strlen(buf.base);
166
167 r = uv_try_write((uv_stream_t*) tty_out, &buf, 1);
168 ASSERT_GE(r, 0);
169 ASSERT_EQ((unsigned int) r, buf.len);
170 }
171
172 static void setup_screen(uv_tty_t* tty_out) {
173 DWORD length, number_of_written;
174 COORD origin;
175 CONSOLE_SCREEN_BUFFER_INFO info;
176 ASSERT(GetConsoleScreenBufferInfo(tty_out->handle, &info));
177 length = info.dwSize.X * (info.srWindow.Bottom - info.srWindow.Top + 1);
178 origin.X = 0;
179 origin.Y = info.srWindow.Top;
180 ASSERT(FillConsoleOutputCharacter(
181 tty_out->handle, '.', length, origin, &number_of_written));
182 ASSERT_EQ(length, number_of_written);
183 }
184
185 static void clear_screen(uv_tty_t* tty_out, struct screen_info* si) {
186 DWORD length, number_of_written;
187 COORD origin;
188 CONSOLE_SCREEN_BUFFER_INFO info;
189 ASSERT(GetConsoleScreenBufferInfo(tty_out->handle, &info));
190 length = (info.srWindow.Bottom - info.srWindow.Top + 1) * info.dwSize.X - 1;
191 origin.X = 0;
192 origin.Y = info.srWindow.Top;
193 FillConsoleOutputCharacterA(
194 tty_out->handle, ' ', length, origin, &number_of_written);
195 ASSERT_EQ(length, number_of_written);
196 FillConsoleOutputAttribute(
197 tty_out->handle, si->default_attr, length, origin, &number_of_written);
198 ASSERT_EQ(length, number_of_written);
199 }
200
201 static void free_screen(struct captured_screen* cs) {
202 free(cs->text);
203 cs->text = NULL;
204 free(cs->attributes);
205 cs->attributes = NULL;
206 }
207
208 static void capture_screen(uv_tty_t* tty_out, struct captured_screen* cs) {
209 DWORD length;
210 COORD origin;
211 get_screen_info(tty_out, &(cs->si));
212 origin.X = 0;
213 origin.Y = cs->si.csbi.srWindow.Top;
214 cs->text = malloc(cs->si.length * sizeof(*cs->text));
215 ASSERT_NOT_NULL(cs->text);
216 cs->attributes = (WORD*) malloc(cs->si.length * sizeof(*cs->attributes));
217 ASSERT_NOT_NULL(cs->attributes);
218 ASSERT(ReadConsoleOutputCharacter(
219 tty_out->handle, cs->text, cs->si.length, origin, &length));
220 ASSERT_EQ((unsigned int) cs->si.length, length);
221 ASSERT(ReadConsoleOutputAttribute(
222 tty_out->handle, cs->attributes, cs->si.length, origin, &length));
223 ASSERT_EQ((unsigned int) cs->si.length, length);
224 }
225
226 static void make_expect_screen_erase(struct captured_screen* cs,
227 COORD cursor_position,
228 int dir,
229 BOOL entire_screen) {
230 /* beginning of line */
231 char* start;
232 char* end;
233 start = cs->text + cs->si.width * (cursor_position.Y - 1);
234 if (dir == 0) {
235 if (entire_screen) {
236 /* erase to end of screen */
237 end = cs->text + cs->si.length;
238 } else {
239 /* erase to end of line */
240 end = start + cs->si.width;
241 }
242 /* erase from postition of cursor */
243 start += cursor_position.X - 1;
244 } else if (dir == 1) {
245 /* erase to position of cursor */
246 end = start + cursor_position.X;
247 if (entire_screen) {
248 /* erase form beginning of screen */
249 start = cs->text;
250 }
251 } else if (dir == 2) {
252 if (entire_screen) {
253 /* erase form beginning of screen */
254 start = cs->text;
255 /* erase to end of screen */
256 end = cs->text + cs->si.length;
257 } else {
258 /* erase to end of line */
259 end = start + cs->si.width;
260 }
261 } else {
262 ASSERT(FALSE);
263 }
264 ASSERT_PTR_LT(start, end);
265 ASSERT_LE(end - cs->text, cs->si.length);
266 for (; start < end; start++) {
267 *start = ' ';
268 }
269 }
270
271 static void make_expect_screen_write(struct captured_screen* cs,
272 COORD cursor_position,
273 const char* text) {
274 /* position of cursor */
275 char* start;
276 start = cs->text + cs->si.width * (cursor_position.Y - 1) +
277 cursor_position.X - 1;
278 size_t length = strlen(text);
279 size_t remain_length = cs->si.length - (cs->text - start);
280 length = length > remain_length ? remain_length : length;
281 memcpy(start, text, length);
282 }
283
284 static void make_expect_screen_set_attr(struct captured_screen* cs,
285 COORD cursor_position,
286 size_t length,
287 WORD attr) {
288 WORD* start;
289 start = cs->attributes + cs->si.width * (cursor_position.Y - 1) +
290 cursor_position.X - 1;
291 size_t remain_length = cs->si.length - (cs->attributes - start);
292 length = length > remain_length ? remain_length : length;
293 while (length) {
294 *start = attr;
295 start++;
296 length--;
297 }
298 }
299
300 static BOOL compare_screen(uv_tty_t* tty_out,
301 struct captured_screen* actual,
302 struct captured_screen* expect) {
303 int line, col;
304 BOOL result = TRUE;
305 int current = 0;
306 ASSERT(actual->text);
307 ASSERT(actual->attributes);
308 ASSERT(expect->text);
309 ASSERT(expect->attributes);
310 if (actual->si.length != expect->si.length) {
311 return FALSE;
312 }
313 if (actual->si.width != expect->si.width) {
314 return FALSE;
315 }
316 if (actual->si.height != expect->si.height) {
317 return FALSE;
318 }
319 while (current < actual->si.length) {
320 if (*(actual->text + current) != *(expect->text + current)) {
321 line = current / actual->si.width + 1;
322 col = current - actual->si.width * (line - 1) + 1;
323 fprintf(stderr,
324 "line:%d col:%d expected character '%c' but found '%c'\n",
325 line,
326 col,
327 *(expect->text + current),
328 *(actual->text + current));
329 result = FALSE;
330 }
331 if (*(actual->attributes + current) != *(expect->attributes + current)) {
332 line = current / actual->si.width + 1;
333 col = current - actual->si.width * (line - 1) + 1;
334 fprintf(stderr,
335 "line:%d col:%d expected attributes '%u' but found '%u'\n",
336 line,
337 col,
338 *(expect->attributes + current),
339 *(actual->attributes + current));
340 result = FALSE;
341 }
342 current++;
343 }
344 clear_screen(tty_out, &expect->si);
345 free_screen(expect);
346 free_screen(actual);
347 return result;
348 }
349
350 static void initialize_tty(uv_tty_t* tty_out) {
351 int r;
352 int ttyout_fd;
353 /* Make sure we have an FD that refers to a tty */
354 HANDLE handle;
355
356 uv_tty_set_vterm_state(UV_TTY_UNSUPPORTED);
357
358 handle = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
359 FILE_SHARE_READ | FILE_SHARE_WRITE,
360 NULL,
361 CONSOLE_TEXTMODE_BUFFER,
362 NULL);
363 ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE);
364
365 ttyout_fd = _open_osfhandle((intptr_t) handle, 0);
366 ASSERT_GE(ttyout_fd, 0);
367 ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd));
368 r = uv_tty_init(uv_default_loop(), tty_out, ttyout_fd, 0); /* Writable. */
369 ASSERT_OK(r);
370 }
371
372 static void terminate_tty(uv_tty_t* tty_out) {
373 set_cursor_to_home(tty_out);
374 uv_close((uv_handle_t*) tty_out, NULL);
375 }
376
377 TEST_IMPL(tty_cursor_up) {
378 uv_tty_t tty_out;
379 uv_loop_t* loop;
380 COORD cursor_pos, cursor_pos_old;
381 char buffer[1024];
382 struct screen_info si;
383
384 loop = uv_default_loop();
385
386 initialize_tty(&tty_out);
387 get_screen_info(&tty_out, &si);
388
389 cursor_pos_old.X = si.width / 2;
390 cursor_pos_old.Y = si.height / 2;
391 set_cursor_position(&tty_out, cursor_pos_old);
392
393 /* cursor up one times if omitted arguments */
394 snprintf(buffer, sizeof(buffer), "%sA", CSI);
395 write_console(&tty_out, buffer);
396 get_cursor_position(&tty_out, &cursor_pos);
397 ASSERT_EQ(cursor_pos_old.Y - 1, cursor_pos.Y);
398 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
399
400 /* cursor up nth times */
401 cursor_pos_old = cursor_pos;
402 snprintf(buffer, sizeof(buffer), "%s%dA", CSI, si.height / 4);
403 write_console(&tty_out, buffer);
404 get_cursor_position(&tty_out, &cursor_pos);
405 ASSERT_EQ(cursor_pos_old.Y - si.height / 4, cursor_pos.Y);
406 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
407
408 /* cursor up from Window top does nothing */
409 cursor_pos_old.X = 1;
410 cursor_pos_old.Y = 1;
411 set_cursor_position(&tty_out, cursor_pos_old);
412 snprintf(buffer, sizeof(buffer), "%sA", CSI);
413 write_console(&tty_out, buffer);
414 get_cursor_position(&tty_out, &cursor_pos);
415 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
416 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
417 ASSERT(!is_scrolling(&tty_out, si));
418
419 terminate_tty(&tty_out);
420
421 uv_run(loop, UV_RUN_DEFAULT);
422
423 MAKE_VALGRIND_HAPPY(loop);
424 return 0;
425 }
426
427
428 TEST_IMPL(tty_cursor_down) {
429 uv_tty_t tty_out;
430 uv_loop_t* loop;
431 COORD cursor_pos, cursor_pos_old;
432 char buffer[1024];
433 struct screen_info si;
434
435 loop = uv_default_loop();
436
437 initialize_tty(&tty_out);
438 get_screen_info(&tty_out, &si);
439
440 cursor_pos_old.X = si.width / 2;
441 cursor_pos_old.Y = si.height / 2;
442 set_cursor_position(&tty_out, cursor_pos_old);
443
444 /* cursor down one times if omitted arguments */
445 snprintf(buffer, sizeof(buffer), "%sB", CSI);
446 write_console(&tty_out, buffer);
447 get_cursor_position(&tty_out, &cursor_pos);
448 ASSERT_EQ(cursor_pos_old.Y + 1, cursor_pos.Y);
449 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
450
451 /* cursor down nth times */
452 cursor_pos_old = cursor_pos;
453 snprintf(buffer, sizeof(buffer), "%s%dB", CSI, si.height / 4);
454 write_console(&tty_out, buffer);
455 get_cursor_position(&tty_out, &cursor_pos);
456 ASSERT_EQ(cursor_pos_old.Y + si.height / 4, cursor_pos.Y);
457 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
458
459 /* cursor down from bottom line does nothing */
460 cursor_pos_old.X = si.width / 2;
461 cursor_pos_old.Y = si.height;
462 set_cursor_position(&tty_out, cursor_pos_old);
463 snprintf(buffer, sizeof(buffer), "%sB", CSI);
464 write_console(&tty_out, buffer);
465 get_cursor_position(&tty_out, &cursor_pos);
466 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
467 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
468 ASSERT(!is_scrolling(&tty_out, si));
469
470 terminate_tty(&tty_out);
471
472 uv_run(loop, UV_RUN_DEFAULT);
473
474 MAKE_VALGRIND_HAPPY(loop);
475 return 0;
476 }
477
478
479 TEST_IMPL(tty_cursor_forward) {
480 uv_tty_t tty_out;
481 uv_loop_t* loop;
482 COORD cursor_pos, cursor_pos_old;
483 char buffer[1024];
484 struct screen_info si;
485
486 loop = uv_default_loop();
487
488 initialize_tty(&tty_out);
489 get_screen_info(&tty_out, &si);
490
491 cursor_pos_old.X = si.width / 2;
492 cursor_pos_old.Y = si.height / 2;
493 set_cursor_position(&tty_out, cursor_pos_old);
494
495 /* cursor forward one times if omitted arguments */
496 snprintf(buffer, sizeof(buffer), "%sC", CSI);
497 write_console(&tty_out, buffer);
498 get_cursor_position(&tty_out, &cursor_pos);
499 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
500 ASSERT_EQ(cursor_pos_old.X + 1, cursor_pos.X);
501
502 /* cursor forward nth times */
503 cursor_pos_old = cursor_pos;
504 snprintf(buffer, sizeof(buffer), "%s%dC", CSI, si.width / 4);
505 write_console(&tty_out, buffer);
506 get_cursor_position(&tty_out, &cursor_pos);
507 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
508 ASSERT_EQ(cursor_pos_old.X + si.width / 4, cursor_pos.X);
509
510 /* cursor forward from end of line does nothing*/
511 cursor_pos_old.X = si.width;
512 cursor_pos_old.Y = si.height / 2;
513 set_cursor_position(&tty_out, cursor_pos_old);
514 snprintf(buffer, sizeof(buffer), "%sC", CSI);
515 write_console(&tty_out, buffer);
516 get_cursor_position(&tty_out, &cursor_pos);
517 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
518 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
519
520 /* cursor forward from end of screen does nothing */
521 cursor_pos_old.X = si.width;
522 cursor_pos_old.Y = si.height;
523 set_cursor_position(&tty_out, cursor_pos_old);
524 snprintf(buffer, sizeof(buffer), "%sC", CSI);
525 write_console(&tty_out, buffer);
526 get_cursor_position(&tty_out, &cursor_pos);
527 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
528 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
529 ASSERT(!is_scrolling(&tty_out, si));
530
531 terminate_tty(&tty_out);
532
533 uv_run(loop, UV_RUN_DEFAULT);
534
535 MAKE_VALGRIND_HAPPY(loop);
536 return 0;
537 }
538
539
540 TEST_IMPL(tty_cursor_back) {
541 uv_tty_t tty_out;
542 uv_loop_t* loop;
543 COORD cursor_pos, cursor_pos_old;
544 char buffer[1024];
545 struct screen_info si;
546
547 loop = uv_default_loop();
548
549 initialize_tty(&tty_out);
550 get_screen_info(&tty_out, &si);
551
552 cursor_pos_old.X = si.width / 2;
553 cursor_pos_old.Y = si.height / 2;
554 set_cursor_position(&tty_out, cursor_pos_old);
555
556 /* cursor back one times if omitted arguments */
557 snprintf(buffer, sizeof(buffer), "%sD", CSI);
558 write_console(&tty_out, buffer);
559 get_cursor_position(&tty_out, &cursor_pos);
560 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
561 ASSERT_EQ(cursor_pos_old.X - 1, cursor_pos.X);
562
563 /* cursor back nth times */
564 cursor_pos_old = cursor_pos;
565 snprintf(buffer, sizeof(buffer), "%s%dD", CSI, si.width / 4);
566 write_console(&tty_out, buffer);
567 get_cursor_position(&tty_out, &cursor_pos);
568 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
569 ASSERT_EQ(cursor_pos_old.X - si.width / 4, cursor_pos.X);
570
571 /* cursor back from beginning of line does nothing */
572 cursor_pos_old.X = 1;
573 cursor_pos_old.Y = si.height / 2;
574 set_cursor_position(&tty_out, cursor_pos_old);
575 snprintf(buffer, sizeof(buffer), "%sD", CSI);
576 write_console(&tty_out, buffer);
577 get_cursor_position(&tty_out, &cursor_pos);
578 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
579 ASSERT_EQ(cursor_pos_old.X, cursor_pos.X);
580
581 /* cursor back from top of screen does nothing */
582 cursor_pos_old.X = 1;
583 cursor_pos_old.Y = 1;
584 set_cursor_position(&tty_out, cursor_pos_old);
585 snprintf(buffer, sizeof(buffer), "%sD", CSI);
586 write_console(&tty_out, buffer);
587 get_cursor_position(&tty_out, &cursor_pos);
588 ASSERT_EQ(1, cursor_pos.Y);
589 ASSERT_EQ(1, cursor_pos.X);
590 ASSERT(!is_scrolling(&tty_out, si));
591
592 terminate_tty(&tty_out);
593
594 uv_run(loop, UV_RUN_DEFAULT);
595
596 MAKE_VALGRIND_HAPPY(loop);
597 return 0;
598 }
599
600
601 TEST_IMPL(tty_cursor_next_line) {
602 uv_tty_t tty_out;
603 uv_loop_t* loop;
604 COORD cursor_pos, cursor_pos_old;
605 char buffer[1024];
606 struct screen_info si;
607
608 loop = uv_default_loop();
609
610 initialize_tty(&tty_out);
611 get_screen_info(&tty_out, &si);
612
613 cursor_pos_old.X = si.width / 2;
614 cursor_pos_old.Y = si.height / 2;
615 set_cursor_position(&tty_out, cursor_pos_old);
616
617 /* cursor next line one times if omitted arguments */
618 snprintf(buffer, sizeof(buffer), "%sE", CSI);
619 write_console(&tty_out, buffer);
620 get_cursor_position(&tty_out, &cursor_pos);
621 ASSERT_EQ(cursor_pos_old.Y + 1, cursor_pos.Y);
622 ASSERT_EQ(1, cursor_pos.X);
623
624 /* cursor next line nth times */
625 cursor_pos_old = cursor_pos;
626 snprintf(buffer, sizeof(buffer), "%s%dE", CSI, si.height / 4);
627 write_console(&tty_out, buffer);
628 get_cursor_position(&tty_out, &cursor_pos);
629 ASSERT_EQ(cursor_pos_old.Y + si.height / 4, cursor_pos.Y);
630 ASSERT_EQ(1, cursor_pos.X);
631
632 /* cursor next line from buttom row moves beginning of line */
633 cursor_pos_old.X = si.width / 2;
634 cursor_pos_old.Y = si.height;
635 set_cursor_position(&tty_out, cursor_pos_old);
636 snprintf(buffer, sizeof(buffer), "%sE", CSI);
637 write_console(&tty_out, buffer);
638 get_cursor_position(&tty_out, &cursor_pos);
639 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
640 ASSERT_EQ(1, cursor_pos.X);
641 ASSERT(!is_scrolling(&tty_out, si));
642
643 terminate_tty(&tty_out);
644
645 uv_run(loop, UV_RUN_DEFAULT);
646
647 MAKE_VALGRIND_HAPPY(loop);
648 return 0;
649 }
650
651
652 TEST_IMPL(tty_cursor_previous_line) {
653 uv_tty_t tty_out;
654 uv_loop_t* loop;
655 COORD cursor_pos, cursor_pos_old;
656 char buffer[1024];
657 struct screen_info si;
658
659 loop = uv_default_loop();
660
661 initialize_tty(&tty_out);
662 get_screen_info(&tty_out, &si);
663
664 cursor_pos_old.X = si.width / 2;
665 cursor_pos_old.Y = si.height / 2;
666 set_cursor_position(&tty_out, cursor_pos_old);
667
668 /* cursor previous line one times if omitted arguments */
669 snprintf(buffer, sizeof(buffer), "%sF", CSI);
670 write_console(&tty_out, buffer);
671 get_cursor_position(&tty_out, &cursor_pos);
672 ASSERT_EQ(cursor_pos_old.Y - 1, cursor_pos.Y);
673 ASSERT_EQ(1, cursor_pos.X);
674
675 /* cursor previous line nth times */
676 cursor_pos_old = cursor_pos;
677 snprintf(buffer, sizeof(buffer), "%s%dF", CSI, si.height / 4);
678 write_console(&tty_out, buffer);
679 get_cursor_position(&tty_out, &cursor_pos);
680 ASSERT_EQ(cursor_pos_old.Y - si.height / 4, cursor_pos.Y);
681 ASSERT_EQ(1, cursor_pos.X);
682
683 /* cursor previous line from top of screen does nothing */
684 cursor_pos_old.X = 1;
685 cursor_pos_old.Y = 1;
686 set_cursor_position(&tty_out, cursor_pos_old);
687 snprintf(buffer, sizeof(buffer), "%sD", CSI);
688 write_console(&tty_out, buffer);
689 get_cursor_position(&tty_out, &cursor_pos);
690 ASSERT_EQ(1, cursor_pos.Y);
691 ASSERT_EQ(1, cursor_pos.X);
692 ASSERT(!is_scrolling(&tty_out, si));
693
694 terminate_tty(&tty_out);
695
696 uv_run(loop, UV_RUN_DEFAULT);
697
698 MAKE_VALGRIND_HAPPY(loop);
699 return 0;
700 }
701
702
703 TEST_IMPL(tty_cursor_horizontal_move_absolute) {
704 uv_tty_t tty_out;
705 uv_loop_t* loop;
706 COORD cursor_pos, cursor_pos_old;
707 char buffer[1024];
708 struct screen_info si;
709
710 loop = uv_default_loop();
711
712 initialize_tty(&tty_out);
713 get_screen_info(&tty_out, &si);
714
715 cursor_pos_old.X = si.width / 2;
716 cursor_pos_old.Y = si.height / 2;
717 set_cursor_position(&tty_out, cursor_pos_old);
718
719 /* Move to beginning of line if omitted argument */
720 snprintf(buffer, sizeof(buffer), "%sG", CSI);
721 write_console(&tty_out, buffer);
722 get_cursor_position(&tty_out, &cursor_pos);
723 ASSERT_EQ(1, cursor_pos.X);
724 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
725
726 /* Move cursor to nth character */
727 snprintf(buffer, sizeof(buffer), "%s%dG", CSI, si.width / 4);
728 write_console(&tty_out, buffer);
729 get_cursor_position(&tty_out, &cursor_pos);
730 ASSERT_EQ(si.width / 4, cursor_pos.X);
731 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
732
733 /* Moving out of screen will fit within screen */
734 snprintf(buffer, sizeof(buffer), "%s%dG", CSI, si.width + 1);
735 write_console(&tty_out, buffer);
736 get_cursor_position(&tty_out, &cursor_pos);
737 ASSERT_EQ(si.width, cursor_pos.X);
738 ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y);
739
740 terminate_tty(&tty_out);
741
742 uv_run(loop, UV_RUN_DEFAULT);
743
744 MAKE_VALGRIND_HAPPY(loop);
745 return 0;
746 }
747
748
749 TEST_IMPL(tty_cursor_move_absolute) {
750 uv_tty_t tty_out;
751 uv_loop_t* loop;
752 COORD cursor_pos;
753 char buffer[1024];
754 struct screen_info si;
755
756 loop = uv_default_loop();
757
758 initialize_tty(&tty_out);
759 get_screen_info(&tty_out, &si);
760
761 cursor_pos.X = si.width / 2;
762 cursor_pos.Y = si.height / 2;
763 set_cursor_position(&tty_out, cursor_pos);
764
765 /* Move the cursor to home if omitted arguments */
766 snprintf(buffer, sizeof(buffer), "%sH", CSI);
767 write_console(&tty_out, buffer);
768 get_cursor_position(&tty_out, &cursor_pos);
769 ASSERT_EQ(1, cursor_pos.X);
770 ASSERT_EQ(1, cursor_pos.Y);
771
772 /* Move the cursor to the middle of the screen */
773 snprintf(
774 buffer, sizeof(buffer), "%s%d;%df", CSI, si.height / 2, si.width / 2);
775 write_console(&tty_out, buffer);
776 get_cursor_position(&tty_out, &cursor_pos);
777 ASSERT_EQ(si.width / 2, cursor_pos.X);
778 ASSERT_EQ(si.height / 2, cursor_pos.Y);
779
780 /* Moving out of screen will fit within screen */
781 snprintf(
782 buffer, sizeof(buffer), "%s%d;%df", CSI, si.height / 2, si.width + 1);
783 write_console(&tty_out, buffer);
784 get_cursor_position(&tty_out, &cursor_pos);
785 ASSERT_EQ(si.width, cursor_pos.X);
786 ASSERT_EQ(si.height / 2, cursor_pos.Y);
787
788 snprintf(
789 buffer, sizeof(buffer), "%s%d;%df", CSI, si.height + 1, si.width / 2);
790 write_console(&tty_out, buffer);
791 get_cursor_position(&tty_out, &cursor_pos);
792 ASSERT_EQ(si.width / 2, cursor_pos.X);
793 ASSERT_EQ(si.height, cursor_pos.Y);
794 ASSERT(!is_scrolling(&tty_out, si));
795
796 terminate_tty(&tty_out);
797
798 uv_run(loop, UV_RUN_DEFAULT);
799
800 MAKE_VALGRIND_HAPPY(loop);
801 return 0;
802 }
803
804
805 TEST_IMPL(tty_hide_show_cursor) {
806 uv_tty_t tty_out;
807 uv_loop_t* loop;
808 char buffer[1024];
809 BOOL saved_cursor_visibility;
810
811 loop = uv_default_loop();
812
813 initialize_tty(&tty_out);
814
815 saved_cursor_visibility = get_cursor_visibility(&tty_out);
816
817 /* Hide the cursor */
818 set_cursor_visibility(&tty_out, TRUE);
819 snprintf(buffer, sizeof(buffer), "%s?25l", CSI);
820 write_console(&tty_out, buffer);
821 ASSERT(!get_cursor_visibility(&tty_out));
822
823 /* Show the cursor */
824 set_cursor_visibility(&tty_out, FALSE);
825 snprintf(buffer, sizeof(buffer), "%s?25h", CSI);
826 write_console(&tty_out, buffer);
827 ASSERT(get_cursor_visibility(&tty_out));
828
829 set_cursor_visibility(&tty_out, saved_cursor_visibility);
830 terminate_tty(&tty_out);
831
832 uv_run(loop, UV_RUN_DEFAULT);
833
834 MAKE_VALGRIND_HAPPY(loop);
835 return 0;
836 }
837
838
839 TEST_IMPL(tty_erase) {
840 int dir;
841 uv_tty_t tty_out;
842 uv_loop_t* loop;
843 COORD cursor_pos;
844 char buffer[1024];
845 struct captured_screen actual = {0}, expect = {0};
846
847 loop = uv_default_loop();
848
849 initialize_tty(&tty_out);
850
851 /* Erase to below if omitted argument */
852 dir = 0;
853 setup_screen(&tty_out);
854 capture_screen(&tty_out, &expect);
855 cursor_pos.X = expect.si.width / 2;
856 cursor_pos.Y = expect.si.height / 2;
857 make_expect_screen_erase(&expect, cursor_pos, dir, TRUE);
858
859 set_cursor_position(&tty_out, cursor_pos);
860 snprintf(buffer, sizeof(buffer), "%sJ", CSI);
861 write_console(&tty_out, buffer);
862 capture_screen(&tty_out, &actual);
863
864 ASSERT(compare_screen(&tty_out, &actual, &expect));
865
866 /* Erase to below(dir = 0) */
867 setup_screen(&tty_out);
868 capture_screen(&tty_out, &expect);
869 make_expect_screen_erase(&expect, cursor_pos, dir, TRUE);
870
871 set_cursor_position(&tty_out, cursor_pos);
872 snprintf(buffer, sizeof(buffer), "%s%dJ", CSI, dir);
873 write_console(&tty_out, buffer);
874 capture_screen(&tty_out, &actual);
875
876 ASSERT(compare_screen(&tty_out, &actual, &expect));
877
878 /* Erase to above */
879 dir = 1;
880 setup_screen(&tty_out);
881 capture_screen(&tty_out, &expect);
882 make_expect_screen_erase(&expect, cursor_pos, dir, TRUE);
883
884 set_cursor_position(&tty_out, cursor_pos);
885 snprintf(buffer, sizeof(buffer), "%s%dJ", CSI, dir);
886 write_console(&tty_out, buffer);
887 capture_screen(&tty_out, &actual);
888
889 ASSERT(compare_screen(&tty_out, &actual, &expect));
890
891 /* Erase All */
892 dir = 2;
893 setup_screen(&tty_out);
894 capture_screen(&tty_out, &expect);
895 make_expect_screen_erase(&expect, cursor_pos, dir, TRUE);
896
897 set_cursor_position(&tty_out, cursor_pos);
898 snprintf(buffer, sizeof(buffer), "%s%dJ", CSI, dir);
899 write_console(&tty_out, buffer);
900 capture_screen(&tty_out, &actual);
901
902 ASSERT(compare_screen(&tty_out, &actual, &expect));
903
904 terminate_tty(&tty_out);
905
906 uv_run(loop, UV_RUN_DEFAULT);
907
908 MAKE_VALGRIND_HAPPY(loop);
909 return 0;
910 }
911
912
913 TEST_IMPL(tty_erase_line) {
914 int dir;
915 uv_tty_t tty_out;
916 uv_loop_t* loop;
917 COORD cursor_pos;
918 char buffer[1024];
919 struct captured_screen actual = {0}, expect = {0};
920
921 loop = uv_default_loop();
922
923 initialize_tty(&tty_out);
924
925 /* Erase to right if omitted arguments */
926 dir = 0;
927 setup_screen(&tty_out);
928 capture_screen(&tty_out, &expect);
929 cursor_pos.X = expect.si.width / 2;
930 cursor_pos.Y = expect.si.height / 2;
931 make_expect_screen_erase(&expect, cursor_pos, dir, FALSE);
932
933 set_cursor_position(&tty_out, cursor_pos);
934 snprintf(buffer, sizeof(buffer), "%sK", CSI);
935 write_console(&tty_out, buffer);
936 capture_screen(&tty_out, &actual);
937
938 ASSERT(compare_screen(&tty_out, &actual, &expect));
939
940 /* Erase to right(dir = 0) */
941 setup_screen(&tty_out);
942 capture_screen(&tty_out, &expect);
943 make_expect_screen_erase(&expect, cursor_pos, dir, FALSE);
944
945 set_cursor_position(&tty_out, cursor_pos);
946 snprintf(buffer, sizeof(buffer), "%s%dK", CSI, dir);
947 write_console(&tty_out, buffer);
948 capture_screen(&tty_out, &actual);
949
950 ASSERT(compare_screen(&tty_out, &actual, &expect));
951
952 /* Erase to Left */
953 dir = 1;
954 setup_screen(&tty_out);
955 capture_screen(&tty_out, &expect);
956 make_expect_screen_erase(&expect, cursor_pos, dir, FALSE);
957
958 set_cursor_position(&tty_out, cursor_pos);
959 snprintf(buffer, sizeof(buffer), "%s%dK", CSI, dir);
960 write_console(&tty_out, buffer);
961 capture_screen(&tty_out, &actual);
962
963 ASSERT(compare_screen(&tty_out, &actual, &expect));
964
965 /* Erase All */
966 dir = 2;
967 setup_screen(&tty_out);
968 capture_screen(&tty_out, &expect);
969 make_expect_screen_erase(&expect, cursor_pos, dir, FALSE);
970
971 set_cursor_position(&tty_out, cursor_pos);
972 snprintf(buffer, sizeof(buffer), "%s%dK", CSI, dir);
973 write_console(&tty_out, buffer);
974 capture_screen(&tty_out, &actual);
975
976 ASSERT(compare_screen(&tty_out, &actual, &expect));
977
978 terminate_tty(&tty_out);
979
980 uv_run(loop, UV_RUN_DEFAULT);
981
982 MAKE_VALGRIND_HAPPY(loop);
983 return 0;
984 }
985
986
987 TEST_IMPL(tty_set_cursor_shape) {
988 uv_tty_t tty_out;
989 uv_loop_t* loop;
990 DWORD saved_cursor_size;
991 char buffer[1024];
992
993 loop = uv_default_loop();
994
995 initialize_tty(&tty_out);
996
997 saved_cursor_size = get_cursor_size(&tty_out);
998
999 /* cursor size large if omitted arguments */
1000 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1001 snprintf(buffer, sizeof(buffer), "%s q", CSI);
1002 write_console(&tty_out, buffer);
1003 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE);
1004
1005 /* cursor size large */
1006 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1007 snprintf(buffer, sizeof(buffer), "%s1 q", CSI);
1008 write_console(&tty_out, buffer);
1009 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE);
1010 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1011 snprintf(buffer, sizeof(buffer), "%s2 q", CSI);
1012 write_console(&tty_out, buffer);
1013 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE);
1014
1015 /* cursor size small */
1016 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1017 snprintf(buffer, sizeof(buffer), "%s3 q", CSI);
1018 write_console(&tty_out, buffer);
1019 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_SMALL);
1020 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1021 snprintf(buffer, sizeof(buffer), "%s6 q", CSI);
1022 write_console(&tty_out, buffer);
1023 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_SMALL);
1024
1025 /* Nothing occurs with arguments outside valid range */
1026 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1027 snprintf(buffer, sizeof(buffer), "%s7 q", CSI);
1028 write_console(&tty_out, buffer);
1029 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE);
1030
1031 /* restore cursor size if arguments is zero */
1032 snprintf(buffer, sizeof(buffer), "%s0 q", CSI);
1033 write_console(&tty_out, buffer);
1034 ASSERT_EQ(get_cursor_size(&tty_out), saved_cursor_size);
1035
1036 terminate_tty(&tty_out);
1037
1038 uv_run(loop, UV_RUN_DEFAULT);
1039
1040 MAKE_VALGRIND_HAPPY(loop);
1041 return 0;
1042 }
1043
1044
1045 TEST_IMPL(tty_set_style) {
1046 #if _MSC_VER >= 1920 && _MSC_VER <= 1929
1047 RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. "
1048 "See: https://github.com/libuv/libuv/issues/3304");
1049 #else
1050
1051 uv_tty_t tty_out;
1052 uv_loop_t* loop;
1053 COORD cursor_pos;
1054 char buffer[1024];
1055 struct captured_screen actual = {0}, expect = {0};
1056 WORD fg, bg;
1057 WORD fg_attrs[9][2] = {{F_BLACK, FOREGROUND_BLACK},
1058 {F_RED, FOREGROUND_RED},
1059 {F_GREEN, FOREGROUND_GREEN},
1060 {F_YELLOW, FOREGROUND_YELLOW},
1061 {F_BLUE, FOREGROUND_BLUE},
1062 {F_MAGENTA, FOREGROUND_MAGENTA},
1063 {F_CYAN, FOREGROUND_CYAN},
1064 {F_WHITE, FOREGROUND_WHITE},
1065 {F_DEFAULT, 0}};
1066 WORD bg_attrs[9][2] = {{B_DEFAULT, 0},
1067 {B_BLACK, BACKGROUND_BLACK},
1068 {B_RED, BACKGROUND_RED},
1069 {B_GREEN, BACKGROUND_GREEN},
1070 {B_YELLOW, BACKGROUND_YELLOW},
1071 {B_BLUE, BACKGROUND_BLUE},
1072 {B_MAGENTA, BACKGROUND_MAGENTA},
1073 {B_CYAN, BACKGROUND_CYAN},
1074 {B_WHITE, BACKGROUND_WHITE}};
1075 WORD attr;
1076 int i, length;
1077
1078 loop = uv_default_loop();
1079
1080 initialize_tty(&tty_out);
1081
1082 capture_screen(&tty_out, &expect);
1083 fg_attrs[8][1] = expect.si.default_attr & FOREGROUND_WHITE;
1084 bg_attrs[0][1] = expect.si.default_attr & BACKGROUND_WHITE;
1085
1086 /* Set foreground color */
1087 length = ARRAY_SIZE(fg_attrs);
1088 for (i = 0; i < length; i++) {
1089 capture_screen(&tty_out, &expect);
1090 cursor_pos.X = expect.si.width / 2;
1091 cursor_pos.Y = expect.si.height / 2;
1092 attr = (expect.si.default_attr & ~FOREGROUND_WHITE) | fg_attrs[i][1];
1093 make_expect_screen_write(&expect, cursor_pos, HELLO);
1094 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1095
1096 set_cursor_position(&tty_out, cursor_pos);
1097 snprintf(
1098 buffer, sizeof(buffer), "%s%dm%s%sm", CSI, fg_attrs[i][0], HELLO, CSI);
1099 write_console(&tty_out, buffer);
1100 capture_screen(&tty_out, &actual);
1101
1102 ASSERT(compare_screen(&tty_out, &actual, &expect));
1103 }
1104
1105 /* Set background color */
1106 length = ARRAY_SIZE(bg_attrs);
1107 for (i = 0; i < length; i++) {
1108 capture_screen(&tty_out, &expect);
1109 cursor_pos.X = expect.si.width / 2;
1110 cursor_pos.Y = expect.si.height / 2;
1111 attr = (expect.si.default_attr & ~BACKGROUND_WHITE) | bg_attrs[i][1];
1112 make_expect_screen_write(&expect, cursor_pos, HELLO);
1113 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1114
1115 set_cursor_position(&tty_out, cursor_pos);
1116 snprintf(
1117 buffer, sizeof(buffer), "%s%dm%s%sm", CSI, bg_attrs[i][0], HELLO, CSI);
1118 write_console(&tty_out, buffer);
1119 capture_screen(&tty_out, &actual);
1120
1121 ASSERT(compare_screen(&tty_out, &actual, &expect));
1122 }
1123
1124 /* Set foreground and background color */
1125 ASSERT_EQ(ARRAY_SIZE(fg_attrs), ARRAY_SIZE(bg_attrs));
1126 length = ARRAY_SIZE(bg_attrs);
1127 for (i = 0; i < length; i++) {
1128 capture_screen(&tty_out, &expect);
1129 cursor_pos.X = expect.si.width / 2;
1130 cursor_pos.Y = expect.si.height / 2;
1131 attr = expect.si.default_attr & ~FOREGROUND_WHITE & ~BACKGROUND_WHITE;
1132 attr |= fg_attrs[i][1] | bg_attrs[i][1];
1133 make_expect_screen_write(&expect, cursor_pos, HELLO);
1134 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1135
1136 set_cursor_position(&tty_out, cursor_pos);
1137 snprintf(buffer,
1138 sizeof(buffer),
1139 "%s%d;%dm%s%sm",
1140 CSI,
1141 bg_attrs[i][0],
1142 fg_attrs[i][0],
1143 HELLO,
1144 CSI);
1145 write_console(&tty_out, buffer);
1146 capture_screen(&tty_out, &actual);
1147
1148 ASSERT(compare_screen(&tty_out, &actual, &expect));
1149 }
1150
1151 /* Set foreground bright on */
1152 capture_screen(&tty_out, &expect);
1153 cursor_pos.X = expect.si.width / 2;
1154 cursor_pos.Y = expect.si.height / 2;
1155 set_cursor_position(&tty_out, cursor_pos);
1156 attr = expect.si.default_attr;
1157 attr |= FOREGROUND_INTENSITY;
1158 make_expect_screen_write(&expect, cursor_pos, HELLO);
1159 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1160 cursor_pos.X += strlen(HELLO);
1161 make_expect_screen_write(&expect, cursor_pos, HELLO);
1162 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1163
1164 snprintf(buffer,
1165 sizeof(buffer),
1166 "%s%dm%s%s%dm%s%dm%s%s%dm",
1167 CSI,
1168 F_INTENSITY,
1169 HELLO,
1170 CSI,
1171 F_INTENSITY_OFF1,
1172 CSI,
1173 F_INTENSITY,
1174 HELLO,
1175 CSI,
1176 F_INTENSITY_OFF2);
1177 write_console(&tty_out, buffer);
1178 capture_screen(&tty_out, &actual);
1179
1180 ASSERT(compare_screen(&tty_out, &actual, &expect));
1181
1182 /* Set background bright on */
1183 capture_screen(&tty_out, &expect);
1184 cursor_pos.X = expect.si.width / 2;
1185 cursor_pos.Y = expect.si.height / 2;
1186 set_cursor_position(&tty_out, cursor_pos);
1187 attr = expect.si.default_attr;
1188 attr |= BACKGROUND_INTENSITY;
1189 make_expect_screen_write(&expect, cursor_pos, HELLO);
1190 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1191
1192 snprintf(buffer,
1193 sizeof(buffer),
1194 "%s%dm%s%s%dm",
1195 CSI,
1196 B_INTENSITY,
1197 HELLO,
1198 CSI,
1199 B_INTENSITY_OFF);
1200 write_console(&tty_out, buffer);
1201 capture_screen(&tty_out, &actual);
1202
1203 ASSERT(compare_screen(&tty_out, &actual, &expect));
1204
1205 /* Inverse */
1206 capture_screen(&tty_out, &expect);
1207 cursor_pos.X = expect.si.width / 2;
1208 cursor_pos.Y = expect.si.height / 2;
1209 set_cursor_position(&tty_out, cursor_pos);
1210 attr = expect.si.default_attr;
1211 fg = attr & FOREGROUND_WHITE;
1212 bg = attr & BACKGROUND_WHITE;
1213 attr &= (~FOREGROUND_WHITE & ~BACKGROUND_WHITE);
1214 attr |= COMMON_LVB_REVERSE_VIDEO;
1215 attr |= fg << 4;
1216 attr |= bg >> 4;
1217 make_expect_screen_write(&expect, cursor_pos, HELLO);
1218 make_expect_screen_set_attr(&expect, cursor_pos, strlen(HELLO), attr);
1219 cursor_pos.X += strlen(HELLO);
1220 make_expect_screen_write(&expect, cursor_pos, HELLO);
1221
1222 snprintf(buffer,
1223 sizeof(buffer),
1224 "%s%dm%s%s%dm%s",
1225 CSI,
1226 INVERSE,
1227 HELLO,
1228 CSI,
1229 INVERSE_OFF,
1230 HELLO);
1231 write_console(&tty_out, buffer);
1232 capture_screen(&tty_out, &actual);
1233
1234 ASSERT(compare_screen(&tty_out, &actual, &expect));
1235
1236 terminate_tty(&tty_out);
1237
1238 uv_run(loop, UV_RUN_DEFAULT);
1239
1240 MAKE_VALGRIND_HAPPY(loop);
1241 return 0;
1242 #endif
1243 }
1244
1245
1246 TEST_IMPL(tty_save_restore_cursor_position) {
1247 uv_tty_t tty_out;
1248 uv_loop_t* loop;
1249 COORD cursor_pos, cursor_pos_old;
1250 char buffer[1024];
1251 struct screen_info si;
1252
1253 loop = uv_default_loop();
1254
1255 initialize_tty(&tty_out);
1256 get_screen_info(&tty_out, &si);
1257
1258 cursor_pos_old.X = si.width / 2;
1259 cursor_pos_old.Y = si.height / 2;
1260 set_cursor_position(&tty_out, cursor_pos_old);
1261
1262 /* save the cursor position */
1263 snprintf(buffer, sizeof(buffer), "%ss", CSI);
1264 write_console(&tty_out, buffer);
1265
1266 cursor_pos.X = si.width / 4;
1267 cursor_pos.Y = si.height / 4;
1268 set_cursor_position(&tty_out, cursor_pos);
1269
1270 /* restore the cursor position */
1271 snprintf(buffer, sizeof(buffer), "%su", CSI);
1272 write_console(&tty_out, buffer);
1273 get_cursor_position(&tty_out, &cursor_pos);
1274 ASSERT_EQ(cursor_pos.X, cursor_pos_old.X);
1275 ASSERT_EQ(cursor_pos.Y, cursor_pos_old.Y);
1276
1277 cursor_pos_old.X = si.width / 2;
1278 cursor_pos_old.Y = si.height / 2;
1279 set_cursor_position(&tty_out, cursor_pos_old);
1280
1281 /* save the cursor position */
1282 snprintf(buffer, sizeof(buffer), "%s7", ESC);
1283 write_console(&tty_out, buffer);
1284
1285 cursor_pos.X = si.width / 4;
1286 cursor_pos.Y = si.height / 4;
1287 set_cursor_position(&tty_out, cursor_pos);
1288
1289 /* restore the cursor position */
1290 snprintf(buffer, sizeof(buffer), "%s8", ESC);
1291 write_console(&tty_out, buffer);
1292 get_cursor_position(&tty_out, &cursor_pos);
1293 ASSERT_EQ(cursor_pos.X, cursor_pos_old.X);
1294 ASSERT_EQ(cursor_pos.Y, cursor_pos_old.Y);
1295
1296 terminate_tty(&tty_out);
1297
1298 uv_run(loop, UV_RUN_DEFAULT);
1299
1300 MAKE_VALGRIND_HAPPY(loop);
1301 return 0;
1302 }
1303
1304
1305 TEST_IMPL(tty_full_reset) {
1306 uv_tty_t tty_out;
1307 uv_loop_t* loop;
1308 char buffer[1024];
1309 struct captured_screen actual = {0}, expect = {0};
1310 COORD cursor_pos;
1311 DWORD saved_cursor_size;
1312 BOOL saved_cursor_visibility;
1313
1314 loop = uv_default_loop();
1315
1316 initialize_tty(&tty_out);
1317
1318 capture_screen(&tty_out, &expect);
1319 setup_screen(&tty_out);
1320 cursor_pos.X = expect.si.width;
1321 cursor_pos.Y = expect.si.height;
1322 set_cursor_position(&tty_out, cursor_pos);
1323 snprintf(buffer, sizeof(buffer), "%s%d;%dm%s", CSI, F_CYAN, B_YELLOW, HELLO);
1324 saved_cursor_size = get_cursor_size(&tty_out);
1325 set_cursor_size(&tty_out,
1326 saved_cursor_size == CURSOR_SIZE_LARGE ? CURSOR_SIZE_SMALL
1327 : CURSOR_SIZE_LARGE);
1328 saved_cursor_visibility = get_cursor_visibility(&tty_out);
1329 set_cursor_visibility(&tty_out, saved_cursor_visibility ? FALSE : TRUE);
1330 write_console(&tty_out, buffer);
1331 snprintf(buffer, sizeof(buffer), "%sc", ESC);
1332 write_console(&tty_out, buffer);
1333 capture_screen(&tty_out, &actual);
1334 ASSERT(compare_screen(&tty_out, &actual, &expect));
1335 ASSERT_EQ(get_cursor_size(&tty_out), saved_cursor_size);
1336 ASSERT_EQ(get_cursor_visibility(&tty_out), saved_cursor_visibility);
1337 ASSERT_OK(actual.si.csbi.srWindow.Top);
1338
1339 terminate_tty(&tty_out);
1340
1341 uv_run(loop, UV_RUN_DEFAULT);
1342
1343 MAKE_VALGRIND_HAPPY(loop);
1344 return 0;
1345 }
1346
1347
1348 TEST_IMPL(tty_escape_sequence_processing) {
1349 #if _MSC_VER >= 1920 && _MSC_VER <= 1929
1350 RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. "
1351 "See: https://github.com/libuv/libuv/issues/3304");
1352 #else
1353 uv_tty_t tty_out;
1354 uv_loop_t* loop;
1355 COORD cursor_pos, cursor_pos_old;
1356 DWORD saved_cursor_size;
1357 char buffer[1024];
1358 struct captured_screen actual = {0}, expect = {0};
1359 int dir;
1360
1361 loop = uv_default_loop();
1362
1363 initialize_tty(&tty_out);
1364
1365 /* CSI + finally byte does not output anything */
1366 cursor_pos.X = 1;
1367 cursor_pos.Y = 1;
1368 set_cursor_position(&tty_out, cursor_pos);
1369 capture_screen(&tty_out, &expect);
1370 make_expect_screen_write(&expect, cursor_pos, HELLO);
1371 cursor_pos.X += strlen(HELLO);
1372 make_expect_screen_write(&expect, cursor_pos, HELLO);
1373 snprintf(buffer, sizeof(buffer), "%s@%s%s~%s", CSI, HELLO, CSI, HELLO);
1374 write_console(&tty_out, buffer);
1375 capture_screen(&tty_out, &actual);
1376 ASSERT(compare_screen(&tty_out, &actual, &expect));
1377
1378 /* CSI(C1) + finally byte does not output anything */
1379 cursor_pos.X = 1;
1380 cursor_pos.Y = 1;
1381 set_cursor_position(&tty_out, cursor_pos);
1382 capture_screen(&tty_out, &expect);
1383 make_expect_screen_write(&expect, cursor_pos, HELLO);
1384 cursor_pos.X += strlen(HELLO);
1385 make_expect_screen_write(&expect, cursor_pos, HELLO);
1386 snprintf(buffer, sizeof(buffer), "\xC2\x9B@%s\xC2\x9B~%s", HELLO, HELLO);
1387 write_console(&tty_out, buffer);
1388 capture_screen(&tty_out, &actual);
1389 ASSERT(compare_screen(&tty_out, &actual, &expect));
1390
1391 /* CSI + intermediate byte + finally byte does not output anything */
1392 cursor_pos.X = 1;
1393 cursor_pos.Y = 1;
1394 set_cursor_position(&tty_out, cursor_pos);
1395 capture_screen(&tty_out, &expect);
1396 make_expect_screen_write(&expect, cursor_pos, HELLO);
1397 cursor_pos.X += strlen(HELLO);
1398 make_expect_screen_write(&expect, cursor_pos, HELLO);
1399 snprintf(buffer, sizeof(buffer), "%s @%s%s/~%s", CSI, HELLO, CSI, HELLO);
1400 write_console(&tty_out, buffer);
1401 capture_screen(&tty_out, &actual);
1402 ASSERT(compare_screen(&tty_out, &actual, &expect));
1403
1404 /* CSI + parameter byte + finally byte does not output anything */
1405 cursor_pos.X = 1;
1406 cursor_pos.Y = 1;
1407 set_cursor_position(&tty_out, cursor_pos);
1408 capture_screen(&tty_out, &expect);
1409 snprintf(buffer,
1410 sizeof(buffer),
1411 "%s0@%s%s>~%s%s?~%s",
1412 CSI,
1413 HELLO,
1414 CSI,
1415 HELLO,
1416 CSI,
1417 HELLO);
1418 make_expect_screen_write(&expect, cursor_pos, HELLO);
1419 cursor_pos.X += strlen(HELLO);
1420 make_expect_screen_write(&expect, cursor_pos, HELLO);
1421 cursor_pos.X += strlen(HELLO);
1422 make_expect_screen_write(&expect, cursor_pos, HELLO);
1423 write_console(&tty_out, buffer);
1424 capture_screen(&tty_out, &actual);
1425 ASSERT(compare_screen(&tty_out, &actual, &expect));
1426
1427 /* ESC Single-char control does not output anyghing */
1428 cursor_pos.X = 1;
1429 cursor_pos.Y = 1;
1430 set_cursor_position(&tty_out, cursor_pos);
1431 capture_screen(&tty_out, &expect);
1432 make_expect_screen_write(&expect, cursor_pos, HELLO);
1433 cursor_pos.X += strlen(HELLO);
1434 make_expect_screen_write(&expect, cursor_pos, HELLO);
1435 snprintf(buffer, sizeof(buffer), "%s @%s%s/~%s", CSI, HELLO, CSI, HELLO);
1436 write_console(&tty_out, buffer);
1437 capture_screen(&tty_out, &actual);
1438 ASSERT(compare_screen(&tty_out, &actual, &expect));
1439
1440 /* Nothing is output from ESC + ^, _, P, ] to BEL or ESC \ */
1441 /* Operaging System Command */
1442 cursor_pos.X = 1;
1443 cursor_pos.Y = 1;
1444 set_cursor_position(&tty_out, cursor_pos);
1445 capture_screen(&tty_out, &expect);
1446 make_expect_screen_write(&expect, cursor_pos, HELLO);
1447 snprintf(buffer, sizeof(buffer), "%s]0;%s%s%s", ESC, HELLO, BEL, HELLO);
1448 write_console(&tty_out, buffer);
1449 capture_screen(&tty_out, &actual);
1450 ASSERT(compare_screen(&tty_out, &actual, &expect));
1451 /* Device Control Sequence */
1452 cursor_pos.X = 1;
1453 cursor_pos.Y = 1;
1454 set_cursor_position(&tty_out, cursor_pos);
1455 capture_screen(&tty_out, &expect);
1456 make_expect_screen_write(&expect, cursor_pos, HELLO);
1457 snprintf(buffer, sizeof(buffer), "%sP$m%s%s", ESC, ST, HELLO);
1458 write_console(&tty_out, buffer);
1459 capture_screen(&tty_out, &actual);
1460 ASSERT(compare_screen(&tty_out, &actual, &expect));
1461 /* Privacy Message */
1462 cursor_pos.X = 1;
1463 cursor_pos.Y = 1;
1464 set_cursor_position(&tty_out, cursor_pos);
1465 capture_screen(&tty_out, &expect);
1466 make_expect_screen_write(&expect, cursor_pos, HELLO);
1467 snprintf(buffer,
1468 sizeof(buffer),
1469 "%s^\"%s\\\"%s\"%s%s",
1470 ESC,
1471 HELLO,
1472 HELLO,
1473 ST,
1474 HELLO);
1475 write_console(&tty_out, buffer);
1476 capture_screen(&tty_out, &actual);
1477 ASSERT(compare_screen(&tty_out, &actual, &expect));
1478 /* Application Program Command */
1479 cursor_pos.X = 1;
1480 cursor_pos.Y = 1;
1481 set_cursor_position(&tty_out, cursor_pos);
1482 capture_screen(&tty_out, &expect);
1483 make_expect_screen_write(&expect, cursor_pos, HELLO);
1484 snprintf(buffer,
1485 sizeof(buffer),
1486 "%s_\"%s%s%s\"%s%s",
1487 ESC,
1488 HELLO,
1489 ST,
1490 HELLO,
1491 BEL,
1492 HELLO);
1493 write_console(&tty_out, buffer);
1494 capture_screen(&tty_out, &actual);
1495 ASSERT(compare_screen(&tty_out, &actual, &expect));
1496
1497 /* Ignore double escape */
1498 cursor_pos.X = 1;
1499 cursor_pos.Y = 1;
1500 set_cursor_position(&tty_out, cursor_pos);
1501 capture_screen(&tty_out, &expect);
1502 make_expect_screen_write(&expect, cursor_pos, HELLO);
1503 cursor_pos.X += strlen(HELLO);
1504 make_expect_screen_write(&expect, cursor_pos, HELLO);
1505 snprintf(buffer,
1506 sizeof(buffer),
1507 "%s%s@%s%s%s~%s",
1508 ESC,
1509 CSI,
1510 HELLO,
1511 ESC,
1512 CSI,
1513 HELLO);
1514 write_console(&tty_out, buffer);
1515 capture_screen(&tty_out, &actual);
1516 ASSERT(compare_screen(&tty_out, &actual, &expect));
1517
1518 /* Ignored if argument overflow */
1519 set_cursor_to_home(&tty_out);
1520 snprintf(buffer, sizeof(buffer), "%s1;%dH", CSI, UINT16_MAX + 1);
1521 write_console(&tty_out, buffer);
1522 get_cursor_position(&tty_out, &cursor_pos);
1523 ASSERT_EQ(1, cursor_pos.X);
1524 ASSERT_EQ(1, cursor_pos.Y);
1525
1526 /* Too many argument are ignored */
1527 cursor_pos.X = 1;
1528 cursor_pos.Y = 1;
1529 set_cursor_position(&tty_out, cursor_pos);
1530 capture_screen(&tty_out, &expect);
1531 make_expect_screen_write(&expect, cursor_pos, HELLO);
1532 snprintf(buffer,
1533 sizeof(buffer),
1534 "%s%d;%d;%d;%d;%dm%s%sm",
1535 CSI,
1536 F_RED,
1537 F_INTENSITY,
1538 INVERSE,
1539 B_CYAN,
1540 B_INTENSITY_OFF,
1541 HELLO,
1542 CSI);
1543 write_console(&tty_out, buffer);
1544 capture_screen(&tty_out, &actual);
1545 ASSERT(compare_screen(&tty_out, &actual, &expect));
1546
1547 /* In the case of DECSCUSR, the others are ignored */
1548 set_cursor_to_home(&tty_out);
1549 snprintf(buffer,
1550 sizeof(buffer),
1551 "%s%d;%d H",
1552 CSI,
1553 expect.si.height / 2,
1554 expect.si.width / 2);
1555 write_console(&tty_out, buffer);
1556 get_cursor_position(&tty_out, &cursor_pos);
1557 ASSERT_EQ(1, cursor_pos.X);
1558 ASSERT_EQ(1, cursor_pos.Y);
1559
1560 /* Invalid sequence are ignored */
1561 saved_cursor_size = get_cursor_size(&tty_out);
1562 set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE);
1563 snprintf(buffer, sizeof(buffer), "%s 1q", CSI);
1564 write_console(&tty_out, buffer);
1565 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE);
1566 snprintf(buffer, sizeof(buffer), "%s 1 q", CSI);
1567 write_console(&tty_out, buffer);
1568 ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE);
1569 set_cursor_size(&tty_out, saved_cursor_size);
1570
1571 /* #1874 2. */
1572 snprintf(buffer, sizeof(buffer), "%s??25l", CSI);
1573 write_console(&tty_out, buffer);
1574 ASSERT(get_cursor_visibility(&tty_out));
1575 snprintf(buffer, sizeof(buffer), "%s25?l", CSI);
1576 write_console(&tty_out, buffer);
1577 ASSERT(get_cursor_visibility(&tty_out));
1578 cursor_pos_old.X = expect.si.width / 2;
1579 cursor_pos_old.Y = expect.si.height / 2;
1580 set_cursor_position(&tty_out, cursor_pos_old);
1581 snprintf(buffer,
1582 sizeof(buffer),
1583 "%s??%d;%df",
1584 CSI,
1585 expect.si.height / 4,
1586 expect.si.width / 4);
1587 write_console(&tty_out, buffer);
1588 get_cursor_position(&tty_out, &cursor_pos);
1589 ASSERT(cursor_pos.X = cursor_pos_old.X);
1590 ASSERT(cursor_pos.Y = cursor_pos_old.Y);
1591 set_cursor_to_home(&tty_out);
1592
1593 /* CSI 25 l does nothing (#1874 4.) */
1594 snprintf(buffer, sizeof(buffer), "%s25l", CSI);
1595 write_console(&tty_out, buffer);
1596 ASSERT(get_cursor_visibility(&tty_out));
1597
1598 /* Unsupported sequences are ignored(#1874 5.) */
1599 dir = 2;
1600 setup_screen(&tty_out);
1601 capture_screen(&tty_out, &expect);
1602 set_cursor_position(&tty_out, cursor_pos);
1603 snprintf(buffer, sizeof(buffer), "%s?%dJ", CSI, dir);
1604 write_console(&tty_out, buffer);
1605 capture_screen(&tty_out, &actual);
1606 ASSERT(compare_screen(&tty_out, &actual, &expect));
1607
1608 /* Finally byte immedately after CSI [ are also output(#1874 1.) */
1609 cursor_pos.X = expect.si.width / 2;
1610 cursor_pos.Y = expect.si.height / 2;
1611 set_cursor_position(&tty_out, cursor_pos);
1612 capture_screen(&tty_out, &expect);
1613 make_expect_screen_write(&expect, cursor_pos, HELLO);
1614 snprintf(buffer, sizeof(buffer), "%s[%s", CSI, HELLO);
1615 write_console(&tty_out, buffer);
1616 capture_screen(&tty_out, &actual);
1617 ASSERT(compare_screen(&tty_out, &actual, &expect));
1618
1619 terminate_tty(&tty_out);
1620
1621 uv_run(loop, UV_RUN_DEFAULT);
1622
1623 MAKE_VALGRIND_HAPPY(loop);
1624 return 0;
1625 #endif
1626 }
1627
1628 #else
1629
1630 typedef int file_has_no_tests; /* ISO C forbids an empty translation unit. */
1631
1632 #endif /* ifdef _WIN32 */