Achieve 100% statement and branch coverage in test_render

Author: ambv

Lib/test/test_pyrepl/test_render.py

@@ -1,10 +1,14 @@
 from unittest import TestCase
 from _pyrepl.render import (
+    LineUpdate,
+    RenderCell,
     RenderLine,
     RenderedScreen,
+    ScreenOverlay,
     StyleRef,
     diff_render_lines,
     render_cells,
+    requires_cursor_resync,
 )
 
 
@@ -38,6 +42,45 @@ def test_from_parts_accepts_style_refs(self):
         )
         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):
@@ -94,10 +137,175 @@ def test_keyword_space_inserts_only_space_after_reset(self):
         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))