Debian Codegraph @

Lib/test/test_pyrepl/test_windows_console.py

raw
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()