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 */ 1633
Indexes created Tue Feb 24 08:35:24 UTC 2026