Add a test suite for _pyrepl.layout

Author: ambv

Lib/test/test_pyrepl/test_layout.py

@@ -0,0 +1,310 @@
+from unittest import TestCase
+from _pyrepl.content import (
+    ContentFragment,
+    ContentLine,
+    PromptContent,
+    SourceLine,
+)
+from _pyrepl.layout import (
+    LayoutMap,
+    LayoutRow,
+    WrappedRow,
+    layout_content_lines,
+)
+
+
+def _source(text, lineno=0, start_offset=0, has_newline=True, cursor_index=None):
+    return SourceLine(lineno, text, start_offset, has_newline, cursor_index)
+
+
+def _prompt(text=">>> ", width=4):
+    return PromptContent((), text, width)
+
+
+def _body_from_text(text):
+    return tuple(ContentFragment(ch, 1) for ch in text)
+
+
+def _content_line(text, prompt=None, has_newline=True, start_offset=0):
+    if prompt is None:
+        prompt = _prompt()
+    body = _body_from_text(text)
+    source = _source(text, start_offset=start_offset, has_newline=has_newline)
+    return ContentLine(source, prompt, body)
+
+
+class TestLayoutRow(TestCase):
+    def test_width_basic(self):
+        row = LayoutRow(4, (1, 1, 1))
+        self.assertEqual(row.width, 7)
+
+    def test_width_with_suffix(self):
+        row = LayoutRow(4, (1, 1), suffix_width=1)
+        self.assertEqual(row.width, 7)
+
+    def test_screeninfo_without_suffix(self):
+        row = LayoutRow(4, (1, 1, 1))
+        prompt_w, widths = row.screeninfo
+        self.assertEqual(prompt_w, 4)
+        self.assertEqual(widths, [1, 1, 1])
+
+    def test_screeninfo_with_suffix(self):
+        row = LayoutRow(4, (1, 1), suffix_width=1)
+        prompt_w, widths = row.screeninfo
+        self.assertEqual(prompt_w, 4)
+        self.assertEqual(widths, [1, 1, 1])
+
+
+class TestLayoutMap(TestCase):
+    def test_empty(self):
+        lm = LayoutMap.empty()
+        self.assertEqual(len(lm.rows), 1)
+        self.assertEqual(lm.max_row(), 0)
+        self.assertEqual(lm.max_column(0), 0)
+
+    def test_screeninfo(self):
+        lm = LayoutMap((
+            LayoutRow(4, (1, 1, 1)),
+            LayoutRow(0, (1, 1)),
+        ))
+        info = lm.screeninfo
+        self.assertEqual(len(info), 2)
+        self.assertEqual(info[0], (4, [1, 1, 1]))
+        self.assertEqual(info[1], (0, [1, 1]))
+
+    def test_max_column(self):
+        lm = LayoutMap((LayoutRow(4, (1, 1, 1)),))
+        self.assertEqual(lm.max_column(0), 7)
+
+    def test_max_row(self):
+        lm = LayoutMap((LayoutRow(0, ()), LayoutRow(0, ())))
+        self.assertEqual(lm.max_row(), 1)
+
+    def test_pos_to_xy_empty_rows(self):
+        lm = LayoutMap(())
+        self.assertEqual(lm.pos_to_xy(0), (0, 0))
+
+    def test_pos_to_xy_single_row(self):
+        lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),))
+        self.assertEqual(lm.pos_to_xy(0), (4, 0))
+        self.assertEqual(lm.pos_to_xy(1), (5, 0))
+        self.assertEqual(lm.pos_to_xy(2), (6, 0))
+        self.assertEqual(lm.pos_to_xy(3), (7, 0))
+
+    def test_pos_to_xy_multi_row(self):
+        lm = LayoutMap((
+            LayoutRow(4, (1, 1, 1), buffer_advance=4),
+            LayoutRow(4, (1, 1), buffer_advance=2),
+        ))
+        # First row: pos 0-3
+        self.assertEqual(lm.pos_to_xy(0), (4, 0))
+        self.assertEqual(lm.pos_to_xy(3), (7, 0))
+        # Second row: pos 4-5
+        self.assertEqual(lm.pos_to_xy(4), (4, 1))
+        self.assertEqual(lm.pos_to_xy(5), (5, 1))
+
+    def test_pos_to_xy_past_end_clamps(self):
+        lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),))
+        self.assertEqual(lm.pos_to_xy(99), (6, 0))
+
+    def test_pos_to_xy_skips_prompt_only_leading_rows(self):
+        lm = LayoutMap((
+            LayoutRow(0, (), buffer_advance=0),  # leading prompt-only row
+            LayoutRow(4, (1, 1), buffer_advance=3),
+        ))
+        # pos 0 should skip the leading row and land on the real row
+        self.assertEqual(lm.pos_to_xy(0), (4, 1))
+
+    def test_pos_to_xy_with_suffix(self):
+        lm = LayoutMap((
+            LayoutRow(4, (1, 1), suffix_width=1, buffer_advance=2),
+            LayoutRow(0, (1,), buffer_advance=2),
+        ))
+        # pos=2 fits within first row's char_widths (len=2), cursor at end
+        self.assertEqual(lm.pos_to_xy(2), (6, 0))
+        # pos=3 exceeds first row, lands on second row
+        self.assertEqual(lm.pos_to_xy(3), (1, 1))
+
+    def test_xy_to_pos_empty_rows(self):
+        lm = LayoutMap(())
+        self.assertEqual(lm.xy_to_pos(0, 0), 0)
+
+    def test_xy_to_pos_single_row(self):
+        lm = LayoutMap((LayoutRow(4, (1, 1, 1), buffer_advance=3),))
+        self.assertEqual(lm.xy_to_pos(4, 0), 0)
+        self.assertEqual(lm.xy_to_pos(5, 0), 1)
+        self.assertEqual(lm.xy_to_pos(6, 0), 2)
+        self.assertEqual(lm.xy_to_pos(7, 0), 3)
+
+    def test_xy_to_pos_multi_row(self):
+        lm = LayoutMap((
+            LayoutRow(4, (1, 1, 1), buffer_advance=4),
+            LayoutRow(4, (1, 1), buffer_advance=2),
+        ))
+        self.assertEqual(lm.xy_to_pos(4, 0), 0)
+        self.assertEqual(lm.xy_to_pos(4, 1), 4)
+        self.assertEqual(lm.xy_to_pos(5, 1), 5)
+
+    def test_xy_to_pos_before_prompt_returns_zero(self):
+        lm = LayoutMap((LayoutRow(4, (1, 1), buffer_advance=2),))
+        self.assertEqual(lm.xy_to_pos(0, 0), 0)
+
+    def test_xy_to_pos_with_zero_width_chars(self):
+        # Simulates combining characters (zero-width) after a base char
+        lm = LayoutMap((LayoutRow(4, (1, 0, 1), buffer_advance=3),))
+        # x=5 is past the first char; trailing zero-width combining is included
+        self.assertEqual(lm.xy_to_pos(5, 0), 2)
+
+    def test_xy_to_pos_zero_width_skipped(self):
+        lm = LayoutMap((LayoutRow(0, (0, 1, 1), buffer_advance=3),))
+        # x=0: the zero-width char at index 0 is skipped, pos advances
+        self.assertEqual(lm.xy_to_pos(0, 0), 1)
+
+    def test_xy_to_pos_zero_width_before_target(self):
+        # Zero-width char between two normal chars; target x is past it
+        lm = LayoutMap((LayoutRow(0, (1, 0, 1), buffer_advance=3),))
+        # x=2: passes char at x=0 (w=1), skips zero-width at x=1, lands at x=2
+        self.assertEqual(lm.xy_to_pos(2, 0), 3)
+
+    def test_xy_to_pos_trailing_all_zero_width(self):
+        # All remaining chars from cursor position are zero-width
+        lm = LayoutMap((LayoutRow(0, (1, 0), buffer_advance=2),))
+        # x=1: past first char, trailing loop exhausts (all remaining are 0-width)
+        self.assertEqual(lm.xy_to_pos(1, 0), 2)
+
+
+class TestLayoutContentLines(TestCase):
+    def test_zero_width_returns_empty(self):
+        result = layout_content_lines((), 0, 0)
+        self.assertEqual(result.wrapped_rows, ())
+        self.assertEqual(result.layout_map.rows, ())
+
+    def test_negative_width_returns_empty(self):
+        result = layout_content_lines((), -1, 0)
+        self.assertEqual(result.wrapped_rows, ())
+
+    def test_single_short_line(self):
+        line = _content_line("abc")
+        result = layout_content_lines((line,), 80, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 1)
+        row = result.wrapped_rows[0]
+        self.assertEqual(row.prompt_text, ">>> ")
+        self.assertEqual(row.prompt_width, 4)
+        self.assertEqual(row.suffix, "")
+        self.assertEqual(row.buffer_advance, 4)  # 3 chars + newline
+
+    def test_single_line_no_newline(self):
+        line = _content_line("ab", has_newline=False)
+        result = layout_content_lines((line,), 80, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 1)
+        self.assertEqual(result.wrapped_rows[0].buffer_advance, 2)
+
+    def test_empty_body(self):
+        source = _source("", has_newline=True)
+        prompt = _prompt()
+        line = ContentLine(source, prompt, ())
+        result = layout_content_lines((line,), 80, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 1)
+        self.assertEqual(result.wrapped_rows[0].buffer_advance, 1)  # just newline
+
+    def test_line_wraps(self):
+        # prompt ">>> " is 4 wide, terminal is 10 wide, so 6 chars fit per row
+        line = _content_line("abcdefgh")  # 8 chars, needs 2 rows
+        result = layout_content_lines((line,), 10, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 2)
+        first, second = result.wrapped_rows
+        self.assertEqual(first.prompt_text, ">>> ")
+        self.assertEqual(first.suffix, "\\")
+        self.assertEqual(first.suffix_width, 1)
+        # First row: 10 - 4(prompt) - 1(suffix) = 5 chars
+        self.assertEqual(first.buffer_advance, 5)
+        # Second row: continuation with no prompt
+        self.assertEqual(second.prompt_text, "")
+        self.assertEqual(second.prompt_width, 0)
+        self.assertEqual(second.buffer_advance, 4)  # remaining 3 + newline
+        self.assertEqual(second.suffix, "")
+
+    def test_wrapping_forces_progress(self):
+        # When a single character is wider than available space, force 1 char
+        prompt = _prompt("P", 1)
+        body = (ContentFragment("W", 1),)
+        source = _source("W", has_newline=False)
+        line = ContentLine(source, prompt, body)
+        # width=2 means prompt(1) + char(1) = 2, which fits (< width would be
+        # false for width=2 since 1+1 >= 2), so it wraps but forces progress
+        result = layout_content_lines((line,), 2, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 1)
+        self.assertEqual(result.wrapped_rows[0].buffer_advance, 1)
+
+    def test_layout_map_matches_wrapped_rows(self):
+        line = _content_line("abc")
+        result = layout_content_lines((line,), 80, 0)
+
+        self.assertEqual(len(result.layout_map.rows), len(result.wrapped_rows))
+        self.assertEqual(result.layout_map.rows[0].prompt_width, 4)
+        self.assertEqual(result.layout_map.rows[0].char_widths, (1, 1, 1))
+
+    def test_line_end_offsets(self):
+        line1 = _content_line("ab")
+        line2 = _content_line("cd")
+        result = layout_content_lines((line1, line2), 80, 0)
+
+        self.assertEqual(len(result.line_end_offsets), 2)
+        # line1: 2 chars + 1 newline = offset 3
+        self.assertEqual(result.line_end_offsets[0], 3)
+        # line2: offset 3 + 2 chars + 1 newline = 6
+        self.assertEqual(result.line_end_offsets[1], 6)
+
+    def test_start_offset_shifts_offsets(self):
+        line = _content_line("ab")
+        result = layout_content_lines((line,), 80, 10)
+
+        self.assertEqual(result.line_end_offsets[0], 13)
+
+    def test_multiple_lines(self):
+        line1 = _content_line("abc")
+        line2 = _content_line("de")
+        result = layout_content_lines((line1, line2), 80, 0)
+
+        self.assertEqual(len(result.wrapped_rows), 2)
+        self.assertEqual(result.wrapped_rows[0].buffer_advance, 4)  # abc + \n
+        self.assertEqual(result.wrapped_rows[1].buffer_advance, 3)  # de + \n
+
+    def test_leading_prompt_lines(self):
+        leading = (ContentFragment("header", 6),)
+        prompt = PromptContent(leading, ">>> ", 4)
+        body = _body_from_text("x")
+        source = _source("x", has_newline=False)
+        line = ContentLine(source, prompt, body)
+        result = layout_content_lines((line,), 80, 0)
+
+        # Leading line + body line
+        self.assertEqual(len(result.wrapped_rows), 2)
+        # Leading row has the fragment but no prompt
+        self.assertEqual(result.wrapped_rows[0].fragments, leading)
+        # Body row has prompt and content
+        self.assertEqual(result.wrapped_rows[1].prompt_text, ">>> ")
+
+    def test_wrapped_line_layout_rows_have_suffix(self):
+        line = _content_line("abcdefgh")
+        result = layout_content_lines((line,), 10, 0)
+
+        first_layout = result.layout_map.rows[0]
+        self.assertEqual(first_layout.suffix_width, 1)
+        second_layout = result.layout_map.rows[1]
+        self.assertEqual(second_layout.suffix_width, 0)
+
+    def test_pos_to_xy_through_layout(self):
+        line = _content_line("abc")
+        result = layout_content_lines((line,), 80, 0)
+        lm = result.layout_map
+
+        self.assertEqual(lm.pos_to_xy(0), (4, 0))  # after prompt
+        self.assertEqual(lm.pos_to_xy(1), (5, 0))
+        self.assertEqual(lm.pos_to_xy(2), (6, 0))
+        self.assertEqual(lm.pos_to_xy(3), (7, 0))  # end of line