libuv-svace-build

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