mirror of
https://github.com/python/cpython.git
synced 2026-04-21 03:10:52 +00:00
311 lines
11 KiB
Python
311 lines
11 KiB
Python
from unittest import TestCase
|
|
from _pyrepl.render import (
|
|
LineUpdate,
|
|
RenderCell,
|
|
RenderLine,
|
|
RenderedScreen,
|
|
ScreenOverlay,
|
|
StyleRef,
|
|
diff_render_lines,
|
|
render_cells,
|
|
requires_cursor_resync,
|
|
)
|
|
|
|
|
|
class TestRenderLine(TestCase):
|
|
def test_from_rendered_text_parses_style_state(self):
|
|
line = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mb")
|
|
|
|
self.assertEqual(line.width, 2)
|
|
self.assertEqual([cell.text for cell in line.cells], ["a", "b"])
|
|
self.assertEqual([cell.style.sgr for cell in line.cells], ["\x1b[31m", ""])
|
|
self.assertEqual([cell.controls for cell in line.cells], [(), ()])
|
|
|
|
def test_from_rendered_text_round_trips_trailing_reset(self):
|
|
line = RenderLine.from_rendered_text("\x1b[31ma\x1b[0m")
|
|
|
|
self.assertEqual([cell.text for cell in line.cells], ["a"])
|
|
self.assertEqual([cell.style.sgr for cell in line.cells], ["\x1b[31m"])
|
|
self.assertEqual(line.text, "\x1b[31ma\x1b[0m")
|
|
|
|
def test_from_parts_accepts_style_refs(self):
|
|
line = RenderLine.from_parts(
|
|
["d", "e", "f", " "],
|
|
[1, 1, 1, 1],
|
|
[StyleRef.from_sgr("\x1b[1;34m")] * 3 + [None],
|
|
)
|
|
|
|
self.assertEqual([cell.text for cell in line.cells], ["d", "e", "f", " "])
|
|
self.assertEqual(
|
|
[cell.style.sgr for cell in line.cells],
|
|
["\x1b[1;34m", "\x1b[1;34m", "\x1b[1;34m", ""],
|
|
)
|
|
self.assertEqual(line.text, "\x1b[1;34mdef\x1b[0m ")
|
|
|
|
def test_from_parts_without_styles(self):
|
|
line = RenderLine.from_parts(["a", "b"], [1, 1])
|
|
|
|
self.assertEqual(line.text, "ab")
|
|
self.assertEqual(line.width, 2)
|
|
|
|
def test_from_rendered_text_empty_string(self):
|
|
line = RenderLine.from_rendered_text("")
|
|
|
|
self.assertEqual(line.cells, ())
|
|
self.assertEqual(line.text, "")
|
|
self.assertEqual(line.width, 0)
|
|
|
|
def test_from_rendered_text_with_non_sgr_controls(self):
|
|
# \x1b[H is a cursor-home control (not SGR since it doesn't end with 'm')
|
|
line = RenderLine.from_rendered_text("\x1b[Hx")
|
|
|
|
self.assertEqual(len(line.cells), 2)
|
|
self.assertEqual(line.cells[0].controls, ("\x1b[H",))
|
|
self.assertEqual(line.cells[0].text, "")
|
|
self.assertEqual(line.cells[1].text, "x")
|
|
|
|
def test_from_rendered_text_trailing_non_sgr_control(self):
|
|
line = RenderLine.from_rendered_text("a\x1b[K")
|
|
|
|
self.assertEqual(len(line.cells), 2)
|
|
self.assertEqual(line.cells[0].text, "a")
|
|
self.assertEqual(line.cells[1].controls, ("\x1b[K",))
|
|
self.assertEqual(line.cells[1].text, "")
|
|
|
|
def test_from_rendered_text_non_sgr_before_text(self):
|
|
# Non-SGR control immediately before text should produce a control cell
|
|
# then text cells.
|
|
line = RenderLine.from_rendered_text("\x1b[Kab")
|
|
|
|
texts = [c.text for c in line.cells]
|
|
self.assertEqual(texts, ["", "a", "b"])
|
|
self.assertEqual(line.cells[0].controls, ("\x1b[K",))
|
|
|
|
|
|
class TestLineDiff(TestCase):
|
|
def test_diff_render_lines_ignores_unchanged_ansi_prefix(self):
|
|
old = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mb")
|
|
new = RenderLine.from_rendered_text("\x1b[31ma\x1b[0mc")
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
self.assertEqual(diff.start_x, 1)
|
|
self.assertEqual(diff.old_text, "b")
|
|
self.assertEqual(diff.new_text, "c")
|
|
|
|
def test_diff_render_lines_detects_single_cell_insertion(self):
|
|
old = RenderLine.from_rendered_text("ab")
|
|
new = RenderLine.from_rendered_text("acb")
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
self.assertEqual(diff.start_x, 1)
|
|
self.assertEqual(diff.old_text, "")
|
|
self.assertEqual(diff.new_text, "c")
|
|
|
|
def test_colored_append_only_emits_new_character_and_reset(self):
|
|
old = RenderLine.from_rendered_text("\x1b[1mabc\x1b[0m")
|
|
new = RenderLine.from_rendered_text("\x1b[1mabcd\x1b[0m")
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
self.assertEqual(diff.start_x, 3)
|
|
self.assertEqual(render_cells(diff.new_cells), "\x1b[1md\x1b[0m")
|
|
|
|
def test_keyword_space_inserts_only_space_after_reset(self):
|
|
old = RenderLine.from_parts(
|
|
["d", "e", "f"],
|
|
[1, 1, 1],
|
|
["keyword", "keyword", "keyword"],
|
|
)
|
|
new = RenderLine.from_parts(
|
|
["d", "e", "f", " "],
|
|
[1, 1, 1, 1],
|
|
["keyword", "keyword", "keyword", None],
|
|
)
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
self.assertEqual(diff.start_x, 3)
|
|
self.assertEqual(render_cells(diff.new_cells), " ")
|
|
|
|
def test_diff_render_lines_returns_none_for_identical(self):
|
|
line = RenderLine.from_rendered_text("abc")
|
|
self.assertIsNone(diff_render_lines(line, line))
|
|
|
|
def test_diff_render_lines_breaks_on_controls_in_prefix(self):
|
|
old = RenderLine.from_cells([
|
|
RenderCell("a", 1),
|
|
RenderCell("", 0, controls=("\x1b[K",)),
|
|
RenderCell("b", 1),
|
|
])
|
|
new = RenderLine.from_cells([
|
|
RenderCell("a", 1),
|
|
RenderCell("", 0, controls=("\x1b[K",)),
|
|
RenderCell("c", 1),
|
|
])
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
# Prefix scan stops at control cell, so diff starts at cell 1
|
|
self.assertEqual(diff.start_cell, 1)
|
|
self.assertEqual(diff.start_x, 1)
|
|
|
|
def test_diff_render_lines_extends_past_combining_chars(self):
|
|
# \u0301 is a combining acute accent (zero-width)
|
|
old = RenderLine.from_parts(["a", "b", "\u0301"], [1, 1, 0])
|
|
new = RenderLine.from_parts(["a", "c", "\u0301"], [1, 1, 0])
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
# The combining char is included since it's zero-width
|
|
self.assertEqual(len(diff.new_cells), 2)
|
|
|
|
def test_diff_old_and_new_changed_width(self):
|
|
old = RenderLine.from_rendered_text("ab")
|
|
new = RenderLine.from_rendered_text("acd")
|
|
|
|
diff = diff_render_lines(old, new)
|
|
|
|
self.assertIsNotNone(diff)
|
|
assert diff is not None
|
|
self.assertEqual(diff.old_changed_width, 1)
|
|
self.assertEqual(diff.new_changed_width, 2)
|
|
|
|
def test_rendered_screen_round_trips_screen_lines(self):
|
|
screen = RenderedScreen.from_screen_lines(
|
|
["a", "\x1b[31mb\x1b[0m"],
|
|
(0, 1),
|
|
)
|
|
|
|
self.assertEqual(screen.screen_lines, ("a", "\x1b[31mb\x1b[0m"))
|
|
|
|
|
|
class TestRenderedScreen(TestCase):
|
|
def test_empty(self):
|
|
screen = RenderedScreen.empty()
|
|
|
|
self.assertEqual(screen.lines, ())
|
|
self.assertEqual(screen.cursor, (0, 0))
|
|
self.assertEqual(screen.overlays, ())
|
|
self.assertEqual(screen.composed_lines, ())
|
|
|
|
def test_with_overlay(self):
|
|
screen = RenderedScreen.from_screen_lines(["aaa", "bbb"], (0, 0))
|
|
overlay_line = RenderLine.from_rendered_text("xxx")
|
|
result = screen.with_overlay(1, [overlay_line])
|
|
|
|
self.assertEqual(len(result.overlays), 1)
|
|
self.assertEqual(result.composed_lines[0].text, "aaa")
|
|
self.assertEqual(result.composed_lines[1].text, "xxx")
|
|
|
|
def test_compose_replace_overlay(self):
|
|
base = RenderedScreen.from_screen_lines(["aa", "bb", "cc"], (0, 0))
|
|
overlay_line = RenderLine.from_rendered_text("XX")
|
|
screen = RenderedScreen(
|
|
base.lines,
|
|
(0, 0),
|
|
(ScreenOverlay(y=1, lines=(overlay_line,)),),
|
|
)
|
|
|
|
self.assertEqual(screen.composed_lines[0].text, "aa")
|
|
self.assertEqual(screen.composed_lines[1].text, "XX")
|
|
self.assertEqual(screen.composed_lines[2].text, "cc")
|
|
|
|
def test_compose_insert_overlay(self):
|
|
base = RenderedScreen.from_screen_lines(["aa", "bb"], (0, 0))
|
|
overlay_line = RenderLine.from_rendered_text("INS")
|
|
screen = RenderedScreen(
|
|
base.lines,
|
|
(0, 0),
|
|
(ScreenOverlay(y=1, lines=(overlay_line,), insert=True),),
|
|
)
|
|
|
|
self.assertEqual(len(screen.composed_lines), 3)
|
|
self.assertEqual(screen.composed_lines[0].text, "aa")
|
|
self.assertEqual(screen.composed_lines[1].text, "INS")
|
|
self.assertEqual(screen.composed_lines[2].text, "bb")
|
|
|
|
def test_compose_replace_extends_beyond_lines(self):
|
|
base = RenderedScreen.from_screen_lines(["aa"], (0, 0))
|
|
overlay_line = RenderLine.from_rendered_text("XX")
|
|
screen = RenderedScreen(
|
|
base.lines,
|
|
(0, 0),
|
|
(ScreenOverlay(y=1, lines=(overlay_line,)),),
|
|
)
|
|
|
|
self.assertEqual(len(screen.composed_lines), 2)
|
|
self.assertEqual(screen.composed_lines[1].text, "XX")
|
|
|
|
|
|
class TestRenderCell(TestCase):
|
|
def test_terminal_text(self):
|
|
cell = RenderCell("x", 1, style=StyleRef.from_sgr("\x1b[32m"))
|
|
self.assertEqual(cell.terminal_text, "\x1b[32mx\x1b[0m")
|
|
|
|
def test_terminal_text_plain(self):
|
|
cell = RenderCell("y", 1)
|
|
self.assertEqual(cell.terminal_text, "y")
|
|
|
|
|
|
class TestRenderCells(TestCase):
|
|
def test_render_cells_with_controls(self):
|
|
cells = [
|
|
RenderCell("", 0, controls=("\x1b[K",)),
|
|
RenderCell("a", 1),
|
|
]
|
|
result = render_cells(cells)
|
|
self.assertEqual(result, "\x1b[Ka")
|
|
|
|
def test_render_cells_skips_empty_text(self):
|
|
cells = [
|
|
RenderCell("", 0),
|
|
RenderCell("a", 1),
|
|
]
|
|
result = render_cells(cells)
|
|
self.assertEqual(result, "a")
|
|
|
|
def test_render_cells_with_visual_style(self):
|
|
cells = [RenderCell("a", 1)]
|
|
result = render_cells(cells, visual_style="\x1b[7m")
|
|
self.assertEqual(result, "\x1b[7ma\x1b[0m")
|
|
|
|
|
|
class TestLineUpdate(TestCase):
|
|
def test_post_init_renders_text(self):
|
|
cells = (RenderCell("a", 1), RenderCell("b", 1))
|
|
update = LineUpdate(
|
|
kind="insert_char",
|
|
y=0,
|
|
start_cell=0,
|
|
start_x=0,
|
|
cells=cells,
|
|
)
|
|
self.assertEqual(update.text, "ab")
|
|
|
|
|
|
class TestRequiresCursorResync(TestCase):
|
|
def test_no_controls(self):
|
|
cells = [RenderCell("a", 1)]
|
|
self.assertFalse(requires_cursor_resync(cells))
|
|
|
|
def test_sgr_only_does_not_require_resync(self):
|
|
cells = [RenderCell("", 0, controls=("\x1b[31m",))]
|
|
self.assertFalse(requires_cursor_resync(cells))
|
|
|
|
def test_non_sgr_requires_resync(self):
|
|
cells = [RenderCell("", 0, controls=("\x1b[H",))]
|
|
self.assertTrue(requires_cursor_resync(cells))
|