Add the review's test-coverage batch (T1-T4, T6)

- T1: three-piece FAMILY_FIRST_GIVEN_LAST pins given-from-the-END
  semantics (not a rotation of FAMILY_FIRST)
- T2: reverse-coverage property -- every input char lies in a token
  span, a masked delimited span, or is individually ignorable; no
  character silently vanishes
- T3: case row for post-comma non-suffix extras ('Smith, John, Extra,
  Jr.' -> suffix 'Extra, Jr.' + COMMA_STRUCTURE; v1 parity pinned live)
- T4: multiple unbalanced delimiters are each reported; the scan does
  not stop at the first unmatched opener
- T6: digits join the Hypothesis stress alphabet

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: derek73

tests/v2/cases.py

@@ -40,6 +40,12 @@ class Case:
          {"given": "John", "family": "Smith"}),
     Case("suffix_comma", "John Smith, PhD",
          {"given": "John", "family": "Smith", "suffix": "PhD"}),
+    Case("comma_extras_become_suffixes", "Smith, John, Extra, Jr.",
+         {"given": "John", "family": "Smith", "suffix": "Extra, Jr."},
+         ambiguities=("comma-structure",),
+         notes="post-comma segments land in suffix even when not "
+               "suffix-shaped; the ambiguity flags the guess (v1 "
+               "parity, pinned live 2026-07-13)"),
     Case("delavega", "Dr. Juan de la Vega III",
          {"title": "Dr.", "given": "Juan", "family": "de la Vega",
           "suffix": "III"}),

tests/v2/test_parser.py

@@ -3,7 +3,9 @@
 import pytest
 
 from nameparser import Lexicon, Locale, Parser, Policy, PolicyPatch, parse, parser_for
-from nameparser._policy import FAMILY_FIRST, PatronymicRule
+from nameparser._policy import (
+    FAMILY_FIRST, FAMILY_FIRST_GIVEN_LAST, PatronymicRule,
+)
 from nameparser._types import AmbiguityKind
 
 
@@ -128,6 +130,26 @@ def test_matches_component_wise_case_insensitive() -> None:
         pn.matches(42)  # type: ignore[arg-type]
 
 
+def test_family_first_given_last_places_middle_between() -> None:
+    # T1: the three-piece FAMILY_FIRST_GIVEN_LAST assignment -- family
+    # from the front, given from the END, middle between (not a rotation
+    # of FAMILY_FIRST)
+    p = Parser(policy=Policy(name_order=FAMILY_FIRST_GIVEN_LAST))
+    pn = p.parse("Zeng Xiao Long")
+    assert (pn.family, pn.middle, pn.given) == ("Zeng", "Xiao", "Long")
+
+
+def test_multiple_unbalanced_delimiters_each_reported() -> None:
+    # T4: the extract scan continues past the first unmatched opener;
+    # each one is reported and treated as literal text
+    pn = parse('John "Jack (Smith')
+    unbalanced = [a for a in pn.ambiguities
+                  if a.kind is AmbiguityKind.UNBALANCED_DELIMITER]
+    assert len(unbalanced) == 2
+    assert pn.given == "John" and pn.family == "(Smith"
+    assert not pn.nickname
+
+
 def test_matches_accepts_explicit_parser() -> None:
     family_first = Parser(policy=Policy(name_order=FAMILY_FIRST))
     pn = family_first.parse("Yamada Taro")

tests/v2/test_properties.py

@@ -9,10 +9,12 @@
 from hypothesis import given, settings
 from hypothesis import strategies as st
 
-from nameparser import parse
+from nameparser import Lexicon, Policy, parse
+from nameparser._pipeline import run
+from nameparser._pipeline._state import ParseState
 
 _ALPHABET = st.sampled_from(
-    'abcdefgh ABC .,،，\'"()«»‏‏\U0001f600éñßЖ-')
+    'abcdefgh ABC 12 .,،，\'"()«»‏‏\U0001f600éñßЖ-')
 
 
 @given(st.text(alphabet=_ALPHABET, max_size=200))
@@ -50,3 +52,27 @@ def test_render_reparse_reaches_fixpoint(text: str) -> None:
             break
         s = nxt
     assert str(parse(s)) == s, f"no fixpoint within 10 rounds: {s!r}"
+
+
+@given(st.text(alphabet=_ALPHABET, max_size=100))
+@settings(max_examples=300, deadline=None, derandomize=True)
+def test_every_original_char_is_accounted_for(text: str) -> None:
+    # Reverse coverage (the dual of provenance): no character of the
+    # input silently vanishes. Every char lies in a token span, a
+    # masked delimited span, or is individually ignorable -- whitespace,
+    # a structural comma, or a char the strip options remove. Checked on
+    # the pre-assembly state because dropped/extracted tokens keep their
+    # spans there.
+    state = run(ParseState(original=text, lexicon=Lexicon.default(),
+                           policy=Policy()))
+    covered: set[int] = set()
+    for tok in state.tokens:
+        covered.update(range(tok.span.start, tok.span.end))
+    for span in state.masked:
+        covered.update(range(span.start, span.end))
+    ignorable = {",", "،", "，", "\U0001f600", "‏"}
+    for i, ch in enumerate(text):
+        if i in covered or ch.isspace() or ch in ignorable:
+            continue
+        raise AssertionError(
+            f"char {ch!r} at {i} in {text!r} is unaccounted for")