fonttools/Tests/ttLib/tables/_n_a_m_e_test.py

from fontTools.misc import sstruct
from fontTools.misc.loggingTools import CapturingLogHandler
from fontTools.misc.testTools import FakeFont
from fontTools.misc.textTools import bytesjoin, tostr, Tag
from fontTools.misc.xmlWriter import XMLWriter
from io import BytesIO
import struct
import unittest
from fontTools.ttLib import TTFont, newTable
from fontTools.ttLib.tables._n_a_m_e import (
    table__n_a_m_e,
    NameRecord,
    nameRecordFormat,
    nameRecordSize,
    makeName,
    log,
)


def names(nameTable):
    result = [
        (n.nameID, n.platformID, n.platEncID, n.langID, n.string)
        for n in nameTable.names
    ]
    result.sort()
    return result


class NameTableTest(unittest.TestCase):
    def test_init(self):
        table = table__n_a_m_e()
        self.assertEqual(table.names, [])
        self.assertTrue(type(table.tableTag) is Tag)

    def test_getDebugName(self):
        table = table__n_a_m_e()
        table.names = [
            makeName("Bold", 258, 1, 0, 0),  # Mac, MacRoman, English
            makeName("Gras", 258, 1, 0, 1),  # Mac, MacRoman, French
            makeName("Fett", 258, 1, 0, 2),  # Mac, MacRoman, German
            makeName("Sem Fracções", 292, 1, 0, 8),  # Mac, MacRoman, Portuguese
        ]
        self.assertEqual("Bold", table.getDebugName(258))
        self.assertEqual("Sem Fracções", table.getDebugName(292))
        self.assertEqual(None, table.getDebugName(999))

    def test_setName(self):
        table = table__n_a_m_e()
        table.setName("Regular", 2, 1, 0, 0)
        table.setName("Version 1.000", 5, 3, 1, 0x409)
        table.setName("寬鬆", 276, 1, 2, 0x13)
        self.assertEqual("Regular", table.getName(2, 1, 0, 0).toUnicode())
        self.assertEqual("Version 1.000", table.getName(5, 3, 1, 0x409).toUnicode())
        self.assertEqual("寬鬆", table.getName(276, 1, 2, 0x13).toUnicode())
        self.assertTrue(len(table.names) == 3)
        table.setName("緊縮", 276, 1, 2, 0x13)
        self.assertEqual("緊縮", table.getName(276, 1, 2, 0x13).toUnicode())
        self.assertTrue(len(table.names) == 3)
        # passing bytes issues a warning
        with CapturingLogHandler(log, "WARNING") as captor:
            table.setName(b"abc", 0, 1, 0, 0)
        self.assertTrue(
            len([r for r in captor.records if "string is bytes" in r.msg]) == 1
        )
        # anything other than unicode or bytes raises an error
        with self.assertRaises(TypeError):
            table.setName(1.000, 5, 1, 0, 0)

    def test_names_sort_bytes_str(self):
        # Corner case: If a user appends a name record directly to `names`, the
        # `__lt__` method on NameRecord may run into duplicate name records where
        # one `string` is a str and the other one bytes, leading to an exception.
        table = table__n_a_m_e()
        table.names = [
            makeName("Test", 25, 3, 1, 0x409),
            makeName("Test".encode("utf-16be"), 25, 3, 1, 0x409),
        ]
        table.compile(None)

    def test_names_sort_attributes(self):
        table = table__n_a_m_e()
        # Create an actual invalid NameRecord object
        broken = makeName("Test", 25, 3, 1, 0x409)
        delattr(broken, "platformID")
        table.names = [
            makeName("Test", 25, 3, 1, 0x409),
            broken,
        ]
        # Sorting these two is impossible, expect an error to be raised
        with self.assertRaises(TypeError):
            table.names.sort()

    def test_names_sort_encoding(self):
        """
        Confirm that encoding errors in name table strings do not prevent at
        least sorting by other IDs
        """
        table = table__n_a_m_e()
        table.names = [
            makeName("Mac Unicode 寬 encodes ok", 25, 3, 0, 0x409),
            makeName("Win Latin 寬 fails to encode", 25, 1, 0, 0),
        ]
        table.names.sort()
        # Encoding errors or not, sort based on other IDs nonetheless
        self.assertEqual(table.names[0].platformID, 1)
        self.assertEqual(table.names[1].platformID, 3)

    def test_addName(self):
        table = table__n_a_m_e()
        nameIDs = []
        for string in ("Width", "Weight", "Custom"):
            nameIDs.append(table.addName(string))

        self.assertEqual(nameIDs[0], 256)
        self.assertEqual(nameIDs[1], 257)
        self.assertEqual(nameIDs[2], 258)
        self.assertEqual(len(table.names), 6)
        self.assertEqual(table.names[0].string, "Width")
        self.assertEqual(table.names[1].string, "Width")
        self.assertEqual(table.names[2].string, "Weight")
        self.assertEqual(table.names[3].string, "Weight")
        self.assertEqual(table.names[4].string, "Custom")
        self.assertEqual(table.names[5].string, "Custom")

        with self.assertRaises(ValueError):
            table.addName("Invalid nameID", minNameID=32767)
        with self.assertRaises(TypeError):
            table.addName(b"abc")  # must be unicode string

    def test_removeNames(self):
        table = table__n_a_m_e()
        table.setName("Regular", 2, 1, 0, 0)
        table.setName("Regular", 2, 3, 1, 0x409)
        table.removeNames(nameID=2)
        self.assertEqual(table.names, [])

        table = table__n_a_m_e()
        table.setName("FamilyName", 1, 1, 0, 0)
        table.setName("Regular", 2, 1, 0, 0)
        table.setName("FamilyName", 1, 3, 1, 0x409)
        table.setName("Regular", 2, 3, 1, 0x409)
        table.removeNames(platformID=1)
        self.assertEqual(len(table.names), 2)
        self.assertIsNone(table.getName(1, 1, 0, 0))
        self.assertIsNone(table.getName(2, 1, 0, 0))
        rec1 = table.getName(1, 3, 1, 0x409)
        self.assertEqual(str(rec1), "FamilyName")
        rec2 = table.getName(2, 3, 1, 0x409)
        self.assertEqual(str(rec2), "Regular")

        table = table__n_a_m_e()
        table.setName("FamilyName", 1, 1, 0, 0)
        table.setName("Regular", 2, 1, 0, 0)
        table.removeNames(nameID=1)
        self.assertEqual(len(table.names), 1)
        self.assertIsNone(table.getName(1, 1, 0, 0))
        rec = table.getName(2, 1, 0, 0)
        self.assertEqual(str(rec), "Regular")

        table = table__n_a_m_e()
        table.setName("FamilyName", 1, 1, 0, 0)
        table.setName("Regular", 2, 1, 0, 0)
        table.removeNames(2, 1, 0, 0)
        self.assertEqual(len(table.names), 1)
        self.assertIsNone(table.getName(2, 1, 0, 0))
        rec = table.getName(1, 1, 0, 0)
        self.assertEqual(str(rec), "FamilyName")

        table = table__n_a_m_e()
        table.setName("FamilyName", 1, 1, 0, 0)
        table.setName("Regular", 2, 1, 0, 0)
        table.removeNames()
        self.assertEqual(len(table.names), 2)
        rec1 = table.getName(1, 1, 0, 0)
        self.assertEqual(str(rec1), "FamilyName")
        rec2 = table.getName(2, 1, 0, 0)
        self.assertEqual(str(rec2), "Regular")

    @staticmethod
    def _get_test_names():
        names = {
            "en": "Width",
            "de-CH": "Breite",
            "gsw-LI": "Bräiti",
        }
        namesSubSet = names.copy()
        del namesSubSet["gsw-LI"]
        namesSuperSet = names.copy()
        namesSuperSet["nl"] = "Breedte"
        return names, namesSubSet, namesSuperSet

    def test_findMultilingualName(self):
        table = table__n_a_m_e()
        names, namesSubSet, namesSuperSet = self._get_test_names()
        nameID = table.addMultilingualName(names)
        assert nameID is not None
        self.assertEqual(nameID, table.findMultilingualName(names))
        self.assertEqual(nameID, table.findMultilingualName(namesSubSet))
        self.assertEqual(None, table.findMultilingualName(namesSuperSet))

    def test_findMultilingualName_compiled(self):
        table = table__n_a_m_e()
        names, namesSubSet, namesSuperSet = self._get_test_names()
        nameID = table.addMultilingualName(names)
        assert nameID is not None
        # After compile/decompile, name.string is a bytes sequence, which
        # findMultilingualName() should also handle
        data = table.compile(None)
        table = table__n_a_m_e()
        table.decompile(data, None)
        self.assertEqual(nameID, table.findMultilingualName(names))
        self.assertEqual(nameID, table.findMultilingualName(namesSubSet))
        self.assertEqual(None, table.findMultilingualName(namesSuperSet))

    def test_addMultilingualNameReuse(self):
        table = table__n_a_m_e()
        names, namesSubSet, namesSuperSet = self._get_test_names()
        nameID = table.addMultilingualName(names)
        assert nameID is not None
        self.assertEqual(nameID, table.addMultilingualName(names))
        self.assertEqual(nameID, table.addMultilingualName(namesSubSet))
        self.assertNotEqual(None, table.addMultilingualName(namesSuperSet))

    def test_findMultilingualNameNoMac(self):
        table = table__n_a_m_e()
        names, namesSubSet, namesSuperSet = self._get_test_names()
        nameID = table.addMultilingualName(names, mac=False)
        assert nameID is not None
        self.assertEqual(nameID, table.findMultilingualName(names, mac=False))
        self.assertEqual(None, table.findMultilingualName(names))
        self.assertEqual(nameID, table.findMultilingualName(namesSubSet, mac=False))
        self.assertEqual(None, table.findMultilingualName(namesSubSet))
        self.assertEqual(None, table.findMultilingualName(namesSuperSet))

    def test_addMultilingualName(self):
        # Microsoft Windows has language codes for “English” (en)
        # and for “Standard German as used in Switzerland” (de-CH).
        # In this case, we expect that the implementation just
        # encodes the name for the Windows platform; Apple platforms
        # have been able to decode Windows names since the early days
        # of OSX (~2001). However, Windows has no language code for
        # “Swiss German as used in Liechtenstein” (gsw-LI), so we
        # expect that the implementation populates the 'ltag' table
        # to represent that particular, rather exotic BCP47 code.
        font = FakeFont(glyphs=[".notdef", "A"])
        nameTable = font.tables["name"] = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            widthID = nameTable.addMultilingualName(
                {
                    "en": "Width",
                    "de-CH": "Breite",
                    "gsw-LI": "Bräiti",
                },
                ttFont=font,
                mac=False,
            )
            self.assertEqual(widthID, 256)
            xHeightID = nameTable.addMultilingualName(
                {"en": "X-Height", "gsw-LI": "X-Hööchi"}, ttFont=font, mac=False
            )
            self.assertEqual(xHeightID, 257)
        captor.assertRegex("cannot add Windows name in language gsw-LI")
        self.assertEqual(
            names(nameTable),
            [
                (256, 0, 4, 0, "Bräiti"),
                (256, 3, 1, 0x0409, "Width"),
                (256, 3, 1, 0x0807, "Breite"),
                (257, 0, 4, 0, "X-Hööchi"),
                (257, 3, 1, 0x0409, "X-Height"),
            ],
        )
        self.assertEqual(set(font.tables.keys()), {"ltag", "name"})
        self.assertEqual(font["ltag"].tags, ["gsw-LI"])

    def test_addMultilingualName_legacyMacEncoding(self):
        # Windows has no language code for Latin; MacOS has a code;
        # and we actually can convert the name to the legacy MacRoman
        # encoding. In this case, we expect that the name gets encoded
        # as Macintosh name (platformID 1) with the corresponding Mac
        # language code (133); the 'ltag' table should not be used.
        font = FakeFont(glyphs=[".notdef", "A"])
        nameTable = font.tables["name"] = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            nameTable.addMultilingualName({"la": "SPQR"}, ttFont=font)
        captor.assertRegex("cannot add Windows name in language la")
        self.assertEqual(names(nameTable), [(256, 1, 0, 131, "SPQR")])
        self.assertNotIn("ltag", font.tables.keys())

    def test_addMultilingualName_legacyMacEncodingButUnencodableName(self):
        # Windows has no language code for Latin; MacOS has a code;
        # but we cannot encode the name into this encoding because
        # it contains characters that are not representable.
        # In this case, we expect that the name gets encoded as
        # Unicode name (platformID 0) with the language tag being
        # added to the 'ltag' table.
        font = FakeFont(glyphs=[".notdef", "A"])
        nameTable = font.tables["name"] = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            nameTable.addMultilingualName({"la": "ⱾƤℚⱤ"}, ttFont=font)
        captor.assertRegex("cannot add Windows name in language la")
        self.assertEqual(names(nameTable), [(256, 0, 4, 0, "ⱾƤℚⱤ")])
        self.assertIn("ltag", font.tables)
        self.assertEqual(font["ltag"].tags, ["la"])

    def test_addMultilingualName_legacyMacEncodingButNoCodec(self):
        # Windows has no language code for “Azeri written in the
        # Arabic script” (az-Arab); MacOS would have a code (50);
        # but we cannot encode the name into the legacy encoding
        # because we have no codec for MacArabic in fonttools.
        # In this case, we expect that the name gets encoded as
        # Unicode name (platformID 0) with the language tag being
        # added to the 'ltag' table.
        font = FakeFont(glyphs=[".notdef", "A"])
        nameTable = font.tables["name"] = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            nameTable.addMultilingualName({"az-Arab": "آذربايجان ديلی"}, ttFont=font)
        captor.assertRegex("cannot add Windows name in language az-Arab")
        self.assertEqual(names(nameTable), [(256, 0, 4, 0, "آذربايجان ديلی")])
        self.assertIn("ltag", font.tables)
        self.assertEqual(font["ltag"].tags, ["az-Arab"])

    def test_addMultilingualName_noTTFont(self):
        # If the ttFont argument is not passed, the implementation
        # should add whatever names it can, but it should not crash
        # just because it cannot build an ltag table.
        nameTable = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            nameTable.addMultilingualName({"en": "A", "la": "ⱾƤℚⱤ"})
        captor.assertRegex("cannot store language la into 'ltag' table")

    def test_addMultilingualName_TTFont(self):
        # if ttFont argument is passed, it should not WARN about not being able
        # to create ltag table.
        font = FakeFont(glyphs=[".notdef", "A"])
        nameTable = newTable("name")
        with CapturingLogHandler(log, "WARNING") as captor:
            nameTable.addMultilingualName({"en": "A", "ar": "ع"}, ttFont=font)
        self.assertFalse(captor.records)

    def test_addMultilingualName_minNameID(self):
        table = table__n_a_m_e()
        names, namesSubSet, namesSuperSet = self._get_test_names()
        nameID = table.addMultilingualName(names, nameID=2)
        self.assertEqual(nameID, 2)
        nameID = table.addMultilingualName(names)
        self.assertEqual(nameID, 2)
        nameID = table.addMultilingualName(names, minNameID=256)
        self.assertGreaterEqual(nameID, 256)
        self.assertEqual(nameID, table.findMultilingualName(names, minNameID=256))

    def test_addMultilingualName_name_inconsistencies(self):
        # Check what happens, when there are
        # inconsistencies in the name table
        table = table__n_a_m_e()
        table.setName("Weight", 270, 3, 1, 0x409)
        names = {
            "en": "Weight",
        }
        nameID = table.addMultilingualName(names, minNameID=256)
        # Because there is an inconsistency in the names,
        # addMultilingualName adds a new name ID
        self.assertEqual(271, nameID)

    def test_decompile_badOffset(self):
        # https://github.com/fonttools/fonttools/issues/525
        table = table__n_a_m_e()
        badRecord = {
            "platformID": 1,
            "platEncID": 3,
            "langID": 7,
            "nameID": 1,
            "length": 3,
            "offset": 8765,  # out of range
        }
        data = bytesjoin(
            [
                struct.pack(tostr(">HHH"), 1, 1, 6 + nameRecordSize),
                sstruct.pack(nameRecordFormat, badRecord),
            ]
        )
        table.decompile(data, ttFont=None)
        self.assertEqual(table.names, [])


class NameRecordTest(unittest.TestCase):
    def test_toUnicode_utf16be(self):
        name = makeName("Foo Bold", 111, 0, 2, 7)
        self.assertEqual("utf_16_be", name.getEncoding())
        self.assertEqual("Foo Bold", name.toUnicode())

    def test_toUnicode_macroman(self):
        name = makeName("Foo Italic", 222, 1, 0, 7)  # MacRoman
        self.assertEqual("mac_roman", name.getEncoding())
        self.assertEqual("Foo Italic", name.toUnicode())

    def test_toUnicode_macromanian(self):
        name = makeName(b"Foo Italic\xfb", 222, 1, 0, 37)  # Mac Romanian
        self.assertEqual("mac_romanian", name.getEncoding())
        self.assertEqual("Foo Italic" + chr(0x02DA), name.toUnicode())

    def test_toUnicode_UnicodeDecodeError(self):
        name = makeName(b"\1", 111, 0, 2, 7)
        self.assertEqual("utf_16_be", name.getEncoding())
        self.assertRaises(UnicodeDecodeError, name.toUnicode)

    def test_toUnicode_singleChar(self):
        # https://github.com/fonttools/fonttools/issues/1997
        name = makeName("A", 256, 3, 1, 0x409)
        self.assertEqual(name.toUnicode(), "A")

    def toXML(self, name):
        writer = XMLWriter(BytesIO())
        name.toXML(writer, ttFont=None)
        xml = writer.file.getvalue().decode("utf_8").strip()
        return xml.split(writer.newlinestr.decode("utf_8"))[1:]

    def test_toXML_utf16be(self):
        name = makeName("Foo Bold", 111, 0, 2, 7)
        self.assertEqual(
            [
                '<namerecord nameID="111" platformID="0" platEncID="2" langID="0x7">',
                "  Foo Bold",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_utf16be_odd_length1(self):
        name = makeName(b"\0F\0o\0o\0", 111, 0, 2, 7)
        self.assertEqual(
            [
                '<namerecord nameID="111" platformID="0" platEncID="2" langID="0x7">',
                "  Foo",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_utf16be_odd_length2(self):
        name = makeName(b"\0Fooz", 111, 0, 2, 7)
        self.assertEqual(
            [
                '<namerecord nameID="111" platformID="0" platEncID="2" langID="0x7">',
                "  Fooz",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_utf16be_double_encoded(self):
        name = makeName(b"\0\0\0F\0\0\0o", 111, 0, 2, 7)
        self.assertEqual(
            [
                '<namerecord nameID="111" platformID="0" platEncID="2" langID="0x7">',
                "  Fo",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_macroman(self):
        name = makeName("Foo Italic", 222, 1, 0, 7)  # MacRoman
        self.assertEqual(
            [
                '<namerecord nameID="222" platformID="1" platEncID="0" langID="0x7" unicode="True">',
                "  Foo Italic",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_macroman_actual_utf16be(self):
        name = makeName("\0F\0o\0o", 222, 1, 0, 7)
        self.assertEqual(
            [
                '<namerecord nameID="222" platformID="1" platEncID="0" langID="0x7" unicode="True">',
                "  Foo",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_unknownPlatEncID_nonASCII(self):
        name = makeName(b"B\x8arli", 333, 1, 9876, 7)  # Unknown Mac encodingID
        self.assertEqual(
            [
                '<namerecord nameID="333" platformID="1" platEncID="9876" langID="0x7" unicode="False">',
                "  B&#138;rli",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_toXML_unknownPlatEncID_ASCII(self):
        name = makeName(b"Barli", 333, 1, 9876, 7)  # Unknown Mac encodingID
        self.assertEqual(
            [
                '<namerecord nameID="333" platformID="1" platEncID="9876" langID="0x7" unicode="True">',
                "  Barli",
                "</namerecord>",
            ],
            self.toXML(name),
        )

    def test_encoding_macroman_misc(self):
        name = makeName("", 123, 1, 0, 17)  # Mac Turkish
        self.assertEqual(name.getEncoding(), "mac_turkish")
        name.langID = 37
        self.assertEqual(name.getEncoding(), "mac_romanian")
        name.langID = 45  # Other
        self.assertEqual(name.getEncoding(), "mac_roman")

    def test_extended_mac_encodings(self):
        name = makeName(b"\xfe", 123, 1, 1, 0)  # Mac Japanese
        self.assertEqual(name.toUnicode(), chr(0x2122))

    def test_extended_mac_encodings_errors(self):
        s = "汉仪彩云体简"
        name = makeName(s.encode("x_mac_simp_chinese_ttx"), 123, 1, 25, 0)
        # first check we round-trip with 'strict'
        self.assertEqual(name.toUnicode(errors="strict"), s)

        # append an incomplete invalid sequence and check that we handle
        # errors with the requested error handler
        name.string += b"\xba"
        self.assertEqual(name.toUnicode(errors="backslashreplace"), s + "\\xba")
        self.assertEqual(name.toUnicode(errors="replace"), s + "<EFBFBD>")

    def test_extended_unknown(self):
        name = makeName(b"\xfe", 123, 10, 11, 12)
        self.assertEqual(name.getEncoding(), "ascii")
        self.assertEqual(name.getEncoding(None), None)
        self.assertEqual(name.getEncoding(default=None), None)

    def test_get_family_name(self):
        name = table__n_a_m_e()
        name.names = [
            makeName("Copyright", 0, 1, 0, 0),
            makeName("Family Name ID 1", 1, 1, 0, 0),
            makeName("SubFamily Name ID 2", 2, 1, 0, 0),
            makeName("Unique Name ID 3", 3, 1, 0, 0),
            makeName("Full Name ID 4", 4, 1, 0, 0),
            makeName("PS Name ID 6", 6, 1, 0, 0),
            makeName("Version Name ID 5", 5, 1, 0, 0),
            makeName("Trademark Name ID 7", 7, 1, 0, 0),
        ]

        result_value = name.getBestFamilyName()
        self.assertEqual("Family Name ID 1", result_value)

        expected_value = "Family Name ID 16"
        name.setName(expected_value, 16, 1, 0, 0)
        result_value = name.getBestFamilyName()
        self.assertEqual(expected_value, result_value)

        expected_value = "Family Name ID 21"
        name.setName(expected_value, 21, 1, 0, 0)
        result_value = name.getBestFamilyName()
        self.assertEqual(expected_value, result_value)

    def test_get_subfamily_name(self):
        name = table__n_a_m_e()
        name.names = [
            makeName("Copyright", 0, 1, 0, 0),
            makeName("Family Name ID 1", 1, 1, 0, 0),
            makeName("SubFamily Name ID 2", 2, 1, 0, 0),
            makeName("Unique Name ID 3", 3, 1, 0, 0),
            makeName("Full Name ID 4", 4, 1, 0, 0),
            makeName("PS Name ID 6", 6, 1, 0, 0),
            makeName("Version Name ID 5", 5, 1, 0, 0),
            makeName("Trademark Name ID 7", 7, 1, 0, 0),
        ]

        result_value = name.getBestSubFamilyName()
        self.assertEqual("SubFamily Name ID 2", result_value)

        expected_value = "Family Name ID 17"
        name.setName(expected_value, 17, 1, 0, 0)
        result_value = name.getBestSubFamilyName()
        self.assertEqual(expected_value, result_value)

        expected_value = "Family Name ID 22"
        name.setName(expected_value, 22, 1, 0, 0)
        result_value = name.getBestSubFamilyName()
        self.assertEqual(expected_value, result_value)

    def test_get_nice_full_name(self):
        name = table__n_a_m_e()
        name.names = [
            makeName("NID 1", 1, 1, 0, 0),
            makeName("NID 2", 2, 1, 0, 0),
            makeName("NID 4", 4, 1, 0, 0),
            makeName("NID 6", 6, 1, 0, 0),
        ]

        result_value = name.getBestFullName()
        self.assertEqual("NID 1 NID 2", result_value)

        expected_value = "NID 1 NID 2"
        # expection is still NID 1 NID 2,
        # because name ID 17 is missing
        name.setName("NID 16", 16, 1, 0, 0)
        result_value = name.getBestFullName()
        self.assertEqual(expected_value, result_value)

        name.setName("NID 17", 17, 1, 0, 0)
        result_value = name.getBestFullName()
        self.assertEqual("NID 16 NID 17", result_value)

        expected_value = "NID 16 NID 17"
        # expection is still NID 16 NID 17,
        # because name ID 21 is missing
        name.setName("NID 21", 21, 1, 0, 0)
        result_value = name.getBestFullName()
        self.assertEqual(expected_value, result_value)

        name.setName("NID 22", 22, 1, 0, 0)
        result_value = name.getBestFullName()
        self.assertEqual("NID 21 NID 22", result_value)

        for NID in [2, 16, 17, 21, 22]:
            name.removeNames(NID)

        result_value = name.getBestFullName()
        self.assertEqual("NID 4", result_value)

        name.setName("Regular", 2, 1, 0, 0)
        result_value = name.getBestFullName()
        self.assertEqual("NID 1", result_value)


if __name__ == "__main__":
    import sys

    sys.exit(unittest.main())