| 1 |
import sys |
| 2 |
import unittest |
| 3 |
|
| 4 |
if sys.platform != "win32": |
| 5 |
raise unittest.SkipTest("test only relevant on win32") |
| 6 |
|
| 7 |
|
| 8 |
import itertools |
| 9 |
from functools import partial |
| 10 |
from test.support import force_not_colorized_test_class |
| 11 |
from typing import Iterable |
| 12 |
from unittest import TestCase |
| 13 |
from unittest.mock import MagicMock, call |
| 14 |
|
| 15 |
from .support import handle_all_events, code_to_events |
| 16 |
from .support import prepare_reader as default_prepare_reader |
| 17 |
|
| 18 |
try: |
| 19 |
from _pyrepl.console import Event, Console |
| 20 |
from _pyrepl.windows_console import ( |
| 21 |
WindowsConsole, |
| 22 |
MOVE_LEFT, |
| 23 |
MOVE_RIGHT, |
| 24 |
MOVE_UP, |
| 25 |
MOVE_DOWN, |
| 26 |
ERASE_IN_LINE, |
| 27 |
) |
| 28 |
import _pyrepl.windows_console as wc |
| 29 |
except ImportError: |
| 30 |
pass |
| 31 |
|
| 32 |
|
| 33 |
@force_not_colorized_test_class |
| 34 |
class WindowsConsoleTests(TestCase): |
| 35 |
def console(self, events, **kwargs) -> Console: |
| 36 |
console = WindowsConsole() |
| 37 |
console.get_event = MagicMock(side_effect=events) |
| 38 |
console.getpending = MagicMock(return_value=Event("key", "")) |
| 39 |
console.wait = MagicMock() |
| 40 |
console._scroll = MagicMock() |
| 41 |
console._hide_cursor = MagicMock() |
| 42 |
console._show_cursor = MagicMock() |
| 43 |
console._getscrollbacksize = MagicMock(42) |
| 44 |
console.out = MagicMock() |
| 45 |
|
| 46 |
height = kwargs.get("height", 25) |
| 47 |
width = kwargs.get("width", 80) |
| 48 |
console.getheightwidth = MagicMock(side_effect=lambda: (height, width)) |
| 49 |
|
| 50 |
console.prepare() |
| 51 |
for key, val in kwargs.items(): |
| 52 |
setattr(console, key, val) |
| 53 |
return console |
| 54 |
|
| 55 |
def handle_events( |
| 56 |
self, |
| 57 |
events: Iterable[Event], |
| 58 |
prepare_console=None, |
| 59 |
prepare_reader=None, |
| 60 |
**kwargs, |
| 61 |
): |
| 62 |
prepare_console = prepare_console or partial(self.console, **kwargs) |
| 63 |
prepare_reader = prepare_reader or default_prepare_reader |
| 64 |
return handle_all_events(events, prepare_console, prepare_reader) |
| 65 |
|
| 66 |
def handle_events_narrow(self, events): |
| 67 |
return self.handle_events(events, width=5) |
| 68 |
|
| 69 |
def handle_events_short(self, events, **kwargs): |
| 70 |
return self.handle_events(events, height=1, **kwargs) |
| 71 |
|
| 72 |
def handle_events_height_3(self, events): |
| 73 |
return self.handle_events(events, height=3) |
| 74 |
|
| 75 |
def test_no_newline(self): |
| 76 |
code = "1" |
| 77 |
events = code_to_events(code) |
| 78 |
_, con = self.handle_events(events) |
| 79 |
self.assertNotIn(call(b'\n'), con.out.write.mock_calls) |
| 80 |
con.restore() |
| 81 |
|
| 82 |
def test_newline(self): |
| 83 |
code = "\n" |
| 84 |
events = code_to_events(code) |
| 85 |
_, con = self.handle_events(events) |
| 86 |
con.out.write.assert_any_call(b"\n") |
| 87 |
con.restore() |
| 88 |
|
| 89 |
def test_simple_addition(self): |
| 90 |
code = "12+34" |
| 91 |
events = code_to_events(code) |
| 92 |
_, con = self.handle_events(events) |
| 93 |
con.out.write.assert_any_call(b"1") |
| 94 |
con.out.write.assert_any_call(b"2") |
| 95 |
con.out.write.assert_any_call(b"+") |
| 96 |
con.out.write.assert_any_call(b"3") |
| 97 |
con.out.write.assert_any_call(b"4") |
| 98 |
con.restore() |
| 99 |
|
| 100 |
def test_wrap(self): |
| 101 |
code = "12+34" |
| 102 |
events = code_to_events(code) |
| 103 |
_, con = self.handle_events_narrow(events) |
| 104 |
con.out.write.assert_any_call(b"1") |
| 105 |
con.out.write.assert_any_call(b"2") |
| 106 |
con.out.write.assert_any_call(b"+") |
| 107 |
con.out.write.assert_any_call(b"3") |
| 108 |
con.out.write.assert_any_call(b"\\") |
| 109 |
con.out.write.assert_any_call(b"\n") |
| 110 |
con.out.write.assert_any_call(b"4") |
| 111 |
con.restore() |
| 112 |
|
| 113 |
def test_resize_wider(self): |
| 114 |
code = "1234567890" |
| 115 |
events = code_to_events(code) |
| 116 |
reader, console = self.handle_events_narrow(events) |
| 117 |
|
| 118 |
console.getheightwidth = MagicMock(side_effect=lambda: (20, 80)) |
| 119 |
|
| 120 |
def same_reader(_): |
| 121 |
return reader |
| 122 |
|
| 123 |
def same_console(events): |
| 124 |
console.get_event = MagicMock(side_effect=events) |
| 125 |
return console |
| 126 |
|
| 127 |
_, con = handle_all_events( |
| 128 |
[Event(evt="resize", data=None)], |
| 129 |
prepare_reader=same_reader, |
| 130 |
prepare_console=same_console, |
| 131 |
) |
| 132 |
|
| 133 |
con.out.write.assert_any_call(self.move_right(2)) |
| 134 |
con.out.write.assert_any_call(self.move_up(2)) |
| 135 |
con.out.write.assert_any_call(b"567890") |
| 136 |
|
| 137 |
con.restore() |
| 138 |
|
| 139 |
def test_resize_narrower(self): |
| 140 |
code = "1234567890" |
| 141 |
events = code_to_events(code) |
| 142 |
reader, console = self.handle_events(events) |
| 143 |
|
| 144 |
console.getheightwidth = MagicMock(side_effect=lambda: (20, 4)) |
| 145 |
|
| 146 |
def same_reader(_): |
| 147 |
return reader |
| 148 |
|
| 149 |
def same_console(events): |
| 150 |
console.get_event = MagicMock(side_effect=events) |
| 151 |
return console |
| 152 |
|
| 153 |
_, con = handle_all_events( |
| 154 |
[Event(evt="resize", data=None)], |
| 155 |
prepare_reader=same_reader, |
| 156 |
prepare_console=same_console, |
| 157 |
) |
| 158 |
|
| 159 |
con.out.write.assert_any_call(b"456\\") |
| 160 |
con.out.write.assert_any_call(b"789\\") |
| 161 |
|
| 162 |
con.restore() |
| 163 |
|
| 164 |
def test_cursor_left(self): |
| 165 |
code = "1" |
| 166 |
events = itertools.chain( |
| 167 |
code_to_events(code), |
| 168 |
[Event(evt="key", data="left", raw=bytearray(b"\x1bOD"))], |
| 169 |
) |
| 170 |
_, con = self.handle_events(events) |
| 171 |
con.out.write.assert_any_call(self.move_left()) |
| 172 |
con.restore() |
| 173 |
|
| 174 |
def test_cursor_left_right(self): |
| 175 |
code = "1" |
| 176 |
events = itertools.chain( |
| 177 |
code_to_events(code), |
| 178 |
[ |
| 179 |
Event(evt="key", data="left", raw=bytearray(b"\x1bOD")), |
| 180 |
Event(evt="key", data="right", raw=bytearray(b"\x1bOC")), |
| 181 |
], |
| 182 |
) |
| 183 |
_, con = self.handle_events(events) |
| 184 |
con.out.write.assert_any_call(self.move_left()) |
| 185 |
con.out.write.assert_any_call(self.move_right()) |
| 186 |
con.restore() |
| 187 |
|
| 188 |
def test_cursor_up(self): |
| 189 |
code = "1\n2+3" |
| 190 |
events = itertools.chain( |
| 191 |
code_to_events(code), |
| 192 |
[Event(evt="key", data="up", raw=bytearray(b"\x1bOA"))], |
| 193 |
) |
| 194 |
_, con = self.handle_events(events) |
| 195 |
con.out.write.assert_any_call(self.move_up()) |
| 196 |
con.restore() |
| 197 |
|
| 198 |
def test_cursor_up_down(self): |
| 199 |
code = "1\n2+3" |
| 200 |
events = itertools.chain( |
| 201 |
code_to_events(code), |
| 202 |
[ |
| 203 |
Event(evt="key", data="up", raw=bytearray(b"\x1bOA")), |
| 204 |
Event(evt="key", data="down", raw=bytearray(b"\x1bOB")), |
| 205 |
], |
| 206 |
) |
| 207 |
_, con = self.handle_events(events) |
| 208 |
con.out.write.assert_any_call(self.move_up()) |
| 209 |
con.out.write.assert_any_call(self.move_down()) |
| 210 |
con.restore() |
| 211 |
|
| 212 |
def test_cursor_back_write(self): |
| 213 |
events = itertools.chain( |
| 214 |
code_to_events("1"), |
| 215 |
[Event(evt="key", data="left", raw=bytearray(b"\x1bOD"))], |
| 216 |
code_to_events("2"), |
| 217 |
) |
| 218 |
_, con = self.handle_events(events) |
| 219 |
con.out.write.assert_any_call(b"1") |
| 220 |
con.out.write.assert_any_call(self.move_left()) |
| 221 |
con.out.write.assert_any_call(b"21") |
| 222 |
con.restore() |
| 223 |
|
| 224 |
def test_multiline_function_move_up_short_terminal(self): |
| 225 |
# fmt: off |
| 226 |
code = ( |
| 227 |
"def f():\n" |
| 228 |
" foo" |
| 229 |
) |
| 230 |
# fmt: on |
| 231 |
|
| 232 |
events = itertools.chain( |
| 233 |
code_to_events(code), |
| 234 |
[ |
| 235 |
Event(evt="key", data="up", raw=bytearray(b"\x1bOA")), |
| 236 |
Event(evt="scroll", data=None), |
| 237 |
], |
| 238 |
) |
| 239 |
_, con = self.handle_events_short(events) |
| 240 |
con.out.write.assert_any_call(self.move_left(5)) |
| 241 |
con.out.write.assert_any_call(self.move_up()) |
| 242 |
con.restore() |
| 243 |
|
| 244 |
def test_multiline_function_move_up_down_short_terminal(self): |
| 245 |
# fmt: off |
| 246 |
code = ( |
| 247 |
"def f():\n" |
| 248 |
" foo" |
| 249 |
) |
| 250 |
# fmt: on |
| 251 |
|
| 252 |
events = itertools.chain( |
| 253 |
code_to_events(code), |
| 254 |
[ |
| 255 |
Event(evt="key", data="up", raw=bytearray(b"\x1bOA")), |
| 256 |
Event(evt="scroll", data=None), |
| 257 |
Event(evt="key", data="down", raw=bytearray(b"\x1bOB")), |
| 258 |
Event(evt="scroll", data=None), |
| 259 |
], |
| 260 |
) |
| 261 |
_, con = self.handle_events_short(events) |
| 262 |
con.out.write.assert_any_call(self.move_left(8)) |
| 263 |
con.out.write.assert_any_call(self.erase_in_line()) |
| 264 |
con.restore() |
| 265 |
|
| 266 |
def test_resize_bigger_on_multiline_function(self): |
| 267 |
# fmt: off |
| 268 |
code = ( |
| 269 |
"def f():\n" |
| 270 |
" foo" |
| 271 |
) |
| 272 |
# fmt: on |
| 273 |
|
| 274 |
events = itertools.chain(code_to_events(code)) |
| 275 |
reader, console = self.handle_events_short(events) |
| 276 |
|
| 277 |
console.getheightwidth = MagicMock(side_effect=lambda: (2, 80)) |
| 278 |
|
| 279 |
def same_reader(_): |
| 280 |
return reader |
| 281 |
|
| 282 |
def same_console(events): |
| 283 |
console.get_event = MagicMock(side_effect=events) |
| 284 |
return console |
| 285 |
|
| 286 |
_, con = handle_all_events( |
| 287 |
[Event(evt="resize", data=None)], |
| 288 |
prepare_reader=same_reader, |
| 289 |
prepare_console=same_console, |
| 290 |
) |
| 291 |
con.out.write.assert_has_calls( |
| 292 |
[ |
| 293 |
call(self.move_left(5)), |
| 294 |
call(self.move_up()), |
| 295 |
call(b"def f():"), |
| 296 |
call(self.move_left(3)), |
| 297 |
call(self.move_down()), |
| 298 |
] |
| 299 |
) |
| 300 |
console.restore() |
| 301 |
con.restore() |
| 302 |
|
| 303 |
def test_resize_smaller_on_multiline_function(self): |
| 304 |
# fmt: off |
| 305 |
code = ( |
| 306 |
"def f():\n" |
| 307 |
" foo" |
| 308 |
) |
| 309 |
# fmt: on |
| 310 |
|
| 311 |
events = itertools.chain(code_to_events(code)) |
| 312 |
reader, console = self.handle_events_height_3(events) |
| 313 |
|
| 314 |
console.getheightwidth = MagicMock(side_effect=lambda: (1, 80)) |
| 315 |
|
| 316 |
def same_reader(_): |
| 317 |
return reader |
| 318 |
|
| 319 |
def same_console(events): |
| 320 |
console.get_event = MagicMock(side_effect=events) |
| 321 |
return console |
| 322 |
|
| 323 |
_, con = handle_all_events( |
| 324 |
[Event(evt="resize", data=None)], |
| 325 |
prepare_reader=same_reader, |
| 326 |
prepare_console=same_console, |
| 327 |
) |
| 328 |
con.out.write.assert_has_calls( |
| 329 |
[ |
| 330 |
call(self.move_left(5)), |
| 331 |
call(self.move_up()), |
| 332 |
call(self.erase_in_line()), |
| 333 |
call(b" foo"), |
| 334 |
] |
| 335 |
) |
| 336 |
console.restore() |
| 337 |
con.restore() |
| 338 |
|
| 339 |
def move_up(self, lines=1): |
| 340 |
return MOVE_UP.format(lines).encode("utf8") |
| 341 |
|
| 342 |
def move_down(self, lines=1): |
| 343 |
return MOVE_DOWN.format(lines).encode("utf8") |
| 344 |
|
| 345 |
def move_left(self, cols=1): |
| 346 |
return MOVE_LEFT.format(cols).encode("utf8") |
| 347 |
|
| 348 |
def move_right(self, cols=1): |
| 349 |
return MOVE_RIGHT.format(cols).encode("utf8") |
| 350 |
|
| 351 |
def erase_in_line(self): |
| 352 |
return ERASE_IN_LINE.encode("utf8") |
| 353 |
|
| 354 |
def test_multiline_ctrl_z(self): |
| 355 |
# see gh-126332 |
| 356 |
code = "abcdefghi" |
| 357 |
|
| 358 |
events = itertools.chain( |
| 359 |
code_to_events(code), |
| 360 |
[ |
| 361 |
Event(evt="key", data='\x1a', raw=bytearray(b'\x1a')), |
| 362 |
Event(evt="key", data='\x1a', raw=bytearray(b'\x1a')), |
| 363 |
], |
| 364 |
) |
| 365 |
reader, con = self.handle_events_narrow(events) |
| 366 |
self.assertEqual(reader.cxy, (2, 3)) |
| 367 |
con.restore() |
| 368 |
|
| 369 |
|
| 370 |
class WindowsConsoleGetEventTests(TestCase): |
| 371 |
# Virtual-Key Codes: https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes |
| 372 |
VK_BACK = 0x08 |
| 373 |
VK_RETURN = 0x0D |
| 374 |
VK_LEFT = 0x25 |
| 375 |
VK_7 = 0x37 |
| 376 |
VK_M = 0x4D |
| 377 |
# Used for miscellaneous characters; it can vary by keyboard. |
| 378 |
# For the US standard keyboard, the '" key. |
| 379 |
# For the German keyboard, the Ä key. |
| 380 |
VK_OEM_7 = 0xDE |
| 381 |
|
| 382 |
# State of control keys: https://learn.microsoft.com/en-us/windows/console/key-event-record-str |
| 383 |
RIGHT_ALT_PRESSED = 0x0001 |
| 384 |
RIGHT_CTRL_PRESSED = 0x0004 |
| 385 |
LEFT_ALT_PRESSED = 0x0002 |
| 386 |
LEFT_CTRL_PRESSED = 0x0008 |
| 387 |
ENHANCED_KEY = 0x0100 |
| 388 |
SHIFT_PRESSED = 0x0010 |
| 389 |
|
| 390 |
|
| 391 |
def get_event(self, input_records, **kwargs) -> Console: |
| 392 |
self.console = WindowsConsole(encoding='utf-8') |
| 393 |
self.mock = MagicMock(side_effect=input_records) |
| 394 |
self.console._read_input = self.mock |
| 395 |
self.console._WindowsConsole__vt_support = kwargs.get("vt_support", |
| 396 |
False) |
| 397 |
self.console.wait = MagicMock(return_value=True) |
| 398 |
event = self.console.get_event(block=False) |
| 399 |
return event |
| 400 |
|
| 401 |
def get_input_record(self, unicode_char, vcode=0, control=0): |
| 402 |
return wc.INPUT_RECORD( |
| 403 |
wc.KEY_EVENT, |
| 404 |
wc.ConsoleEvent(KeyEvent= |
| 405 |
wc.KeyEvent( |
| 406 |
bKeyDown=True, |
| 407 |
wRepeatCount=1, |
| 408 |
wVirtualKeyCode=vcode, |
| 409 |
wVirtualScanCode=0, # not used |
| 410 |
uChar=wc.Char(unicode_char), |
| 411 |
dwControlKeyState=control |
| 412 |
))) |
| 413 |
|
| 414 |
def test_EmptyBuffer(self): |
| 415 |
self.assertEqual(self.get_event([None]), None) |
| 416 |
self.assertEqual(self.mock.call_count, 1) |
| 417 |
|
| 418 |
def test_WINDOW_BUFFER_SIZE_EVENT(self): |
| 419 |
ir = wc.INPUT_RECORD( |
| 420 |
wc.WINDOW_BUFFER_SIZE_EVENT, |
| 421 |
wc.ConsoleEvent(WindowsBufferSizeEvent= |
| 422 |
wc.WindowsBufferSizeEvent( |
| 423 |
wc._COORD(0, 0)))) |
| 424 |
self.assertEqual(self.get_event([ir]), Event("resize", "")) |
| 425 |
self.assertEqual(self.mock.call_count, 1) |
| 426 |
|
| 427 |
def test_KEY_EVENT_up_ignored(self): |
| 428 |
ir = wc.INPUT_RECORD( |
| 429 |
wc.KEY_EVENT, |
| 430 |
wc.ConsoleEvent(KeyEvent= |
| 431 |
wc.KeyEvent(bKeyDown=False))) |
| 432 |
self.assertEqual(self.get_event([ir]), None) |
| 433 |
self.assertEqual(self.mock.call_count, 1) |
| 434 |
|
| 435 |
def test_unhandled_events(self): |
| 436 |
for event in (wc.FOCUS_EVENT, wc.MENU_EVENT, wc.MOUSE_EVENT): |
| 437 |
ir = wc.INPUT_RECORD( |
| 438 |
event, |
| 439 |
# fake data, nothing is read except bKeyDown |
| 440 |
wc.ConsoleEvent(KeyEvent= |
| 441 |
wc.KeyEvent(bKeyDown=False))) |
| 442 |
self.assertEqual(self.get_event([ir]), None) |
| 443 |
self.assertEqual(self.mock.call_count, 1) |
| 444 |
|
| 445 |
def test_enter(self): |
| 446 |
ir = self.get_input_record("\r", self.VK_RETURN) |
| 447 |
self.assertEqual(self.get_event([ir]), Event("key", "\n")) |
| 448 |
self.assertEqual(self.mock.call_count, 1) |
| 449 |
|
| 450 |
def test_backspace(self): |
| 451 |
ir = self.get_input_record("\x08", self.VK_BACK) |
| 452 |
self.assertEqual( |
| 453 |
self.get_event([ir]), Event("key", "backspace")) |
| 454 |
self.assertEqual(self.mock.call_count, 1) |
| 455 |
|
| 456 |
def test_m(self): |
| 457 |
ir = self.get_input_record("m", self.VK_M) |
| 458 |
self.assertEqual(self.get_event([ir]), Event("key", "m")) |
| 459 |
self.assertEqual(self.mock.call_count, 1) |
| 460 |
|
| 461 |
def test_M(self): |
| 462 |
ir = self.get_input_record("M", self.VK_M, self.SHIFT_PRESSED) |
| 463 |
self.assertEqual(self.get_event([ir]), Event("key", "M")) |
| 464 |
self.assertEqual(self.mock.call_count, 1) |
| 465 |
|
| 466 |
def test_left(self): |
| 467 |
# VK_LEFT is sent as ENHANCED_KEY |
| 468 |
ir = self.get_input_record("\x00", self.VK_LEFT, self.ENHANCED_KEY) |
| 469 |
self.assertEqual(self.get_event([ir]), Event("key", "left")) |
| 470 |
self.assertEqual(self.mock.call_count, 1) |
| 471 |
|
| 472 |
def test_left_RIGHT_CTRL_PRESSED(self): |
| 473 |
ir = self.get_input_record( |
| 474 |
"\x00", self.VK_LEFT, self.RIGHT_CTRL_PRESSED | self.ENHANCED_KEY) |
| 475 |
self.assertEqual( |
| 476 |
self.get_event([ir]), Event("key", "ctrl left")) |
| 477 |
self.assertEqual(self.mock.call_count, 1) |
| 478 |
|
| 479 |
def test_left_LEFT_CTRL_PRESSED(self): |
| 480 |
ir = self.get_input_record( |
| 481 |
"\x00", self.VK_LEFT, self.LEFT_CTRL_PRESSED | self.ENHANCED_KEY) |
| 482 |
self.assertEqual( |
| 483 |
self.get_event([ir]), Event("key", "ctrl left")) |
| 484 |
self.assertEqual(self.mock.call_count, 1) |
| 485 |
|
| 486 |
def test_left_RIGHT_ALT_PRESSED(self): |
| 487 |
ir = self.get_input_record( |
| 488 |
"\x00", self.VK_LEFT, self.RIGHT_ALT_PRESSED | self.ENHANCED_KEY) |
| 489 |
self.assertEqual(self.get_event([ir]), Event(evt="key", data="\033")) |
| 490 |
self.assertEqual( |
| 491 |
self.console.get_event(), Event("key", "left")) |
| 492 |
# self.mock is not called again, since the second time we read from the |
| 493 |
# command queue |
| 494 |
self.assertEqual(self.mock.call_count, 1) |
| 495 |
|
| 496 |
def test_left_LEFT_ALT_PRESSED(self): |
| 497 |
ir = self.get_input_record( |
| 498 |
"\x00", self.VK_LEFT, self.LEFT_ALT_PRESSED | self.ENHANCED_KEY) |
| 499 |
self.assertEqual(self.get_event([ir]), Event(evt="key", data="\033")) |
| 500 |
self.assertEqual( |
| 501 |
self.console.get_event(), Event("key", "left")) |
| 502 |
self.assertEqual(self.mock.call_count, 1) |
| 503 |
|
| 504 |
def test_m_LEFT_ALT_PRESSED_and_LEFT_CTRL_PRESSED(self): |
| 505 |
# For the shift keys, Windows does not send anything when |
| 506 |
# ALT and CTRL are both pressed, so let's test with VK_M. |
| 507 |
# get_event() receives this input, but does not |
| 508 |
# generate an event. |
| 509 |
# This is for e.g. an English keyboard layout, for a |
| 510 |
# German layout this returns `µ`, see test_AltGr_m. |
| 511 |
ir = self.get_input_record( |
| 512 |
"\x00", self.VK_M, self.LEFT_ALT_PRESSED | self.LEFT_CTRL_PRESSED) |
| 513 |
self.assertEqual(self.get_event([ir]), None) |
| 514 |
self.assertEqual(self.mock.call_count, 1) |
| 515 |
|
| 516 |
def test_m_LEFT_ALT_PRESSED(self): |
| 517 |
ir = self.get_input_record( |
| 518 |
"m", vcode=self.VK_M, control=self.LEFT_ALT_PRESSED) |
| 519 |
self.assertEqual(self.get_event([ir]), Event(evt="key", data="\033")) |
| 520 |
self.assertEqual(self.console.get_event(), Event("key", "m")) |
| 521 |
self.assertEqual(self.mock.call_count, 1) |
| 522 |
|
| 523 |
def test_m_RIGHT_ALT_PRESSED(self): |
| 524 |
ir = self.get_input_record( |
| 525 |
"m", vcode=self.VK_M, control=self.RIGHT_ALT_PRESSED) |
| 526 |
self.assertEqual(self.get_event([ir]), Event(evt="key", data="\033")) |
| 527 |
self.assertEqual(self.console.get_event(), Event("key", "m")) |
| 528 |
self.assertEqual(self.mock.call_count, 1) |
| 529 |
|
| 530 |
def test_AltGr_7(self): |
| 531 |
# E.g. on a German keyboard layout, '{' is entered via |
| 532 |
# AltGr + 7, where AltGr is the right Alt key on the keyboard. |
| 533 |
# In this case, Windows automatically sets |
| 534 |
# RIGHT_ALT_PRESSED = 0x0001 + LEFT_CTRL_PRESSED = 0x0008 |
| 535 |
# This can also be entered like |
| 536 |
# LeftAlt + LeftCtrl + 7 or |
| 537 |
# LeftAlt + RightCtrl + 7 |
| 538 |
# See https://learn.microsoft.com/en-us/windows/console/key-event-record-str |
| 539 |
# https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-vkkeyscanw |
| 540 |
ir = self.get_input_record( |
| 541 |
"{", vcode=self.VK_7, |
| 542 |
control=self.RIGHT_ALT_PRESSED | self.LEFT_CTRL_PRESSED) |
| 543 |
self.assertEqual(self.get_event([ir]), Event("key", "{")) |
| 544 |
self.assertEqual(self.mock.call_count, 1) |
| 545 |
|
| 546 |
def test_AltGr_m(self): |
| 547 |
# E.g. on a German keyboard layout, this yields 'µ' |
| 548 |
# Let's use LEFT_ALT_PRESSED and RIGHT_CTRL_PRESSED this |
| 549 |
# time, to cover that, too. See above in test_AltGr_7. |
| 550 |
ir = self.get_input_record( |
| 551 |
"µ", vcode=self.VK_M, control=self.LEFT_ALT_PRESSED | self.RIGHT_CTRL_PRESSED) |
| 552 |
self.assertEqual(self.get_event([ir]), Event("key", "µ")) |
| 553 |
self.assertEqual(self.mock.call_count, 1) |
| 554 |
|
| 555 |
def test_umlaut_a_german(self): |
| 556 |
ir = self.get_input_record("ä", self.VK_OEM_7) |
| 557 |
self.assertEqual(self.get_event([ir]), Event("key", "ä")) |
| 558 |
self.assertEqual(self.mock.call_count, 1) |
| 559 |
|
| 560 |
# virtual terminal tests |
| 561 |
# Note: wVirtualKeyCode, wVirtualScanCode and dwControlKeyState |
| 562 |
# are always zero in this case. |
| 563 |
# "\r" and backspace are handled specially, everything else |
| 564 |
# is handled in "elif self.__vt_support:" in WindowsConsole.get_event(). |
| 565 |
# Hence, only one regular key ("m") and a terminal sequence |
| 566 |
# are sufficient to test here, the real tests happen in test_eventqueue |
| 567 |
# and test_keymap. |
| 568 |
|
| 569 |
def test_enter_vt(self): |
| 570 |
ir = self.get_input_record("\r") |
| 571 |
self.assertEqual(self.get_event([ir], vt_support=True), |
| 572 |
Event("key", "\n")) |
| 573 |
self.assertEqual(self.mock.call_count, 1) |
| 574 |
|
| 575 |
def test_backspace_vt(self): |
| 576 |
ir = self.get_input_record("\x7f") |
| 577 |
self.assertEqual(self.get_event([ir], vt_support=True), |
| 578 |
Event("key", "backspace", b"\x7f")) |
| 579 |
self.assertEqual(self.mock.call_count, 1) |
| 580 |
|
| 581 |
def test_up_vt(self): |
| 582 |
irs = [self.get_input_record(x) for x in "\x1b[A"] |
| 583 |
self.assertEqual(self.get_event(irs, vt_support=True), |
| 584 |
Event(evt='key', data='up', raw=bytearray(b'\x1b[A'))) |
| 585 |
self.assertEqual(self.mock.call_count, 3) |
| 586 |
|
| 587 |
# All tests above assume that there is always keyboard data to read, |
| 588 |
# because for simplicity we just use |
| 589 |
# self.console.wait = MagicMock(return_value=True) |
| 590 |
def test_wait_empty(self): |
| 591 |
console = WindowsConsole(encoding='utf-8') |
| 592 |
console.wait_for_event = MagicMock(return_value=True) |
| 593 |
self.assertTrue(console.event_queue.empty()) |
| 594 |
timeout = 2.0 |
| 595 |
self.assertTrue(console.wait(timeout)) |
| 596 |
self.assertEqual(console.wait_for_event.call_count, 1) |
| 597 |
self.assertEqual(console.wait_for_event.mock_calls[0], call(timeout)) |
| 598 |
|
| 599 |
timeout = 1.1 |
| 600 |
console.wait_for_event = MagicMock(return_value=False) |
| 601 |
self.assertFalse(console.wait(timeout)) |
| 602 |
self.assertEqual(console.wait_for_event.call_count, 1) |
| 603 |
self.assertEqual(console.wait_for_event.mock_calls[0], call(timeout)) |
| 604 |
|
| 605 |
def test_wait_not_empty(self): |
| 606 |
console = WindowsConsole(encoding='utf-8') |
| 607 |
console.wait_for_event = MagicMock(return_value=True) |
| 608 |
console.event_queue.push(b"a") |
| 609 |
self.assertFalse(console.event_queue.empty()) |
| 610 |
self.assertTrue(console.wait(0.0)) |
| 611 |
self.assertEqual(console.wait_for_event.call_count, 0) |
| 612 |
|
| 613 |
|
| 614 |
if __name__ == "__main__": |
| 615 |
unittest.main() |