test_python_api.py

import copy
import pickle
import re
import warnings

import pytest

try:
    import dill
except ImportError:
    dill = False  # type: ignore[assignment]

from nameparser import HumanName
from nameparser.config import CONSTANTS, Constants, TupleManager

from tests.base import HumanNameTestBase


class HumanNamePythonTests(HumanNameTestBase):

    def test_utf8(self) -> None:
        hn = HumanName("de la Véña, Jüan")
        self.m(hn.first, "Jüan", hn)
        self.m(hn.last, "de la Véña", hn)

    def test_string_output(self) -> None:
        hn = HumanName("de la Véña, Jüan")
        self.m(str(hn), "Jüan de la Véña", hn)

    def test_escaped_utf8_bytes(self) -> None:
        # bytes input was removed in 2.0 (#245, warned since 1.3.0):
        # decode first
        with pytest.raises(TypeError, match="decode"):
            HumanName(b'B\xc3\xb6ck, Gerald')  # type: ignore[arg-type]
        hn = HumanName(b'B\xc3\xb6ck, Gerald'.decode('utf-8'))
        self.m(hn.first, "Gerald", hn)
        self.m(hn.last, "Böck", hn)

    def test_bytes_full_name_raises_with_decode_hint(self) -> None:
        # bytes input was removed in 2.0 (#245); both entry points raise
        with pytest.raises(TypeError, match="decode"):
            HumanName(b'John Smith')  # type: ignore[arg-type]
        hn = HumanName("Jane Doe")
        with pytest.raises(TypeError, match="decode"):
            hn.full_name = b'John Smith'  # type: ignore[assignment]
        # the failed assignment must not have corrupted the parse
        self.m(hn.first, "Jane", hn)

    def test_str_full_name_does_not_warn(self) -> None:
        with warnings.catch_warnings():
            warnings.simplefilter("error")
            hn = HumanName("John Smith")
            hn.full_name = "Jane Doe"
        self.m(hn.first, "Jane", hn)

    def test_len(self) -> None:
        hn = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
        self.m(len(hn), 5, hn)
        hn = HumanName("John Doe")
        self.m(len(hn), 2, hn)
        # empty input parses to an all-empty name; len == 0 is the
        # documented emptiness check (see usage.rst)
        self.assertEqual(len(HumanName("")), 0)

    def test_iteration_restarts_after_break(self) -> None:
        hn = HumanName("John Doe")
        for _ in hn:
            break
        # a plain loop, not list(hn): list() presizes via __len__, which
        # under the old shared-cursor implementation reset the cursor and
        # masked this bug
        collected = []
        for part in hn:
            collected.append(part)
        self.assertEqual(collected, ["John", "Doe"])

    def test_iterators_are_independent(self) -> None:
        hn = HumanName("John Doe")
        it1 = iter(hn)
        it2 = iter(hn)
        self.assertEqual(next(it1), "John")
        self.assertEqual(next(it2), "John")
        self.assertEqual(next(it1), "Doe")
        self.assertEqual(next(it2), "Doe")

    def test_len_during_iteration(self) -> None:
        hn = HumanName("John Doe")
        it = iter(hn)
        self.assertEqual(next(it), "John")
        # len() must count all members and leave the live iterator intact
        self.assertEqual(len(hn), 2)
        self.assertEqual(next(it), "Doe")

    def test_instance_is_not_its_own_iterator(self) -> None:
        # iterator state must never live on the instance; see release log
        # for the next(name) -> next(iter(name)) migration
        hn = HumanName("John Doe")
        with pytest.raises(TypeError):
            next(hn)  # type: ignore[call-overload]

    def test_iterating_empty_name_yields_nothing(self) -> None:
        collected = []
        for part in HumanName(""):
            collected.append(part)
        self.assertEqual(collected, [])

    @pytest.mark.skipif(not dill, reason="requires python-dill module to test pickling")
    def test_config_pickle(self) -> None:
        constants = Constants()
        self.assertTrue(dill.pickles(constants))

    @pytest.mark.skipif(not dill, reason="requires python-dill module to test pickling")
    def test_name_instance_pickle(self) -> None:
        hn = HumanName("Title First Middle Middle Last, Jr.")
        self.assertTrue(dill.pickles(hn))

    def test_name_instance_pickle_preserves_instance_config(self) -> None:
        """A HumanName carrying its own config must parse identically after a
        pickle round-trip.

        HumanName pickles its instance Constants (``.C``) through the default
        __dict__ path, so a broken Constants round-trip silently produced a
        differently-configured parser on the other side.
        """
        # Passing None as the second argument gives this name its own Constants.
        hn = HumanName("Smith, Dr. John", Constants())
        hn.C.titles.add('chancellor')
        hn.parse_full_name()

        # Safe: round-tripping a HumanName the test just built, not untrusted data.
        restored = pickle.loads(pickle.dumps(hn))

        self.assertIn('chancellor', restored.C.titles)
        restored.full_name = "Chancellor Jane Smith"
        self.assertEqual(restored.title, "Chancellor")

    def test_name_instance_deepcopy(self) -> None:
        """copy.deepcopy of a HumanName must round-trip.

        HumanName has no custom copy hooks, so deepcopy recurses into its
        Constants (`.C`), and previously into `.C.regexes`, whose __getattr__
        answered copy's __deepcopy__ probe with a re.Pattern — making
        deepcopy of *any* HumanName raise TypeError.
        """
        hn = HumanName("Dr. John P. Doe-Ray, CLU")

        dup = copy.deepcopy(hn)

        self.assertEqual(str(dup), str(hn))

    def test_name_instance_deepcopy_isolates_instance_config(self) -> None:
        """A deep-copied HumanName with its own config must be independent."""
        hn = HumanName("Smith, Dr. John", Constants())
        hn.C.titles.add('chancellor')

        dup = copy.deepcopy(hn)
        dup.C.titles.add('marker')

        self.assertIn('chancellor', dup.C.titles)
        self.assertNotIn('marker', hn.C.titles)

    def test_pickle_default_name_preserves_singleton_identity(self) -> None:
        """A default HumanName must re-attach to CONSTANTS after a pickle round-trip.

        Without __getstate__/__setstate__, pickle serializes .C by value, so the
        restored name gets a detached copy — has_own_config flips to True and
        every pickled default name carries a full Constants copy.
        """
        hn = HumanName("John Doe")
        self.assertFalse(hn.has_own_config)
        self.assertIs(hn.C, CONSTANTS)

        # Safe: round-tripping an object we just built, not untrusted data.
        restored = pickle.loads(pickle.dumps(hn))

        self.assertIs(restored.C, CONSTANTS)
        self.assertFalse(restored.has_own_config)
        self.assertEqual(str(restored), str(hn))
        self.assertEqual(restored.first, hn.first)
        self.assertEqual(restored.last, hn.last)

    def test_pickle_instance_config_name_preserves_own_config(self) -> None:
        """A HumanName with its own Constants must not be collapsed onto CONSTANTS after pickle."""
        hn = HumanName("Smith, Dr. John", Constants())
        hn.C.titles.add('chancellor')
        hn.parse_full_name()
        self.assertTrue(hn.has_own_config)
        self.assertIsNot(hn.C, CONSTANTS)

        # Safe: round-tripping a HumanName the test just built, not untrusted data.
        restored = pickle.loads(pickle.dumps(hn))

        self.assertTrue(restored.has_own_config)
        self.assertIsNot(restored.C, CONSTANTS)
        self.assertIn('chancellor', restored.C.titles)

    def test_shallow_copy_default_name_preserves_singleton_identity(self) -> None:
        """copy.copy of a default HumanName shares the CONSTANTS reference without hooks."""
        hn = HumanName("John Doe")

        sc = copy.copy(hn)

        self.assertIs(sc.C, CONSTANTS)
        self.assertFalse(sc.has_own_config)

    def test_deepcopy_default_name_preserves_singleton_identity(self) -> None:
        """copy.deepcopy of a default HumanName must re-attach to CONSTANTS."""
        hn = HumanName("John Doe")

        dup = copy.deepcopy(hn)

        self.assertIs(dup.C, CONSTANTS)
        self.assertFalse(dup.has_own_config)
        self.assertEqual(str(dup), str(hn))
        self.assertEqual(dup.first, hn.first)
        self.assertEqual(dup.last, hn.last)

    def test_comparison(self) -> None:
        # == and hash reverted to object identity in 2.0 (#223, warned since
        # 1.3.0): distinct instances never compare equal, however they parse,
        # and strings never match. matches()/comparison_key() are the
        # replacements (covered below).
        hn1 = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
        hn2 = HumanName("Dr. John P. Doe-Ray, CLU, CFP, LUTC")
        self.assertTrue(hn1 == hn1)
        self.assertFalse(hn1 == hn2)
        self.assertIsNot(hn1, hn2)
        self.assertFalse(hn1 == "Dr. John P. Doe-Ray CLU, CFP, LUTC")
        self.assertTrue(hn1.matches(hn2))  # the 2.0 spelling of the old ==
        hn1 = HumanName("Doe, Dr. John P., CLU, CFP, LUTC")
        hn2 = HumanName("Dr. John P. Doe-Ray, CLU, CFP, LUTC")
        self.assertTrue(not hn1 == hn2)
        self.assertTrue(not hn1 == 0)
        self.assertTrue(not hn1 == "test")
        self.assertTrue(not hn1 == ["test"])
        self.assertTrue(not hn1 == {"test": hn2})

    def test_assignment_to_full_name(self) -> None:
        hn = HumanName("John A. Kenneth Doe, Jr.")
        self.m(hn.first, "John", hn)
        self.m(hn.last, "Doe", hn)
        self.m(hn.middle, "A. Kenneth", hn)
        self.m(hn.suffix, "Jr.", hn)
        hn.full_name = "Juan Velasquez y Garcia III"
        self.m(hn.first, "Juan", hn)
        self.m(hn.last, "Velasquez y Garcia", hn)
        self.m(hn.suffix, "III", hn)

    def test_assignment_to_attribute(self) -> None:
        hn = HumanName("John A. Kenneth Doe, Jr.")
        hn.last = "de la Vega"
        self.m(hn.last, "de la Vega", hn)
        hn.title = "test"
        self.m(hn.title, "test", hn)
        hn.first = "test"
        self.m(hn.first, "test", hn)
        hn.middle = "test"
        self.m(hn.middle, "test", hn)
        hn.suffix = "test"
        self.m(hn.suffix, "test", hn)
        with pytest.raises(TypeError):
            hn.suffix = [['test']]  # type: ignore[list-item]
        with pytest.raises(TypeError):
            hn.suffix = {"test": "test"}  # type: ignore[assignment]

    def test_assign_list_to_attribute(self) -> None:
        hn = HumanName("John A. Kenneth Doe, Jr.")
        hn.title = ["test1", "test2"]
        self.m(hn.title, "test1 test2", hn)
        hn.first = ["test3", "test4"]
        self.m(hn.first, "test3 test4", hn)
        hn.middle = ["test5", "test6", "test7"]
        self.m(hn.middle, "test5 test6 test7", hn)
        hn.last = ["test8", "test9", "test10"]
        self.m(hn.last, "test8 test9 test10", hn)
        hn.suffix = ['test']
        self.m(hn.suffix, "test", hn)

    def test_comparison_case_insensitive(self) -> None:
        # 2.0 identity semantics (#223): equivalently-parsed instances no
        # longer compare ==; matches() carries the case-insensitive
        # component comparison instead
        hn1 = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
        hn2 = HumanName("dr. john p. doe-Ray, CLU, CFP, LUTC")
        self.assertFalse(hn1 == hn2)
        self.assertIsNot(hn1, hn2)
        self.assertFalse(hn1 == "Dr. John P. Doe-ray clu, CFP, LUTC")
        self.assertTrue(hn1.matches(hn2))
        self.assertTrue(hn1.matches("Dr. John P. Doe-ray clu, CFP, LUTC"))

    def test_hash_is_identity_based(self) -> None:
        # 2.0 identity semantics (#223): hash reverted to the object default,
        # consistent with identity ==; equal-parsing instances stay distinct
        # in sets/dicts. comparison_key() is the dedup replacement.
        hn1 = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
        hn2 = HumanName("dr. john p. doe-Ray, CLU, CFP, LUTC")
        self.assertEqual(hash(hn1), object.__hash__(hn1))
        self.assertEqual(len({hn1, hn2}), 2)
        # strings no longer interoperate with HumanName in sets/dicts
        hn = HumanName("John Smith")
        self.assertNotEqual(hash(hn), hash("john smith"))
        self.assertNotIn("john smith", {hn})
        self.assertEqual(hn1.comparison_key(), hn2.comparison_key())

    def test_not_equal_operator(self) -> None:
        # != routes through the 2.0 identity __eq__ (#223): any two distinct
        # instances are unequal, however similar their parse
        self.assertTrue(HumanName("John Smith") != HumanName("Jane Smith"))
        self.assertTrue(HumanName("John Smith") != HumanName("john smith"))
        hn = HumanName("John Smith")
        self.assertFalse(hn != hn)

    def test_comparison_key_components(self) -> None:
        hn = HumanName("Dr. Juan Q. Xavier de la Vega III")
        self.assertEqual(
            hn.comparison_key(),
            ('dr.', 'juan', 'q. xavier', 'de la vega', 'iii', '', ''))

    def test_comparison_key_case_insensitive_across_formats(self) -> None:
        hn1 = HumanName("Dr. Juan Q. Xavier de la Vega III")
        hn2 = HumanName("de la vega, dr. juan Q. xavier III")
        self.assertEqual(hn1.comparison_key(), hn2.comparison_key())

    def test_comparison_key_independent_of_string_format(self) -> None:
        # unlike ==, which compares str(self) and so changes meaning when
        # display config changes, the key is built from the parsed lists
        hn1 = HumanName("John Smith")
        hn2 = HumanName("John Smith", string_format="{last}")
        self.assertEqual(hn1.comparison_key(), hn2.comparison_key())

    def test_comparison_key_includes_maiden(self) -> None:
        # maiden isn't in the default string_format, so == can't see it;
        # the key includes all seven members
        hn1 = HumanName(first="Jenny", last="Baker", maiden="Johnson")
        hn2 = HumanName(first="Jenny", last="Baker")
        self.assertNotEqual(hn1.comparison_key(), hn2.comparison_key())

    def test_comparison_key_usable_for_dedup(self) -> None:
        names = [HumanName("John Smith"), HumanName("Smith, John"),
                 HumanName("JOHN SMITH"), HumanName("Jane Smith")]
        unique = {n.comparison_key(): n for n in names}
        self.assertEqual(len(unique), 2)

    def test_matches_str_is_semantic_not_textual(self) -> None:
        # any written form of the same name matches, unlike == which only
        # matches strings that render exactly like str(self)
        hn = HumanName("Dr. Juan Q. Xavier de la Vega III")
        self.assertTrue(hn.matches("de la vega, dr. juan Q. xavier III"))
        self.assertTrue(hn.matches("Dr. Juan Q. Xavier de la Vega III"))
        self.assertFalse(hn.matches("Juan de la Vega"))

    def test_matches_humanname_operand(self) -> None:
        hn = HumanName("John Smith")
        self.assertTrue(hn.matches(HumanName("JOHN SMITH")))
        self.assertFalse(hn.matches(HumanName("Jane Smith")))

    def test_matches_parses_str_with_instance_constants(self) -> None:
        # the custom title must not be a default one ('chancellor' is!), or
        # this passes without the self.C parse path ever mattering
        c = Constants()
        c.titles.add('zephyrmark')
        self.assertNotIn('zephyrmark', CONSTANTS.titles)
        hn = HumanName("Zephyrmark Jane Smith", constants=c)
        # the str operand is parsed with self.C, so the custom title is
        # recognized in the comma form; parsed with the shared CONSTANTS,
        # 'zephyrmark' would land in first/middle and the keys would differ
        self.assertTrue(hn.matches("smith, zephyrmark jane"))

    def test_matches_humanname_operand_keeps_its_own_parse(self) -> None:
        # asymmetry, pinned deliberately: a str operand is reparsed with
        # self.C, but a HumanName operand is compared as already parsed --
        # its own constants determined its components
        c = Constants()
        c.titles.add('zephyrmark')
        with_title = HumanName("Zephyrmark Jane Smith", constants=c)
        default_parse = HumanName("Zephyrmark Jane Smith")
        self.assertTrue(with_title.matches("Zephyrmark Jane Smith"))
        self.assertFalse(with_title.matches(default_parse))

    def test_empty_parses_share_a_comparison_key(self) -> None:
        # documented caveat: empty/unparsable input collapses to the
        # all-empty key, so such names match each other and collide in
        # dedup; screen with len(name) == 0 first
        self.assertTrue(HumanName("").matches(HumanName(",")))
        self.assertEqual(HumanName("()").comparison_key(),
                         HumanName("").comparison_key())

    def test_matches_non_ascii_case_insensitive(self) -> None:
        hn = HumanName("JOSÉ GARCÍA")
        self.assertTrue(hn.matches("José García"))

    def test_matches_rejects_other_types(self) -> None:
        hn = HumanName("John Smith")
        for bad in (None, 42, b"John Smith", ["John Smith"]):
            with pytest.raises(TypeError, match="str or HumanName"):
                hn.matches(bad)  # type: ignore[arg-type]

    def test_eq_and_hash_are_silent_in_2_0(self) -> None:
        # the 1.3.0/1.4 DeprecationWarnings on __eq__/__hash__ ended with the
        # 2.0 switch to identity semantics (#223): both are now warning-free
        hn1 = HumanName("John Smith")
        hn2 = HumanName("john smith")
        with warnings.catch_warnings():
            warnings.simplefilter("error")
            self.assertFalse(hn1 == hn2)
            hash(hn1)

    def test_new_comparison_api_does_not_warn(self) -> None:
        # the replacements must be adoptable before 2.0 without tripping
        # -W error test suites; matches(str) parses, so this also covers
        # the parse path
        hn = HumanName("John Smith")
        with warnings.catch_warnings():
            warnings.simplefilter("error")
            hn.comparison_key()
            hn.matches("Smith, John")
            hn.matches(HumanName("John Smith"))

    def test_unparsable_attribute_removed(self) -> None:
        # Removed in 1.3.0: the guard that reported unparsable names was
        # unreachable, so the attribute was always False after any parse.
        self.assertFalse(hasattr(HumanName("John Smith"), "unparsable"))
        self.assertFalse(hasattr(HumanName(first="John"), "unparsable"))

    def test_str_fallback_without_string_format(self) -> None:
        # string_format=None falls back to joining the non-empty attributes
        hn = HumanName("Dr. John A. Doe, Jr.")
        hn.string_format = None
        self.assertEqual(str(hn), "Dr. John A. Doe Jr.")

    def test_repr_blank_name(self) -> None:
        hn = HumanName()
        self.assertIn("first: ''", repr(hn))
        self.assertIn(hn.__class__.__name__, repr(hn))

    def test_slice_removed(self) -> None:
        # slice access was removed in 2.0 (#258, warned since 1.4); iteration
        # and string-key access are the remaining spellings
        hn = HumanName("Doe-Ray, Dr. John P., CLU, CFP, LUTC")
        self.m(list(hn), ['Dr.', 'John', 'P.', 'Doe-Ray', 'CLU, CFP, LUTC'], hn)
        with pytest.raises(TypeError, match="258"):
            hn[1:]  # type: ignore[index]
        with pytest.raises(TypeError, match="258"):
            hn[1:-3]  # type: ignore[index]
        # string-key access is unaffected and stays silent
        with warnings.catch_warnings():
            warnings.simplefilter("error")
            hn['first']

    def test_getitem(self) -> None:
        hn = HumanName("Dr. John A. Kenneth Doe, Jr.")
        self.m(hn['title'], "Dr.", hn)
        self.m(hn['first'], "John", hn)
        self.m(hn['last'], "Doe", hn)
        self.m(hn['middle'], "A. Kenneth", hn)
        self.m(hn['suffix'], "Jr.", hn)

    def test_setitem_removed(self) -> None:
        # __setitem__ was removed in 2.0 (#258, warned since 1.4): item
        # assignment raises TypeError for every key, valid or not; plain
        # attribute assignment is the replacement
        hn = HumanName("Dr. John A. Kenneth Doe, Jr.")
        with pytest.raises(TypeError, match="item assignment"):
            hn['title'] = 'test'  # type: ignore[index]
        with pytest.raises(TypeError, match="item assignment"):
            hn['bogus'] = 'value'  # type: ignore[index]
        hn.first = 'Jane'  # the replacement spelling
        self.m(hn.first, "Jane", hn)

    def test_conjunction_names(self) -> None:
        hn = HumanName("johnny y")
        self.m(hn.first, "johnny", hn)
        self.m(hn.last, "y", hn)

    def test_prefix_names(self) -> None:
        hn = HumanName("vai la")
        self.m(hn.first, "vai", hn)
        self.m(hn.last, "la", hn)

    def test_degenerate_comma_input_leaves_no_empty_pieces(self) -> None:
        # Regression: HumanName(',') (no-comma path after whitespace collapse)
        # and HumanName('Doe,, Jr.') (lastname-comma path) appended '' to
        # first_list — a silent empty member in the public *_list attributes.
        hn = HumanName(",")
        self.assertEqual(hn.first_list, [])
        self.assertEqual(hn.middle_list, [])
        self.assertEqual(hn.last_list, [])
        self.assertEqual(len(hn), 0)
        hn = HumanName("Doe,, Jr.")
        self.assertEqual(hn.first_list, [])
        self.m(hn.last, "Doe", hn)
        self.m(hn.suffix, "Jr.", hn)
        # empty parts[0] exercises the lastname_pieces call site: the empty
        # last-name segment must not become a member of last_list
        hn = HumanName(", John")
        self.assertEqual(hn.last_list, [])
        self.m(hn.first, "John", hn)

    def test_assignment_filters_empty_tokens(self) -> None:
        # parse_pieces() drops tokens that strip to nothing at every entry
        # point, including the setters: whitespace-only strings and empty
        # list members never become *_list members (they previously survived,
        # e.g. hn.first = '  ' left first == '  ' and middle 'a  b' gained an
        # empty member from ['a', '', 'b']).
        hn = HumanName("John Doe")
        hn.first = "  "
        self.assertEqual(hn.first_list, [])
        self.m(hn.first, "", hn)
        hn.middle = ["a", "", "b"]
        self.assertEqual(hn.middle_list, ["a", "b"])
        self.m(hn.middle, "a b", hn)
        hn.last = ["", "Smith"]
        self.assertEqual(hn.last_list, ["Smith"])

    def test_blank_name(self) -> None:
        hn = HumanName()
        self.m(hn.first, "", hn)
        self.m(hn.last, "", hn)

    def test_surnames_list_attribute(self) -> None:
        hn = HumanName("John Edgar Casey Williams III")
        self.m(hn.surnames_list, ["Edgar", "Casey", "Williams"], hn)

    def test_surnames_attribute(self) -> None:
        hn = HumanName("John Edgar Casey Williams III")
        self.m(hn.surnames, "Edgar Casey Williams", hn)

    def test_given_names_list_attribute(self) -> None:
        hn = HumanName("John Edgar Casey Williams III")
        self.m(hn.given_names_list, ["John", "Edgar", "Casey"], hn)

    def test_given_names_attribute(self) -> None:
        hn = HumanName("John Edgar Casey Williams III")
        self.m(hn.given_names, "John Edgar Casey", hn)

    def test_given_names_attribute_first_only(self) -> None:
        hn = HumanName("John Williams")
        self.m(hn.given_names_list, ["John"], hn)
        self.m(hn.given_names, "John", hn)

    def test_given_names_attribute_empty(self) -> None:
        # empty attributes are always '' in 2.0 (#255)
        hn = HumanName("Dr. Williams")
        self.m(hn.given_names, "", hn)

    def test_override_constants(self) -> None:
        C = Constants()
        hn = HumanName(constants=C)
        self.assertIs(hn.C, C)

    def test_override_regex_raises(self) -> None:
        # Custom regexes are not supported in 2.0 (deliberate divergence,
        # shim's uniform read-only rule): the constructor kwarg raises the
        # same TypeError as attribute assignment, pointing at named Policy
        # flags. Reads of the built-in patterns stay available.
        var = TupleManager([("spaces", re.compile(r"\s+")),])
        with pytest.raises(TypeError, match="Policy"):
            Constants(regexes=var)  # type: ignore[call-arg]

    def test_override_titles(self) -> None:
        var = ["abc","def"]
        C = Constants(titles=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.titles) == sorted(var))

    def test_override_first_name_titles(self) -> None:
        var = ["abc","def"]
        C = Constants(first_name_titles=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.first_name_titles) == sorted(var))

    def test_override_prefixes(self) -> None:
        var = ["abc","def"]
        C = Constants(prefixes=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.prefixes) == sorted(var))

    def test_override_suffix_acronyms(self) -> None:
        var = ["abc","def"]
        C = Constants(suffix_acronyms=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.suffix_acronyms) == sorted(var))

    def test_override_suffix_not_acronyms(self) -> None:
        var = ["abc","def"]
        C = Constants(suffix_not_acronyms=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.suffix_not_acronyms) == sorted(var))

    def test_override_conjunctions(self) -> None:
        var = ["abc","def"]
        C = Constants(conjunctions=var)
        hn = HumanName(constants=C)
        self.assertTrue(sorted(hn.C.conjunctions) == sorted(var))

    def test_override_capitalization_exceptions(self) -> None:
        var = TupleManager([("abc", "ABC")])
        C = Constants(capitalization_exceptions=var)
        hn = HumanName(constants=C)
        self.assertTrue(hn.C.capitalization_exceptions == var)