test: add coverage for trailing suffix_not_acronyms in lastname-comma format

Add tests for 'V' (same ambiguity as 'I'), no-middle case, single-letter
middle-initial-before-suffix pattern, and an xfail documenting the known
limitation when an explicit comma-suffix segment is present. Also tighten
the is_suffix_at_lastname_comma_end docstring to explain the parts parameter
semantics and the three conditions that must hold.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: derek73

nameparser/parser.py

@@ -505,14 +505,21 @@ def are_suffixes_after_comma(self, pieces: Iterable[str]) -> bool:
         return True
 
     def is_suffix_at_lastname_comma_end(self, piece: str, nxt: str | None, parts: list[str]) -> bool:
-        """True when a suffix_not_acronyms member is the final token in the
-        post-comma segment of a lastname-comma name with no explicit
-        comma-separated suffix (e.g. 'Maier, Amy Lauren I').
-
-        When parts[2] exists the caller already has an explicit suffix, making
-        the trailing single-letter more likely a middle initial
-        (e.g. 'Doe, Rev. John V, Jr.'), so the guard len(parts)==2 excludes
-        that case.
+        """True when ``piece`` is a suffix_not_acronyms member that should be
+        treated as a suffix at the end of ``parts[1]`` (the post-comma segment)
+        in a lastname-comma name, where ``parts`` is the full comma-split of the
+        name string.
+
+        Returns True only when all three conditions hold:
+        - ``nxt is None``: piece is the last token in the post-comma segment
+        - ``len(parts) == 2``: no ``parts[2]`` suffix segment exists
+        - ``lc(piece) in suffix_not_acronyms``
+
+        When ``parts[2]`` exists the caller already declared an explicit suffix
+        via comma (e.g. 'Doe, Rev. John V, Jr.'), making the trailing token more
+        likely a middle initial; ``len(parts) == 2`` excludes that case.
+        Used as an OR alternative to ``is_suffix()`` for pieces that
+        ``is_suffix()`` would reject via ``is_an_initial()``.
         """
         return (nxt is None
                 and len(parts) == 2

tests/test_suffixes.py

@@ -167,13 +167,47 @@ def test_suffix_with_periods_with_lastname_comma(self) -> None:
         self.m(hn.suffix, "Msc.Ed.", hn)
 
     def test_roman_numeral_i_lastname_comma_format(self) -> None:
-        # trailing 'I' in lastname-comma format must be a suffix, not a middle initial (issue #144)
+        # 'I' is in suffix_not_acronyms; trailing suffix_not_acronyms members in
+        # "Lastname, First Middle Suffix" format (no comma-suffix segment) must
+        # parse as suffix, not middle initial (issue #144)
         hn = HumanName("Maier, Amy Lauren I")
         self.m(hn.first, "Amy", hn)
         self.m(hn.middle, "Lauren", hn)
         self.m(hn.last, "Maier", hn)
         self.m(hn.suffix, "I", hn)
 
+    def test_roman_numeral_v_lastname_comma_format(self) -> None:
+        # 'V' shares the same suffix_not_acronyms ambiguity as 'I' (issue #144)
+        hn = HumanName("Smith, John V")
+        self.m(hn.first, "John", hn)
+        self.m(hn.middle, "", hn)
+        self.m(hn.last, "Smith", hn)
+        self.m(hn.suffix, "V", hn)
+
+    def test_roman_numeral_i_no_middle_lastname_comma_format(self) -> None:
+        # no middle name: trailing 'I' must still be a suffix (issue #144)
+        hn = HumanName("Smith, John I")
+        self.m(hn.first, "John", hn)
+        self.m(hn.middle, "", hn)
+        self.m(hn.last, "Smith", hn)
+        self.m(hn.suffix, "I", hn)
+
+    def test_roman_numeral_i_after_single_initial_lastname_comma_format(self) -> None:
+        # single-letter middle initial followed by trailing 'I' (reporter pattern, issue #144)
+        hn = HumanName("Chang, Andy C I")
+        self.m(hn.first, "Andy", hn)
+        self.m(hn.middle, "C", hn)
+        self.m(hn.last, "Chang", hn)
+        self.m(hn.suffix, "I", hn)
+
+    @pytest.mark.xfail
+    def test_roman_numeral_i_with_explicit_suffix_comma_known_limitation(self) -> None:
+        # When an explicit suffix comma is present (len(parts)==3), the trailing 'I'
+        # is conservatively left in middle to avoid misclassifying true initials.
+        # This is a known limitation of is_suffix_at_lastname_comma_end (issue #144).
+        hn = HumanName("Maier, Amy I, Jr.")
+        self.m(hn.suffix, "I, Jr.", hn)
+
     def test_suffix_delimiter_default_on_constants(self) -> None:
         from nameparser.config import CONSTANTS
         self.assertIs(CONSTANTS.suffix_delimiter, None)