xref: /aosp_15_r20/external/fonttools/Tests/otlLib/builder_test.py (revision e1fe3e4ad2793916b15cccdc4a7da52a7e1dd0e9)

import io
import struct
from fontTools.misc.fixedTools import floatToFixed, fixedToFloat
from fontTools.misc.testTools import getXML
from fontTools.otlLib import builder, error
from fontTools import ttLib
from fontTools.ttLib.tables import otTables
import pytest


class BuilderTest(object):
    GLYPHS = (
        ".notdef space zero one two three four five six "
        "A B C a b c grave acute cedilla f_f_i f_i c_t"
    ).split()
    GLYPHMAP = {name: num for num, name in enumerate(GLYPHS)}

    ANCHOR1 = builder.buildAnchor(11, -11)
    ANCHOR2 = builder.buildAnchor(22, -22)
    ANCHOR3 = builder.buildAnchor(33, -33)

    def test_buildAnchor_format1(self):
        anchor = builder.buildAnchor(23, 42)
        assert getXML(anchor.toXML) == [
            '<Anchor Format="1">',
            '  <XCoordinate value="23"/>',
            '  <YCoordinate value="42"/>',
            "</Anchor>",
        ]

    def test_buildAnchor_format2(self):
        anchor = builder.buildAnchor(23, 42, point=17)
        assert getXML(anchor.toXML) == [
            '<Anchor Format="2">',
            '  <XCoordinate value="23"/>',
            '  <YCoordinate value="42"/>',
            '  <AnchorPoint value="17"/>',
            "</Anchor>",
        ]

    def test_buildAnchor_format3(self):
        anchor = builder.buildAnchor(
            23,
            42,
            deviceX=builder.buildDevice({1: 1, 0: 0}),
            deviceY=builder.buildDevice({7: 7}),
        )
        assert getXML(anchor.toXML) == [
            '<Anchor Format="3">',
            '  <XCoordinate value="23"/>',
            '  <YCoordinate value="42"/>',
            "  <XDeviceTable>",
            '    <StartSize value="0"/>',
            '    <EndSize value="1"/>',
            '    <DeltaFormat value="1"/>',
            '    <DeltaValue value="[0, 1]"/>',
            "  </XDeviceTable>",
            "  <YDeviceTable>",
            '    <StartSize value="7"/>',
            '    <EndSize value="7"/>',
            '    <DeltaFormat value="2"/>',
            '    <DeltaValue value="[7]"/>',
            "  </YDeviceTable>",
            "</Anchor>",
        ]

    def test_buildAttachList(self):
        attachList = builder.buildAttachList(
            {"zero": [23, 7], "one": [1]}, self.GLYPHMAP
        )
        assert getXML(attachList.toXML) == [
            "<AttachList>",
            "  <Coverage>",
            '    <Glyph value="zero"/>',
            '    <Glyph value="one"/>',
            "  </Coverage>",
            "  <!-- GlyphCount=2 -->",
            '  <AttachPoint index="0">',
            "    <!-- PointCount=2 -->",
            '    <PointIndex index="0" value="7"/>',
            '    <PointIndex index="1" value="23"/>',
            "  </AttachPoint>",
            '  <AttachPoint index="1">',
            "    <!-- PointCount=1 -->",
            '    <PointIndex index="0" value="1"/>',
            "  </AttachPoint>",
            "</AttachList>",
        ]

    def test_buildAttachList_empty(self):
        assert builder.buildAttachList({}, self.GLYPHMAP) is None

    def test_buildAttachPoint(self):
        attachPoint = builder.buildAttachPoint([7, 3])
        assert getXML(attachPoint.toXML) == [
            "<AttachPoint>",
            "  <!-- PointCount=2 -->",
            '  <PointIndex index="0" value="3"/>',
            '  <PointIndex index="1" value="7"/>',
            "</AttachPoint>",
        ]

    def test_buildAttachPoint_empty(self):
        assert builder.buildAttachPoint([]) is None

    def test_buildAttachPoint_duplicate(self):
        attachPoint = builder.buildAttachPoint([7, 3, 7])
        assert getXML(attachPoint.toXML) == [
            "<AttachPoint>",
            "  <!-- PointCount=2 -->",
            '  <PointIndex index="0" value="3"/>',
            '  <PointIndex index="1" value="7"/>',
            "</AttachPoint>",
        ]

    def test_buildBaseArray(self):
        anchor = builder.buildAnchor
        baseArray = builder.buildBaseArray(
            {"a": {2: anchor(300, 80)}, "c": {1: anchor(300, 80), 2: anchor(300, -20)}},
            numMarkClasses=4,
            glyphMap=self.GLYPHMAP,
        )
        assert getXML(baseArray.toXML) == [
            "<BaseArray>",
            "  <!-- BaseCount=2 -->",
            '  <BaseRecord index="0">',
            '    <BaseAnchor index="0" empty="1"/>',
            '    <BaseAnchor index="1" empty="1"/>',
            '    <BaseAnchor index="2" Format="1">',
            '      <XCoordinate value="300"/>',
            '      <YCoordinate value="80"/>',
            "    </BaseAnchor>",
            '    <BaseAnchor index="3" empty="1"/>',
            "  </BaseRecord>",
            '  <BaseRecord index="1">',
            '    <BaseAnchor index="0" empty="1"/>',
            '    <BaseAnchor index="1" Format="1">',
            '      <XCoordinate value="300"/>',
            '      <YCoordinate value="80"/>',
            "    </BaseAnchor>",
            '    <BaseAnchor index="2" Format="1">',
            '      <XCoordinate value="300"/>',
            '      <YCoordinate value="-20"/>',
            "    </BaseAnchor>",
            '    <BaseAnchor index="3" empty="1"/>',
            "  </BaseRecord>",
            "</BaseArray>",
        ]

    def test_buildBaseRecord(self):
        a = builder.buildAnchor
        rec = builder.buildBaseRecord([a(500, -20), None, a(300, -15)])
        assert getXML(rec.toXML) == [
            "<BaseRecord>",
            '  <BaseAnchor index="0" Format="1">',
            '    <XCoordinate value="500"/>',
            '    <YCoordinate value="-20"/>',
            "  </BaseAnchor>",
            '  <BaseAnchor index="1" empty="1"/>',
            '  <BaseAnchor index="2" Format="1">',
            '    <XCoordinate value="300"/>',
            '    <YCoordinate value="-15"/>',
            "  </BaseAnchor>",
            "</BaseRecord>",
        ]

    def test_buildCaretValueForCoord(self):
        caret = builder.buildCaretValueForCoord(500)
        assert getXML(caret.toXML) == [
            '<CaretValue Format="1">',
            '  <Coordinate value="500"/>',
            "</CaretValue>",
        ]

    def test_buildCaretValueForPoint(self):
        caret = builder.buildCaretValueForPoint(23)
        assert getXML(caret.toXML) == [
            '<CaretValue Format="2">',
            '  <CaretValuePoint value="23"/>',
            "</CaretValue>",
        ]

    def test_buildComponentRecord(self):
        a = builder.buildAnchor
        rec = builder.buildComponentRecord([a(500, -20), None, a(300, -15)])
        assert getXML(rec.toXML) == [
            "<ComponentRecord>",
            '  <LigatureAnchor index="0" Format="1">',
            '    <XCoordinate value="500"/>',
            '    <YCoordinate value="-20"/>',
            "  </LigatureAnchor>",
            '  <LigatureAnchor index="1" empty="1"/>',
            '  <LigatureAnchor index="2" Format="1">',
            '    <XCoordinate value="300"/>',
            '    <YCoordinate value="-15"/>',
            "  </LigatureAnchor>",
            "</ComponentRecord>",
        ]

    def test_buildComponentRecord_empty(self):
        assert builder.buildComponentRecord([]) is None

    def test_buildComponentRecord_None(self):
        assert builder.buildComponentRecord(None) is None

    def test_buildCoverage(self):
        cov = builder.buildCoverage(("two", "four", "two"), {"two": 2, "four": 4})
        assert getXML(cov.toXML) == [
            "<Coverage>",
            '  <Glyph value="two"/>',
            '  <Glyph value="four"/>',
            "</Coverage>",
        ]

    def test_buildCursivePos(self):
        pos = builder.buildCursivePosSubtable(
            {"two": (self.ANCHOR1, self.ANCHOR2), "four": (self.ANCHOR3, self.ANCHOR1)},
            self.GLYPHMAP,
        )
        assert getXML(pos.toXML) == [
            '<CursivePos Format="1">',
            "  <Coverage>",
            '    <Glyph value="two"/>',
            '    <Glyph value="four"/>',
            "  </Coverage>",
            "  <!-- EntryExitCount=2 -->",
            '  <EntryExitRecord index="0">',
            '    <EntryAnchor Format="1">',
            '      <XCoordinate value="11"/>',
            '      <YCoordinate value="-11"/>',
            "    </EntryAnchor>",
            '    <ExitAnchor Format="1">',
            '      <XCoordinate value="22"/>',
            '      <YCoordinate value="-22"/>',
            "    </ExitAnchor>",
            "  </EntryExitRecord>",
            '  <EntryExitRecord index="1">',
            '    <EntryAnchor Format="1">',
            '      <XCoordinate value="33"/>',
            '      <YCoordinate value="-33"/>',
            "    </EntryAnchor>",
            '    <ExitAnchor Format="1">',
            '      <XCoordinate value="11"/>',
            '      <YCoordinate value="-11"/>',
            "    </ExitAnchor>",
            "  </EntryExitRecord>",
            "</CursivePos>",
        ]

    def test_buildDevice_format1(self):
        device = builder.buildDevice({1: 1, 0: 0})
        assert getXML(device.toXML) == [
            "<Device>",
            '  <StartSize value="0"/>',
            '  <EndSize value="1"/>',
            '  <DeltaFormat value="1"/>',
            '  <DeltaValue value="[0, 1]"/>',
            "</Device>",
        ]

    def test_buildDevice_format2(self):
        device = builder.buildDevice({2: 2, 0: 1, 1: 0})
        assert getXML(device.toXML) == [
            "<Device>",
            '  <StartSize value="0"/>',
            '  <EndSize value="2"/>',
            '  <DeltaFormat value="2"/>',
            '  <DeltaValue value="[1, 0, 2]"/>',
            "</Device>",
        ]

    def test_buildDevice_format3(self):
        device = builder.buildDevice({5: 3, 1: 77})
        assert getXML(device.toXML) == [
            "<Device>",
            '  <StartSize value="1"/>',
            '  <EndSize value="5"/>',
            '  <DeltaFormat value="3"/>',
            '  <DeltaValue value="[77, 0, 0, 0, 3]"/>',
            "</Device>",
        ]

    def test_buildLigatureArray(self):
        anchor = builder.buildAnchor
        ligatureArray = builder.buildLigatureArray(
            {
                "f_i": [{2: anchor(300, -20)}, {}],
                "c_t": [{}, {1: anchor(500, 350), 2: anchor(1300, -20)}],
            },
            numMarkClasses=4,
            glyphMap=self.GLYPHMAP,
        )
        assert getXML(ligatureArray.toXML) == [
            "<LigatureArray>",
            "  <!-- LigatureCount=2 -->",
            '  <LigatureAttach index="0">',  # f_i
            "    <!-- ComponentCount=2 -->",
            '    <ComponentRecord index="0">',
            '      <LigatureAnchor index="0" empty="1"/>',
            '      <LigatureAnchor index="1" empty="1"/>',
            '      <LigatureAnchor index="2" Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="-20"/>',
            "      </LigatureAnchor>",
            '      <LigatureAnchor index="3" empty="1"/>',
            "    </ComponentRecord>",
            '    <ComponentRecord index="1">',
            '      <LigatureAnchor index="0" empty="1"/>',
            '      <LigatureAnchor index="1" empty="1"/>',
            '      <LigatureAnchor index="2" empty="1"/>',
            '      <LigatureAnchor index="3" empty="1"/>',
            "    </ComponentRecord>",
            "  </LigatureAttach>",
            '  <LigatureAttach index="1">',
            "    <!-- ComponentCount=2 -->",
            '    <ComponentRecord index="0">',
            '      <LigatureAnchor index="0" empty="1"/>',
            '      <LigatureAnchor index="1" empty="1"/>',
            '      <LigatureAnchor index="2" empty="1"/>',
            '      <LigatureAnchor index="3" empty="1"/>',
            "    </ComponentRecord>",
            '    <ComponentRecord index="1">',
            '      <LigatureAnchor index="0" empty="1"/>',
            '      <LigatureAnchor index="1" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="350"/>',
            "      </LigatureAnchor>",
            '      <LigatureAnchor index="2" Format="1">',
            '        <XCoordinate value="1300"/>',
            '        <YCoordinate value="-20"/>',
            "      </LigatureAnchor>",
            '      <LigatureAnchor index="3" empty="1"/>',
            "    </ComponentRecord>",
            "  </LigatureAttach>",
            "</LigatureArray>",
        ]

    def test_buildLigatureAttach(self):
        anchor = builder.buildAnchor
        attach = builder.buildLigatureAttach(
            [[anchor(500, -10), None], [None, anchor(300, -20), None]]
        )
        assert getXML(attach.toXML) == [
            "<LigatureAttach>",
            "  <!-- ComponentCount=2 -->",
            '  <ComponentRecord index="0">',
            '    <LigatureAnchor index="0" Format="1">',
            '      <XCoordinate value="500"/>',
            '      <YCoordinate value="-10"/>',
            "    </LigatureAnchor>",
            '    <LigatureAnchor index="1" empty="1"/>',
            "  </ComponentRecord>",
            '  <ComponentRecord index="1">',
            '    <LigatureAnchor index="0" empty="1"/>',
            '    <LigatureAnchor index="1" Format="1">',
            '      <XCoordinate value="300"/>',
            '      <YCoordinate value="-20"/>',
            "    </LigatureAnchor>",
            '    <LigatureAnchor index="2" empty="1"/>',
            "  </ComponentRecord>",
            "</LigatureAttach>",
        ]

    def test_buildLigatureAttach_emptyComponents(self):
        attach = builder.buildLigatureAttach([[], None])
        assert getXML(attach.toXML) == [
            "<LigatureAttach>",
            "  <!-- ComponentCount=2 -->",
            '  <ComponentRecord index="0" empty="1"/>',
            '  <ComponentRecord index="1" empty="1"/>',
            "</LigatureAttach>",
        ]

    def test_buildLigatureAttach_noComponents(self):
        attach = builder.buildLigatureAttach([])
        assert getXML(attach.toXML) == [
            "<LigatureAttach>",
            "  <!-- ComponentCount=0 -->",
            "</LigatureAttach>",
        ]

    def test_buildLigCaretList(self):
        carets = builder.buildLigCaretList(
            {"f_f_i": [300, 600]}, {"c_t": [42]}, self.GLYPHMAP
        )
        assert getXML(carets.toXML) == [
            "<LigCaretList>",
            "  <Coverage>",
            '    <Glyph value="f_f_i"/>',
            '    <Glyph value="c_t"/>',
            "  </Coverage>",
            "  <!-- LigGlyphCount=2 -->",
            '  <LigGlyph index="0">',
            "    <!-- CaretCount=2 -->",
            '    <CaretValue index="0" Format="1">',
            '      <Coordinate value="300"/>',
            "    </CaretValue>",
            '    <CaretValue index="1" Format="1">',
            '      <Coordinate value="600"/>',
            "    </CaretValue>",
            "  </LigGlyph>",
            '  <LigGlyph index="1">',
            "    <!-- CaretCount=1 -->",
            '    <CaretValue index="0" Format="2">',
            '      <CaretValuePoint value="42"/>',
            "    </CaretValue>",
            "  </LigGlyph>",
            "</LigCaretList>",
        ]

    def test_buildLigCaretList_bothCoordsAndPointsForSameGlyph(self):
        carets = builder.buildLigCaretList(
            {"f_f_i": [300]}, {"f_f_i": [7]}, self.GLYPHMAP
        )
        assert getXML(carets.toXML) == [
            "<LigCaretList>",
            "  <Coverage>",
            '    <Glyph value="f_f_i"/>',
            "  </Coverage>",
            "  <!-- LigGlyphCount=1 -->",
            '  <LigGlyph index="0">',
            "    <!-- CaretCount=2 -->",
            '    <CaretValue index="0" Format="1">',
            '      <Coordinate value="300"/>',
            "    </CaretValue>",
            '    <CaretValue index="1" Format="2">',
            '      <CaretValuePoint value="7"/>',
            "    </CaretValue>",
            "  </LigGlyph>",
            "</LigCaretList>",
        ]

    def test_buildLigCaretList_empty(self):
        assert builder.buildLigCaretList({}, {}, self.GLYPHMAP) is None

    def test_buildLigCaretList_None(self):
        assert builder.buildLigCaretList(None, None, self.GLYPHMAP) is None

    def test_buildLigGlyph_coords(self):
        lig = builder.buildLigGlyph([500, 800], None)
        assert getXML(lig.toXML) == [
            "<LigGlyph>",
            "  <!-- CaretCount=2 -->",
            '  <CaretValue index="0" Format="1">',
            '    <Coordinate value="500"/>',
            "  </CaretValue>",
            '  <CaretValue index="1" Format="1">',
            '    <Coordinate value="800"/>',
            "  </CaretValue>",
            "</LigGlyph>",
        ]

    def test_buildLigGlyph_empty(self):
        assert builder.buildLigGlyph([], []) is None

    def test_buildLigGlyph_None(self):
        assert builder.buildLigGlyph(None, None) is None

    def test_buildLigGlyph_points(self):
        lig = builder.buildLigGlyph(None, [2])
        assert getXML(lig.toXML) == [
            "<LigGlyph>",
            "  <!-- CaretCount=1 -->",
            '  <CaretValue index="0" Format="2">',
            '    <CaretValuePoint value="2"/>',
            "  </CaretValue>",
            "</LigGlyph>",
        ]

    def test_buildLookup(self):
        s1 = builder.buildSingleSubstSubtable({"one": "two"})
        s2 = builder.buildSingleSubstSubtable({"three": "four"})
        lookup = builder.buildLookup([s1, s2], flags=7)
        assert getXML(lookup.toXML) == [
            "<Lookup>",
            '  <LookupType value="1"/>',
            '  <LookupFlag value="7"/><!-- rightToLeft ignoreBaseGlyphs ignoreLigatures -->',
            "  <!-- SubTableCount=2 -->",
            '  <SingleSubst index="0">',
            '    <Substitution in="one" out="two"/>',
            "  </SingleSubst>",
            '  <SingleSubst index="1">',
            '    <Substitution in="three" out="four"/>',
            "  </SingleSubst>",
            "</Lookup>",
        ]

    def test_buildLookup_badFlags(self):
        s = builder.buildSingleSubstSubtable({"one": "two"})
        with pytest.raises(
            AssertionError,
            match=(
                "if markFilterSet is None, flags must not set "
                "LOOKUP_FLAG_USE_MARK_FILTERING_SET; flags=0x0010"
            ),
        ) as excinfo:
            builder.buildLookup([s], builder.LOOKUP_FLAG_USE_MARK_FILTERING_SET, None)

    def test_buildLookup_conflictingSubtableTypes(self):
        s1 = builder.buildSingleSubstSubtable({"one": "two"})
        s2 = builder.buildAlternateSubstSubtable({"one": ["two", "three"]})
        with pytest.raises(
            AssertionError, match="all subtables must have the same LookupType"
        ) as excinfo:
            builder.buildLookup([s1, s2])

    def test_buildLookup_noSubtables(self):
        assert builder.buildLookup([]) is None
        assert builder.buildLookup(None) is None
        assert builder.buildLookup([None]) is None
        assert builder.buildLookup([None, None]) is None

    def test_buildLookup_markFilterSet(self):
        s = builder.buildSingleSubstSubtable({"one": "two"})
        flags = (
            builder.LOOKUP_FLAG_RIGHT_TO_LEFT
            | builder.LOOKUP_FLAG_USE_MARK_FILTERING_SET
        )
        lookup = builder.buildLookup([s], flags, markFilterSet=999)
        assert getXML(lookup.toXML) == [
            "<Lookup>",
            '  <LookupType value="1"/>',
            '  <LookupFlag value="17"/><!-- rightToLeft useMarkFilteringSet -->',
            "  <!-- SubTableCount=1 -->",
            '  <SingleSubst index="0">',
            '    <Substitution in="one" out="two"/>',
            "  </SingleSubst>",
            '  <MarkFilteringSet value="999"/>',
            "</Lookup>",
        ]

    def test_buildMarkArray(self):
        markArray = builder.buildMarkArray(
            {
                "acute": (7, builder.buildAnchor(300, 800)),
                "grave": (2, builder.buildAnchor(10, 80)),
            },
            self.GLYPHMAP,
        )
        assert self.GLYPHMAP["grave"] < self.GLYPHMAP["acute"]
        assert getXML(markArray.toXML) == [
            "<MarkArray>",
            "  <!-- MarkCount=2 -->",
            '  <MarkRecord index="0">',
            '    <Class value="2"/>',
            '    <MarkAnchor Format="1">',
            '      <XCoordinate value="10"/>',
            '      <YCoordinate value="80"/>',
            "    </MarkAnchor>",
            "  </MarkRecord>",
            '  <MarkRecord index="1">',
            '    <Class value="7"/>',
            '    <MarkAnchor Format="1">',
            '      <XCoordinate value="300"/>',
            '      <YCoordinate value="800"/>',
            "    </MarkAnchor>",
            "  </MarkRecord>",
            "</MarkArray>",
        ]

    def test_buildMarkBasePosSubtable(self):
        anchor = builder.buildAnchor
        marks = {
            "acute": (0, anchor(300, 700)),
            "cedilla": (1, anchor(300, -100)),
            "grave": (0, anchor(300, 700)),
        }
        bases = {
            # Make sure we can handle missing entries.
            "A": {},  # no entry for any markClass
            "B": {0: anchor(500, 900)},  # only markClass 0 specified
            "C": {1: anchor(500, -10)},  # only markClass 1 specified
            "a": {0: anchor(500, 400), 1: anchor(500, -20)},
            "b": {0: anchor(500, 800), 1: anchor(500, -20)},
        }
        table = builder.buildMarkBasePosSubtable(marks, bases, self.GLYPHMAP)
        assert getXML(table.toXML) == [
            '<MarkBasePos Format="1">',
            "  <MarkCoverage>",
            '    <Glyph value="grave"/>',
            '    <Glyph value="acute"/>',
            '    <Glyph value="cedilla"/>',
            "  </MarkCoverage>",
            "  <BaseCoverage>",
            '    <Glyph value="A"/>',
            '    <Glyph value="B"/>',
            '    <Glyph value="C"/>',
            '    <Glyph value="a"/>',
            '    <Glyph value="b"/>',
            "  </BaseCoverage>",
            "  <!-- ClassCount=2 -->",
            "  <MarkArray>",
            "    <!-- MarkCount=3 -->",
            '    <MarkRecord index="0">',  # grave
            '      <Class value="0"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="700"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            '    <MarkRecord index="1">',  # acute
            '      <Class value="0"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="700"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            '    <MarkRecord index="2">',  # cedilla
            '      <Class value="1"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="-100"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            "  </MarkArray>",
            "  <BaseArray>",
            "    <!-- BaseCount=5 -->",
            '    <BaseRecord index="0">',  # A
            '      <BaseAnchor index="0" empty="1"/>',
            '      <BaseAnchor index="1" empty="1"/>',
            "    </BaseRecord>",
            '    <BaseRecord index="1">',  # B
            '      <BaseAnchor index="0" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="900"/>',
            "      </BaseAnchor>",
            '      <BaseAnchor index="1" empty="1"/>',
            "    </BaseRecord>",
            '    <BaseRecord index="2">',  # C
            '      <BaseAnchor index="0" empty="1"/>',
            '      <BaseAnchor index="1" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="-10"/>',
            "      </BaseAnchor>",
            "    </BaseRecord>",
            '    <BaseRecord index="3">',  # a
            '      <BaseAnchor index="0" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="400"/>',
            "      </BaseAnchor>",
            '      <BaseAnchor index="1" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="-20"/>',
            "      </BaseAnchor>",
            "    </BaseRecord>",
            '    <BaseRecord index="4">',  # b
            '      <BaseAnchor index="0" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="800"/>',
            "      </BaseAnchor>",
            '      <BaseAnchor index="1" Format="1">',
            '        <XCoordinate value="500"/>',
            '        <YCoordinate value="-20"/>',
            "      </BaseAnchor>",
            "    </BaseRecord>",
            "  </BaseArray>",
            "</MarkBasePos>",
        ]

    def test_buildMarkGlyphSetsDef(self):
        marksets = builder.buildMarkGlyphSetsDef(
            [{"acute", "grave"}, {"cedilla", "grave"}], self.GLYPHMAP
        )
        assert getXML(marksets.toXML) == [
            "<MarkGlyphSetsDef>",
            '  <MarkSetTableFormat value="1"/>',
            "  <!-- MarkSetCount=2 -->",
            '  <Coverage index="0">',
            '    <Glyph value="grave"/>',
            '    <Glyph value="acute"/>',
            "  </Coverage>",
            '  <Coverage index="1">',
            '    <Glyph value="grave"/>',
            '    <Glyph value="cedilla"/>',
            "  </Coverage>",
            "</MarkGlyphSetsDef>",
        ]

    def test_buildMarkGlyphSetsDef_empty(self):
        assert builder.buildMarkGlyphSetsDef([], self.GLYPHMAP) is None

    def test_buildMarkGlyphSetsDef_None(self):
        assert builder.buildMarkGlyphSetsDef(None, self.GLYPHMAP) is None

    def test_buildMarkLigPosSubtable(self):
        anchor = builder.buildAnchor
        marks = {
            "acute": (0, anchor(300, 700)),
            "cedilla": (1, anchor(300, -100)),
            "grave": (0, anchor(300, 700)),
        }
        bases = {
            "f_i": [{}, {0: anchor(200, 400)}],  # nothing on f; only 1 on i
            "c_t": [
                {0: anchor(500, 600), 1: anchor(500, -20)},  # c
                {0: anchor(1300, 800), 1: anchor(1300, -20)},  # t
            ],
        }
        table = builder.buildMarkLigPosSubtable(marks, bases, self.GLYPHMAP)
        assert getXML(table.toXML) == [
            '<MarkLigPos Format="1">',
            "  <MarkCoverage>",
            '    <Glyph value="grave"/>',
            '    <Glyph value="acute"/>',
            '    <Glyph value="cedilla"/>',
            "  </MarkCoverage>",
            "  <LigatureCoverage>",
            '    <Glyph value="f_i"/>',
            '    <Glyph value="c_t"/>',
            "  </LigatureCoverage>",
            "  <!-- ClassCount=2 -->",
            "  <MarkArray>",
            "    <!-- MarkCount=3 -->",
            '    <MarkRecord index="0">',
            '      <Class value="0"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="700"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            '    <MarkRecord index="1">',
            '      <Class value="0"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="700"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            '    <MarkRecord index="2">',
            '      <Class value="1"/>',
            '      <MarkAnchor Format="1">',
            '        <XCoordinate value="300"/>',
            '        <YCoordinate value="-100"/>',
            "      </MarkAnchor>",
            "    </MarkRecord>",
            "  </MarkArray>",
            "  <LigatureArray>",
            "    <!-- LigatureCount=2 -->",
            '    <LigatureAttach index="0">',
            "      <!-- ComponentCount=2 -->",
            '      <ComponentRecord index="0">',
            '        <LigatureAnchor index="0" empty="1"/>',
            '        <LigatureAnchor index="1" empty="1"/>',
            "      </ComponentRecord>",
            '      <ComponentRecord index="1">',
            '        <LigatureAnchor index="0" Format="1">',
            '          <XCoordinate value="200"/>',
            '          <YCoordinate value="400"/>',
            "        </LigatureAnchor>",
            '        <LigatureAnchor index="1" empty="1"/>',
            "      </ComponentRecord>",
            "    </LigatureAttach>",
            '    <LigatureAttach index="1">',
            "      <!-- ComponentCount=2 -->",
            '      <ComponentRecord index="0">',
            '        <LigatureAnchor index="0" Format="1">',
            '          <XCoordinate value="500"/>',
            '          <YCoordinate value="600"/>',
            "        </LigatureAnchor>",
            '        <LigatureAnchor index="1" Format="1">',
            '          <XCoordinate value="500"/>',
            '          <YCoordinate value="-20"/>',
            "        </LigatureAnchor>",
            "      </ComponentRecord>",
            '      <ComponentRecord index="1">',
            '        <LigatureAnchor index="0" Format="1">',
            '          <XCoordinate value="1300"/>',
            '          <YCoordinate value="800"/>',
            "        </LigatureAnchor>",
            '        <LigatureAnchor index="1" Format="1">',
            '          <XCoordinate value="1300"/>',
            '          <YCoordinate value="-20"/>',
            "        </LigatureAnchor>",
            "      </ComponentRecord>",
            "    </LigatureAttach>",
            "  </LigatureArray>",
            "</MarkLigPos>",
        ]

    def test_buildMarkRecord(self):
        rec = builder.buildMarkRecord(17, builder.buildAnchor(500, -20))
        assert getXML(rec.toXML) == [
            "<MarkRecord>",
            '  <Class value="17"/>',
            '  <MarkAnchor Format="1">',
            '    <XCoordinate value="500"/>',
            '    <YCoordinate value="-20"/>',
            "  </MarkAnchor>",
            "</MarkRecord>",
        ]

    def test_buildMark2Record(self):
        a = builder.buildAnchor
        rec = builder.buildMark2Record([a(500, -20), None, a(300, -15)])
        assert getXML(rec.toXML) == [
            "<Mark2Record>",
            '  <Mark2Anchor index="0" Format="1">',
            '    <XCoordinate value="500"/>',
            '    <YCoordinate value="-20"/>',
            "  </Mark2Anchor>",
            '  <Mark2Anchor index="1" empty="1"/>',
            '  <Mark2Anchor index="2" Format="1">',
            '    <XCoordinate value="300"/>',
            '    <YCoordinate value="-15"/>',
            "  </Mark2Anchor>",
            "</Mark2Record>",
        ]

    def test_buildPairPosClassesSubtable(self):
        d20 = builder.buildValue({"XPlacement": -20})
        d50 = builder.buildValue({"XPlacement": -50})
        d0 = builder.buildValue({})
        d8020 = builder.buildValue({"XPlacement": -80, "YPlacement": -20})
        subtable = builder.buildPairPosClassesSubtable(
            {
                (tuple("A"), tuple(["zero"])): (d0, d50),
                (tuple("A"), tuple(["one", "two"])): (None, d20),
                (tuple(["B", "C"]), tuple(["zero"])): (d8020, d50),
            },
            self.GLYPHMAP,
        )
        assert getXML(subtable.toXML) == [
            '<PairPos Format="2">',
            "  <Coverage>",
            '    <Glyph value="A"/>',
            '    <Glyph value="B"/>',
            '    <Glyph value="C"/>',
            "  </Coverage>",
            '  <ValueFormat1 value="3"/>',
            '  <ValueFormat2 value="1"/>',
            "  <ClassDef1>",
            '    <ClassDef glyph="A" class="1"/>',
            "  </ClassDef1>",
            "  <ClassDef2>",
            '    <ClassDef glyph="one" class="1"/>',
            '    <ClassDef glyph="two" class="1"/>',
            '    <ClassDef glyph="zero" class="2"/>',
            "  </ClassDef2>",
            "  <!-- Class1Count=2 -->",
            "  <!-- Class2Count=3 -->",
            '  <Class1Record index="0">',
            '    <Class2Record index="0">',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="0"/>',
            "    </Class2Record>",
            '    <Class2Record index="1">',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="0"/>',
            "    </Class2Record>",
            '    <Class2Record index="2">',
            '      <Value1 XPlacement="-80" YPlacement="-20"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </Class2Record>",
            "  </Class1Record>",
            '  <Class1Record index="1">',
            '    <Class2Record index="0">',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="0"/>',
            "    </Class2Record>",
            '    <Class2Record index="1">',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="-20"/>',
            "    </Class2Record>",
            '    <Class2Record index="2">',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </Class2Record>",
            "  </Class1Record>",
            "</PairPos>",
        ]

    def test_buildPairPosGlyphs(self):
        d50 = builder.buildValue({"XPlacement": -50})
        d8020 = builder.buildValue({"XPlacement": -80, "YPlacement": -20})
        subtables = builder.buildPairPosGlyphs(
            {("A", "zero"): (None, d50), ("A", "one"): (d8020, d50)}, self.GLYPHMAP
        )
        assert sum([getXML(t.toXML) for t in subtables], []) == [
            '<PairPos Format="1">',
            "  <Coverage>",
            '    <Glyph value="A"/>',
            "  </Coverage>",
            '  <ValueFormat1 value="0"/>',
            '  <ValueFormat2 value="1"/>',
            "  <!-- PairSetCount=1 -->",
            '  <PairSet index="0">',
            "    <!-- PairValueCount=1 -->",
            '    <PairValueRecord index="0">',
            '      <SecondGlyph value="zero"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </PairValueRecord>",
            "  </PairSet>",
            "</PairPos>",
            '<PairPos Format="1">',
            "  <Coverage>",
            '    <Glyph value="A"/>',
            "  </Coverage>",
            '  <ValueFormat1 value="3"/>',
            '  <ValueFormat2 value="1"/>',
            "  <!-- PairSetCount=1 -->",
            '  <PairSet index="0">',
            "    <!-- PairValueCount=1 -->",
            '    <PairValueRecord index="0">',
            '      <SecondGlyph value="one"/>',
            '      <Value1 XPlacement="-80" YPlacement="-20"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </PairValueRecord>",
            "  </PairSet>",
            "</PairPos>",
        ]

    def test_buildPairPosGlyphsSubtable(self):
        d20 = builder.buildValue({"XPlacement": -20})
        d50 = builder.buildValue({"XPlacement": -50})
        d0 = builder.buildValue({})
        d8020 = builder.buildValue({"XPlacement": -80, "YPlacement": -20})
        subtable = builder.buildPairPosGlyphsSubtable(
            {
                ("A", "zero"): (d0, d50),
                ("A", "one"): (None, d20),
                ("B", "five"): (d8020, d50),
            },
            self.GLYPHMAP,
        )

        assert getXML(subtable.toXML) == [
            '<PairPos Format="1">',
            "  <Coverage>",
            '    <Glyph value="A"/>',
            '    <Glyph value="B"/>',
            "  </Coverage>",
            '  <ValueFormat1 value="3"/>',
            '  <ValueFormat2 value="1"/>',
            "  <!-- PairSetCount=2 -->",
            '  <PairSet index="0">',
            "    <!-- PairValueCount=2 -->",
            '    <PairValueRecord index="0">',
            '      <SecondGlyph value="zero"/>',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </PairValueRecord>",
            '    <PairValueRecord index="1">',
            '      <SecondGlyph value="one"/>',
            '      <Value1 XPlacement="0" YPlacement="0"/>',
            '      <Value2 XPlacement="-20"/>',
            "    </PairValueRecord>",
            "  </PairSet>",
            '  <PairSet index="1">',
            "    <!-- PairValueCount=1 -->",
            '    <PairValueRecord index="0">',
            '      <SecondGlyph value="five"/>',
            '      <Value1 XPlacement="-80" YPlacement="-20"/>',
            '      <Value2 XPlacement="-50"/>',
            "    </PairValueRecord>",
            "  </PairSet>",
            "</PairPos>",
        ]

    def test_buildSinglePos(self):
        subtables = builder.buildSinglePos(
            {
                "one": builder.buildValue({"XPlacement": 500}),
                "two": builder.buildValue({"XPlacement": 500}),
                "three": builder.buildValue({"XPlacement": 200}),
                "four": builder.buildValue({"XPlacement": 400}),
                "five": builder.buildValue({"XPlacement": 500}),
                "six": builder.buildValue({"YPlacement": -6}),
            },
            self.GLYPHMAP,
        )
        assert sum([getXML(t.toXML) for t in subtables], []) == [
            '<SinglePos Format="2">',
            "  <Coverage>",
            '    <Glyph value="one"/>',
            '    <Glyph value="two"/>',
            '    <Glyph value="three"/>',
            '    <Glyph value="four"/>',
            '    <Glyph value="five"/>',
            "  </Coverage>",
            '  <ValueFormat value="1"/>',
            "  <!-- ValueCount=5 -->",
            '  <Value index="0" XPlacement="500"/>',
            '  <Value index="1" XPlacement="500"/>',
            '  <Value index="2" XPlacement="200"/>',
            '  <Value index="3" XPlacement="400"/>',
            '  <Value index="4" XPlacement="500"/>',
            "</SinglePos>",
            '<SinglePos Format="1">',
            "  <Coverage>",
            '    <Glyph value="six"/>',
            "  </Coverage>",
            '  <ValueFormat value="2"/>',
            '  <Value YPlacement="-6"/>',
            "</SinglePos>",
        ]

    def test_buildSinglePos_ValueFormat0(self):
        subtables = builder.buildSinglePos(
            {"zero": builder.buildValue({})}, self.GLYPHMAP
        )
        assert sum([getXML(t.toXML) for t in subtables], []) == [
            '<SinglePos Format="1">',
            "  <Coverage>",
            '    <Glyph value="zero"/>',
            "  </Coverage>",
            '  <ValueFormat value="0"/>',
            "</SinglePos>",
        ]

    def test_buildSinglePosSubtable_format1(self):
        subtable = builder.buildSinglePosSubtable(
            {
                "one": builder.buildValue({"XPlacement": 777}),
                "two": builder.buildValue({"XPlacement": 777}),
            },
            self.GLYPHMAP,
        )
        assert getXML(subtable.toXML) == [
            '<SinglePos Format="1">',
            "  <Coverage>",
            '    <Glyph value="one"/>',
            '    <Glyph value="two"/>',
            "  </Coverage>",
            '  <ValueFormat value="1"/>',
            '  <Value XPlacement="777"/>',
            "</SinglePos>",
        ]

    def test_buildSinglePosSubtable_format2(self):
        subtable = builder.buildSinglePosSubtable(
            {
                "one": builder.buildValue({"XPlacement": 777}),
                "two": builder.buildValue({"YPlacement": -888}),
            },
            self.GLYPHMAP,
        )
        assert getXML(subtable.toXML) == [
            '<SinglePos Format="2">',
            "  <Coverage>",
            '    <Glyph value="one"/>',
            '    <Glyph value="two"/>',
            "  </Coverage>",
            '  <ValueFormat value="3"/>',
            "  <!-- ValueCount=2 -->",
            '  <Value index="0" XPlacement="777" YPlacement="0"/>',
            '  <Value index="1" XPlacement="0" YPlacement="-888"/>',
            "</SinglePos>",
        ]

    def test_buildValue(self):
        value = builder.buildValue({"XPlacement": 7, "YPlacement": 23})
        func = lambda writer, font: value.toXML(writer, font, valueName="Val")
        assert getXML(func) == ['<Val XPlacement="7" YPlacement="23"/>']

    def test_getLigatureSortKey(self):
        components = lambda s: [tuple(word) for word in s.split()]
        c = components("fi fl ff ffi fff")
        c.sort(key=otTables.LigatureSubst._getLigatureSortKey)
        assert c == components("ffi fff fi fl ff")

    def test_getSinglePosValueKey(self):
        device = builder.buildDevice({10: 1, 11: 3})
        a1 = builder.buildValue({"XPlacement": 500, "XPlaDevice": device})
        a2 = builder.buildValue({"XPlacement": 500, "XPlaDevice": device})
        b = builder.buildValue({"XPlacement": 500})
        keyA1 = builder._getSinglePosValueKey(a1)
        keyA2 = builder._getSinglePosValueKey(a1)
        keyB = builder._getSinglePosValueKey(b)
        assert keyA1 == keyA2
        assert hash(keyA1) == hash(keyA2)
        assert keyA1 != keyB
        assert hash(keyA1) != hash(keyB)


class ClassDefBuilderTest(object):
    def test_build_usingClass0(self):
        b = builder.ClassDefBuilder(useClass0=True)
        b.add({"aa", "bb"})
        b.add({"a", "b"})
        b.add({"c"})
        b.add({"e", "f", "g", "h"})
        cdef = b.build()
        assert isinstance(cdef, otTables.ClassDef)
        assert cdef.classDefs == {"a": 1, "b": 1, "c": 3, "aa": 2, "bb": 2}

    def test_build_notUsingClass0(self):
        b = builder.ClassDefBuilder(useClass0=False)
        b.add({"a", "b"})
        b.add({"c"})
        b.add({"e", "f", "g", "h"})
        cdef = b.build()
        assert isinstance(cdef, otTables.ClassDef)
        assert cdef.classDefs == {
            "a": 2,
            "b": 2,
            "c": 3,
            "e": 1,
            "f": 1,
            "g": 1,
            "h": 1,
        }

    def test_canAdd(self):
        b = builder.ClassDefBuilder(useClass0=True)
        b.add({"a", "b", "c", "d"})
        b.add({"e", "f"})
        assert b.canAdd({"a", "b", "c", "d"})
        assert b.canAdd({"e", "f"})
        assert b.canAdd({"g", "h", "i"})
        assert not b.canAdd({"b", "c", "d"})
        assert not b.canAdd({"a", "b", "c", "d", "e", "f"})
        assert not b.canAdd({"d", "e", "f"})
        assert not b.canAdd({"f"})

    def test_add_exception(self):
        b = builder.ClassDefBuilder(useClass0=True)
        b.add({"a", "b", "c"})
        with pytest.raises(error.OpenTypeLibError):
            b.add({"a", "d"})


buildStatTable_test_data = [
    (
        [
            dict(
                tag="wght",
                name="Weight",
                values=[
                    dict(value=100, name="Thin"),
                    dict(value=400, name="Regular", flags=0x2),
                    dict(value=900, name="Black"),
                ],
            )
        ],
        None,
        "Regular",
        [
            "  <STAT>",
            '    <Version value="0x00010001"/>',
            '    <DesignAxisRecordSize value="8"/>',
            "    <!-- DesignAxisCount=1 -->",
            "    <DesignAxisRecord>",
            '      <Axis index="0">',
            '        <AxisTag value="wght"/>',
            '        <AxisNameID value="257"/>  <!-- Weight -->',
            '        <AxisOrdering value="0"/>',
            "      </Axis>",
            "    </DesignAxisRecord>",
            "    <!-- AxisValueCount=3 -->",
            "    <AxisValueArray>",
            '      <AxisValue index="0" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="258"/>  <!-- Thin -->',
            '        <Value value="100.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="1" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="256"/>  <!-- Regular -->',
            '        <Value value="400.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="2" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="259"/>  <!-- Black -->',
            '        <Value value="900.0"/>',
            "      </AxisValue>",
            "    </AxisValueArray>",
            '    <ElidedFallbackNameID value="256"/>  <!-- Regular -->',
            "  </STAT>",
        ],
    ),
    (
        [
            dict(
                tag="wght",
                name=dict(en="Weight", nl="Gewicht"),
                values=[
                    dict(value=100, name=dict(en="Thin", nl="Dun")),
                    dict(value=400, name="Regular", flags=0x2),
                    dict(value=900, name="Black"),
                ],
            ),
            dict(
                tag="wdth",
                name="Width",
                values=[
                    dict(value=50, name="Condensed"),
                    dict(value=100, name="Regular", flags=0x2),
                    dict(value=200, name="Extended"),
                ],
            ),
        ],
        None,
        2,
        [
            "  <STAT>",
            '    <Version value="0x00010001"/>',
            '    <DesignAxisRecordSize value="8"/>',
            "    <!-- DesignAxisCount=2 -->",
            "    <DesignAxisRecord>",
            '      <Axis index="0">',
            '        <AxisTag value="wght"/>',
            '        <AxisNameID value="256"/>  <!-- Weight -->',
            '        <AxisOrdering value="0"/>',
            "      </Axis>",
            '      <Axis index="1">',
            '        <AxisTag value="wdth"/>',
            '        <AxisNameID value="260"/>  <!-- Width -->',
            '        <AxisOrdering value="1"/>',
            "      </Axis>",
            "    </DesignAxisRecord>",
            "    <!-- AxisValueCount=6 -->",
            "    <AxisValueArray>",
            '      <AxisValue index="0" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="257"/>  <!-- Thin -->',
            '        <Value value="100.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="1" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="258"/>  <!-- Regular -->',
            '        <Value value="400.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="2" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="259"/>  <!-- Black -->',
            '        <Value value="900.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="3" Format="1">',
            '        <AxisIndex value="1"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="261"/>  <!-- Condensed -->',
            '        <Value value="50.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="4" Format="1">',
            '        <AxisIndex value="1"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="258"/>  <!-- Regular -->',
            '        <Value value="100.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="5" Format="1">',
            '        <AxisIndex value="1"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="262"/>  <!-- Extended -->',
            '        <Value value="200.0"/>',
            "      </AxisValue>",
            "    </AxisValueArray>",
            '    <ElidedFallbackNameID value="2"/>  <!-- missing from name table -->',
            "  </STAT>",
        ],
    ),
    (
        [
            dict(
                tag="wght",
                name="Weight",
                values=[
                    dict(value=400, name="Regular", flags=0x2),
                    dict(value=600, linkedValue=650, name="Bold"),
                ],
            )
        ],
        None,
        18,
        [
            "  <STAT>",
            '    <Version value="0x00010001"/>',
            '    <DesignAxisRecordSize value="8"/>',
            "    <!-- DesignAxisCount=1 -->",
            "    <DesignAxisRecord>",
            '      <Axis index="0">',
            '        <AxisTag value="wght"/>',
            '        <AxisNameID value="256"/>  <!-- Weight -->',
            '        <AxisOrdering value="0"/>',
            "      </Axis>",
            "    </DesignAxisRecord>",
            "    <!-- AxisValueCount=2 -->",
            "    <AxisValueArray>",
            '      <AxisValue index="0" Format="1">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="257"/>  <!-- Regular -->',
            '        <Value value="400.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="1" Format="3">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="258"/>  <!-- Bold -->',
            '        <Value value="600.0"/>',
            '        <LinkedValue value="650.0"/>',
            "      </AxisValue>",
            "    </AxisValueArray>",
            '    <ElidedFallbackNameID value="18"/>  <!-- missing from name table -->',
            "  </STAT>",
        ],
    ),
    (
        [
            dict(
                tag="opsz",
                name="Optical Size",
                values=[
                    dict(nominalValue=6, rangeMaxValue=10, name="Small"),
                    dict(
                        rangeMinValue=10,
                        nominalValue=14,
                        rangeMaxValue=24,
                        name="Text",
                        flags=0x2,
                    ),
                    dict(rangeMinValue=24, nominalValue=600, name="Display"),
                ],
            )
        ],
        None,
        2,
        [
            "  <STAT>",
            '    <Version value="0x00010001"/>',
            '    <DesignAxisRecordSize value="8"/>',
            "    <!-- DesignAxisCount=1 -->",
            "    <DesignAxisRecord>",
            '      <Axis index="0">',
            '        <AxisTag value="opsz"/>',
            '        <AxisNameID value="256"/>  <!-- Optical Size -->',
            '        <AxisOrdering value="0"/>',
            "      </Axis>",
            "    </DesignAxisRecord>",
            "    <!-- AxisValueCount=3 -->",
            "    <AxisValueArray>",
            '      <AxisValue index="0" Format="2">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="257"/>  <!-- Small -->',
            '        <NominalValue value="6.0"/>',
            '        <RangeMinValue value="-32768.0"/>',
            '        <RangeMaxValue value="10.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="1" Format="2">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="258"/>  <!-- Text -->',
            '        <NominalValue value="14.0"/>',
            '        <RangeMinValue value="10.0"/>',
            '        <RangeMaxValue value="24.0"/>',
            "      </AxisValue>",
            '      <AxisValue index="2" Format="2">',
            '        <AxisIndex value="0"/>',
            '        <Flags value="0"/>',
            '        <ValueNameID value="259"/>  <!-- Display -->',
            '        <NominalValue value="600.0"/>',
            '        <RangeMinValue value="24.0"/>',
            '        <RangeMaxValue value="32767.99998"/>',
            "      </AxisValue>",
            "    </AxisValueArray>",
            '    <ElidedFallbackNameID value="2"/>  <!-- missing from name table -->',
            "  </STAT>",
        ],
    ),
    (
        [
            dict(tag="wght", name="Weight", ordering=1, values=[]),
            dict(
                tag="ABCD",
                name="ABCDTest",
                ordering=0,
                values=[dict(value=100, name="Regular", flags=0x2)],
            ),
        ],
        [dict(location=dict(wght=300, ABCD=100), name="Regular ABCD")],
        18,
        [
            "  <STAT>",
            '    <Version value="0x00010002"/>',
            '    <DesignAxisRecordSize value="8"/>',
            "    <!-- DesignAxisCount=2 -->",
            "    <DesignAxisRecord>",
            '      <Axis index="0">',
            '        <AxisTag value="wght"/>',
            '        <AxisNameID value="256"/>  <!-- Weight -->',
            '        <AxisOrdering value="1"/>',
            "      </Axis>",
            '      <Axis index="1">',
            '        <AxisTag value="ABCD"/>',
            '        <AxisNameID value="257"/>  <!-- ABCDTest -->',
            '        <AxisOrdering value="0"/>',
            "      </Axis>",
            "    </DesignAxisRecord>",
            "    <!-- AxisValueCount=2 -->",
            "    <AxisValueArray>",
            '      <AxisValue index="0" Format="4">',
            "        <!-- AxisCount=2 -->",
            '        <Flags value="0"/>',
            '        <ValueNameID value="259"/>  <!-- Regular ABCD -->',
            '        <AxisValueRecord index="0">',
            '          <AxisIndex value="0"/>',
            '          <Value value="300.0"/>',
            "        </AxisValueRecord>",
            '        <AxisValueRecord index="1">',
            '          <AxisIndex value="1"/>',
            '          <Value value="100.0"/>',
            "        </AxisValueRecord>",
            "      </AxisValue>",
            '      <AxisValue index="1" Format="1">',
            '        <AxisIndex value="1"/>',
            '        <Flags value="2"/>  <!-- ElidableAxisValueName -->',
            '        <ValueNameID value="258"/>  <!-- Regular -->',
            '        <Value value="100.0"/>',
            "      </AxisValue>",
            "    </AxisValueArray>",
            '    <ElidedFallbackNameID value="18"/>  <!-- missing from name table -->',
            "  </STAT>",
        ],
    ),
]


@pytest.mark.parametrize(
    "axes, axisValues, elidedFallbackName, expected_ttx", buildStatTable_test_data
)
def test_buildStatTable(axes, axisValues, elidedFallbackName, expected_ttx):
    font = ttLib.TTFont()
    font["name"] = ttLib.newTable("name")
    font["name"].names = []
    # https://github.com/fonttools/fonttools/issues/1985
    # Add nameID < 256 that matches a test axis name, to test whether
    # the nameID is not reused: AxisNameIDs must be > 255 according
    # to the spec.
    font["name"].addMultilingualName(dict(en="ABCDTest"), nameID=6)
    builder.buildStatTable(font, axes, axisValues, elidedFallbackName)
    f = io.StringIO()
    font.saveXML(f, tables=["STAT"])
    ttx = f.getvalue().splitlines()
    ttx = ttx[3:-2]  # strip XML header and <ttFont> element
    assert expected_ttx == ttx
    # Compile and round-trip
    f = io.BytesIO()
    font.save(f)
    font = ttLib.TTFont(f)
    f = io.StringIO()
    font.saveXML(f, tables=["STAT"])
    ttx = f.getvalue().splitlines()
    ttx = ttx[3:-2]  # strip XML header and <ttFont> element
    assert expected_ttx == ttx


def test_buildStatTable_platform_specific_names():
    # PR: https://github.com/fonttools/fonttools/pull/2528
    # Introduce new 'platform' feature for creating a STAT table.
    # Set windowsNames and or macNames to create name table entries
    # in the specified platforms
    font_obj = ttLib.TTFont()
    font_obj["name"] = ttLib.newTable("name")
    font_obj["name"].names = []

    wght_values = [
        dict(nominalValue=200, rangeMinValue=200, rangeMaxValue=250, name="ExtraLight"),
        dict(nominalValue=300, rangeMinValue=250, rangeMaxValue=350, name="Light"),
        dict(
            nominalValue=400,
            rangeMinValue=350,
            rangeMaxValue=450,
            name="Regular",
            flags=0x2,
        ),
        dict(nominalValue=500, rangeMinValue=450, rangeMaxValue=650, name="Medium"),
        dict(nominalValue=700, rangeMinValue=650, rangeMaxValue=750, name="Bold"),
        dict(nominalValue=800, rangeMinValue=750, rangeMaxValue=850, name="ExtraBold"),
        dict(nominalValue=900, rangeMinValue=850, rangeMaxValue=900, name="Black"),
    ]

    AXES = [
        dict(
            tag="wght",
            name="Weight",
            ordering=1,
            values=wght_values,
        ),
    ]

    font_obj["name"].setName("ExtraLight", 260, 3, 1, 0x409)
    font_obj["name"].setName("Light", 261, 3, 1, 0x409)
    font_obj["name"].setName("Regular", 262, 3, 1, 0x409)
    font_obj["name"].setName("Medium", 263, 3, 1, 0x409)
    font_obj["name"].setName("Bold", 264, 3, 1, 0x409)
    font_obj["name"].setName("ExtraBold", 265, 3, 1, 0x409)
    font_obj["name"].setName("Black", 266, 3, 1, 0x409)

    font_obj["name"].setName("Weight", 270, 3, 1, 0x409)

    expected_names = [x.string for x in font_obj["name"].names]

    builder.buildStatTable(font_obj, AXES, windowsNames=True, macNames=False)
    actual_names = [x.string for x in font_obj["name"].names]

    # no new name records were added by buildStatTable
    # because windows-only names with the same strings were already present
    assert expected_names == actual_names

    font_obj["name"].removeNames(nameID=270)
    expected_names = [x.string for x in font_obj["name"].names] + ["Weight"]

    builder.buildStatTable(font_obj, AXES, windowsNames=True, macNames=False)
    actual_names = [x.string for x in font_obj["name"].names]
    # One new name records 'Weight' were added by buildStatTable
    assert expected_names == actual_names

    builder.buildStatTable(font_obj, AXES, windowsNames=True, macNames=True)
    actual_names = [x.string for x in font_obj["name"].names]
    expected_names = [
        "Weight",
        "Weight",
        "Weight",
        "ExtraLight",
        "ExtraLight",
        "ExtraLight",
        "Light",
        "Light",
        "Light",
        "Regular",
        "Regular",
        "Regular",
        "Medium",
        "Medium",
        "Medium",
        "Bold",
        "Bold",
        "Bold",
        "ExtraBold",
        "ExtraBold",
        "ExtraBold",
        "Black",
        "Black",
        "Black",
    ]
    # Because there is an inconsistency in the names add new name IDs
    # for each platform -> windowsNames=True, macNames=True
    assert sorted(expected_names) == sorted(actual_names)


def test_stat_infinities():
    negInf = floatToFixed(builder.AXIS_VALUE_NEGATIVE_INFINITY, 16)
    assert struct.pack(">l", negInf) == b"\x80\x00\x00\x00"
    posInf = floatToFixed(builder.AXIS_VALUE_POSITIVE_INFINITY, 16)
    assert struct.pack(">l", posInf) == b"\x7f\xff\xff\xff"


def test_buildMathTable_empty():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder([])
    builder.buildMathTable(ttFont)

    assert "MATH" in ttFont
    mathTable = ttFont["MATH"].table
    assert mathTable.Version == 0x00010000

    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants is None


def test_buildMathTable_constants():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder([])
    constants = {
        "AccentBaseHeight": 516,
        "AxisHeight": 262,
        "DelimitedSubFormulaMinHeight": 1500,
        "DisplayOperatorMinHeight": 2339,
        "FlattenedAccentBaseHeight": 698,
        "FractionDenomDisplayStyleGapMin": 198,
        "FractionDenominatorDisplayStyleShiftDown": 698,
        "FractionDenominatorGapMin": 66,
        "FractionDenominatorShiftDown": 465,
        "FractionNumDisplayStyleGapMin": 198,
        "FractionNumeratorDisplayStyleShiftUp": 774,
        "FractionNumeratorGapMin": 66,
        "FractionNumeratorShiftUp": 516,
        "FractionRuleThickness": 66,
        "LowerLimitBaselineDropMin": 585,
        "LowerLimitGapMin": 132,
        "MathLeading": 300,
        "OverbarExtraAscender": 66,
        "OverbarRuleThickness": 66,
        "OverbarVerticalGap": 198,
        "RadicalDegreeBottomRaisePercent": 75,
        "RadicalDisplayStyleVerticalGap": 195,
        "RadicalExtraAscender": 66,
        "RadicalKernAfterDegree": -556,
        "RadicalKernBeforeDegree": 278,
        "RadicalRuleThickness": 66,
        "RadicalVerticalGap": 82,
        "ScriptPercentScaleDown": 70,
        "ScriptScriptPercentScaleDown": 55,
        "SkewedFractionHorizontalGap": 66,
        "SkewedFractionVerticalGap": 77,
        "SpaceAfterScript": 42,
        "StackBottomDisplayStyleShiftDown": 698,
        "StackBottomShiftDown": 465,
        "StackDisplayStyleGapMin": 462,
        "StackGapMin": 198,
        "StackTopDisplayStyleShiftUp": 774,
        "StackTopShiftUp": 516,
        "StretchStackBottomShiftDown": 585,
        "StretchStackGapAboveMin": 132,
        "StretchStackGapBelowMin": 132,
        "StretchStackTopShiftUp": 165,
        "SubSuperscriptGapMin": 264,
        "SubscriptBaselineDropMin": 105,
        "SubscriptShiftDown": 140,
        "SubscriptTopMax": 413,
        "SuperscriptBaselineDropMax": 221,
        "SuperscriptBottomMaxWithSubscript": 413,
        "SuperscriptBottomMin": 129,
        "SuperscriptShiftUp": 477,
        "SuperscriptShiftUpCramped": 358,
        "UnderbarExtraDescender": 66,
        "UnderbarRuleThickness": 66,
        "UnderbarVerticalGap": 198,
        "UpperLimitBaselineRiseMin": 165,
        "UpperLimitGapMin": 132,
    }
    builder.buildMathTable(ttFont, constants=constants)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants is None
    for k, v in constants.items():
        r = getattr(mathTable.MathConstants, k)
        try:
            r = r.Value
        except AttributeError:
            pass
        assert r == v


def test_buildMathTable_italicsCorrection():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
    italicsCorrections = {"A": 100, "C": 300, "D": 400, "E": 500}
    builder.buildMathTable(ttFont, italicsCorrections=italicsCorrections)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo
    assert mathTable.MathVariants is None
    assert set(
        mathTable.MathGlyphInfo.MathItalicsCorrectionInfo.Coverage.glyphs
    ) == set(italicsCorrections.keys())
    for glyph, correction in zip(
        mathTable.MathGlyphInfo.MathItalicsCorrectionInfo.Coverage.glyphs,
        mathTable.MathGlyphInfo.MathItalicsCorrectionInfo.ItalicsCorrection,
    ):
        assert correction.Value == italicsCorrections[glyph]


def test_buildMathTable_topAccentAttachment():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
    topAccentAttachments = {"A": 10, "B": 20, "C": 30, "E": 50}
    builder.buildMathTable(ttFont, topAccentAttachments=topAccentAttachments)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo
    assert mathTable.MathVariants is None
    assert set(
        mathTable.MathGlyphInfo.MathTopAccentAttachment.TopAccentCoverage.glyphs
    ) == set(topAccentAttachments.keys())
    for glyph, attachment in zip(
        mathTable.MathGlyphInfo.MathTopAccentAttachment.TopAccentCoverage.glyphs,
        mathTable.MathGlyphInfo.MathTopAccentAttachment.TopAccentAttachment,
    ):
        assert attachment.Value == topAccentAttachments[glyph]


def test_buildMathTable_extendedShape():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
    extendedShapes = {"A", "C", "E", "F"}
    builder.buildMathTable(ttFont, extendedShapes=extendedShapes)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo
    assert mathTable.MathVariants is None
    assert set(mathTable.MathGlyphInfo.ExtendedShapeCoverage.glyphs) == extendedShapes


def test_buildMathTable_mathKern():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "B"])
    mathKerns = {
        "A": {
            "TopRight": ([10, 20], [10, 20, 30]),
            "BottomRight": ([], [10]),
            "TopLeft": ([10], [0, 20]),
            "BottomLeft": ([-10, 0], [0, 10, 20]),
        },
    }
    builder.buildMathTable(ttFont, mathKerns=mathKerns)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo
    assert mathTable.MathVariants is None
    assert set(mathTable.MathGlyphInfo.MathKernInfo.MathKernCoverage.glyphs) == set(
        mathKerns.keys()
    )
    for glyph, record in zip(
        mathTable.MathGlyphInfo.MathKernInfo.MathKernCoverage.glyphs,
        mathTable.MathGlyphInfo.MathKernInfo.MathKernInfoRecords,
    ):
        h, k = mathKerns[glyph]["TopRight"]
        assert [v.Value for v in record.TopRightMathKern.CorrectionHeight] == h
        assert [v.Value for v in record.TopRightMathKern.KernValue] == k
        h, k = mathKerns[glyph]["BottomRight"]
        assert [v.Value for v in record.BottomRightMathKern.CorrectionHeight] == h
        assert [v.Value for v in record.BottomRightMathKern.KernValue] == k
        h, k = mathKerns[glyph]["TopLeft"]
        assert [v.Value for v in record.TopLeftMathKern.CorrectionHeight] == h
        assert [v.Value for v in record.TopLeftMathKern.KernValue] == k
        h, k = mathKerns[glyph]["BottomLeft"]
        assert [v.Value for v in record.BottomLeftMathKern.CorrectionHeight] == h
        assert [v.Value for v in record.BottomLeftMathKern.KernValue] == k


def test_buildMathTable_vertVariants():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "A.size1", "A.size2"])
    vertGlyphVariants = {"A": [("A.size1", 100), ("A.size2", 200)]}
    builder.buildMathTable(ttFont, vertGlyphVariants=vertGlyphVariants)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants
    assert set(mathTable.MathVariants.VertGlyphCoverage.glyphs) == set(
        vertGlyphVariants.keys()
    )
    for glyph, construction in zip(
        mathTable.MathVariants.VertGlyphCoverage.glyphs,
        mathTable.MathVariants.VertGlyphConstruction,
    ):
        assert [
            (r.VariantGlyph, r.AdvanceMeasurement)
            for r in construction.MathGlyphVariantRecord
        ] == vertGlyphVariants[glyph]


def test_buildMathTable_horizVariants():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "A.size1", "A.size2"])
    horizGlyphVariants = {"A": [("A.size1", 100), ("A.size2", 200)]}
    builder.buildMathTable(ttFont, horizGlyphVariants=horizGlyphVariants)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants
    assert set(mathTable.MathVariants.HorizGlyphCoverage.glyphs) == set(
        horizGlyphVariants.keys()
    )
    for glyph, construction in zip(
        mathTable.MathVariants.HorizGlyphCoverage.glyphs,
        mathTable.MathVariants.HorizGlyphConstruction,
    ):
        assert [
            (r.VariantGlyph, r.AdvanceMeasurement)
            for r in construction.MathGlyphVariantRecord
        ] == horizGlyphVariants[glyph]


def test_buildMathTable_vertAssembly():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "A.top", "A.middle", "A.bottom", "A.extender"])
    vertGlyphAssembly = {
        "A": [
            [
                ("A.bottom", 0, 0, 100, 200),
                ("A.extender", 1, 50, 50, 100),
                ("A.middle", 0, 100, 100, 200),
                ("A.extender", 1, 50, 50, 100),
                ("A.top", 0, 100, 0, 200),
            ],
            10,
        ],
    }
    builder.buildMathTable(ttFont, vertGlyphAssembly=vertGlyphAssembly)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants
    assert set(mathTable.MathVariants.VertGlyphCoverage.glyphs) == set(
        vertGlyphAssembly.keys()
    )
    for glyph, construction in zip(
        mathTable.MathVariants.VertGlyphCoverage.glyphs,
        mathTable.MathVariants.VertGlyphConstruction,
    ):
        assert [
            [
                (
                    r.glyph,
                    r.PartFlags,
                    r.StartConnectorLength,
                    r.EndConnectorLength,
                    r.FullAdvance,
                )
                for r in construction.GlyphAssembly.PartRecords
            ],
            construction.GlyphAssembly.ItalicsCorrection.Value,
        ] == vertGlyphAssembly[glyph]


def test_buildMathTable_horizAssembly():
    ttFont = ttLib.TTFont()
    ttFont.setGlyphOrder(["A", "A.top", "A.middle", "A.bottom", "A.extender"])
    horizGlyphAssembly = {
        "A": [
            [
                ("A.bottom", 0, 0, 100, 200),
                ("A.extender", 1, 50, 50, 100),
                ("A.middle", 0, 100, 100, 200),
                ("A.extender", 1, 50, 50, 100),
                ("A.top", 0, 100, 0, 200),
            ],
            10,
        ],
    }
    builder.buildMathTable(ttFont, horizGlyphAssembly=horizGlyphAssembly)
    mathTable = ttFont["MATH"].table
    assert mathTable.MathConstants is None
    assert mathTable.MathGlyphInfo is None
    assert mathTable.MathVariants
    assert set(mathTable.MathVariants.HorizGlyphCoverage.glyphs) == set(
        horizGlyphAssembly.keys()
    )
    for glyph, construction in zip(
        mathTable.MathVariants.HorizGlyphCoverage.glyphs,
        mathTable.MathVariants.HorizGlyphConstruction,
    ):
        assert [
            [
                (
                    r.glyph,
                    r.PartFlags,
                    r.StartConnectorLength,
                    r.EndConnectorLength,
                    r.FullAdvance,
                )
                for r in construction.GlyphAssembly.PartRecords
            ],
            construction.GlyphAssembly.ItalicsCorrection.Value,
        ] == horizGlyphAssembly[glyph]


class ChainContextualRulesetTest(object):
    def test_makeRulesets(self):
        font = ttLib.TTFont()
        font.setGlyphOrder(["a", "b", "c", "d", "A", "B", "C", "D", "E"])
        sb = builder.ChainContextSubstBuilder(font, None)
        prefix, input_, suffix, lookups = [["a"], ["b"]], [["c"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))

        prefix, input_, suffix, lookups = [["a"], ["d"]], [["c"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))

        sb.add_subtable_break(None)

        # Second subtable has some glyph classes
        prefix, input_, suffix, lookups = [["A"]], [["E"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))
        prefix, input_, suffix, lookups = [["A"]], [["C", "D"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))
        prefix, input_, suffix, lookups = [["A", "B"]], [["E"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))

        sb.add_subtable_break(None)

        # Third subtable has no pre/post context
        prefix, input_, suffix, lookups = [], [["E"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))
        prefix, input_, suffix, lookups = [], [["C", "D"]], [], [None]
        sb.rules.append(builder.ChainContextualRule(prefix, input_, suffix, lookups))

        rulesets = sb.rulesets()
        assert len(rulesets) == 3
        assert rulesets[0].hasPrefixOrSuffix
        assert not rulesets[0].hasAnyGlyphClasses
        cd = rulesets[0].format2ClassDefs()
        assert set(cd[0].classes()[1:]) == set([("d",), ("b",), ("a",)])
        assert set(cd[1].classes()[1:]) == set([("c",)])
        assert set(cd[2].classes()[1:]) == set()

        assert rulesets[1].hasPrefixOrSuffix
        assert rulesets[1].hasAnyGlyphClasses
        assert not rulesets[1].format2ClassDefs()

        assert not rulesets[2].hasPrefixOrSuffix
        assert rulesets[2].hasAnyGlyphClasses
        assert rulesets[2].format2ClassDefs()
        cd = rulesets[2].format2ClassDefs()
        assert set(cd[0].classes()[1:]) == set()
        assert set(cd[1].classes()[1:]) == set([("C", "D"), ("E",)])
        assert set(cd[2].classes()[1:]) == set()


if __name__ == "__main__":
    import sys

    sys.exit(pytest.main(sys.argv))