from fontTools.misc.fixedTools import floatToFixedToFloat from fontTools.misc.roundTools import noRound from fontTools.misc.testTools import stripVariableItemsFromTTX from fontTools.misc.textTools import Tag from fontTools import ttLib from fontTools import designspaceLib from fontTools.feaLib.builder import addOpenTypeFeaturesFromString from fontTools.ttLib.tables import _f_v_a_r, _g_l_y_f from fontTools.ttLib.tables import otTables from fontTools.ttLib.tables.TupleVariation import TupleVariation from fontTools import varLib from fontTools.varLib import instancer from fontTools.varLib.mvar import MVAR_ENTRIES from fontTools.varLib import builder from fontTools.varLib import featureVars from fontTools.varLib import models import collections from copy import deepcopy from io import BytesIO, StringIO import logging import os import re from types import SimpleNamespace import pytest # see Tests/varLib/instancer/conftest.py for "varfont" fixture definition TESTDATA = os.path.join(os.path.dirname(__file__), "data") @pytest.fixture(params=[True, False], ids=["optimize", "no-optimize"]) def optimize(request): return request.param @pytest.fixture def fvarAxes(): wght = _f_v_a_r.Axis() wght.axisTag = Tag("wght") wght.minValue = 100 wght.defaultValue = 400 wght.maxValue = 900 wdth = _f_v_a_r.Axis() wdth.axisTag = Tag("wdth") wdth.minValue = 70 wdth.defaultValue = 100 wdth.maxValue = 100 return [wght, wdth] def _get_coordinates(varfont, glyphname): # converts GlyphCoordinates to a list of (x, y) tuples, so that pytest's # assert will give us a nicer diff return list( varfont["glyf"]._getCoordinatesAndControls( glyphname, varfont["hmtx"].metrics, varfont["vmtx"].metrics, # the tests expect float coordinates round=noRound, )[0] ) class InstantiateGvarTest(object): @pytest.mark.parametrize("glyph_name", ["hyphen"]) @pytest.mark.parametrize( "location, expected", [ pytest.param( {"wdth": -1.0}, { "hyphen": [ (27, 229), (27, 310), (247, 310), (247, 229), (0, 0), (274, 0), (0, 536), (0, 0), ] }, id="wdth=-1.0", ), pytest.param( {"wdth": -0.5}, { "hyphen": [ (33.5, 229), (33.5, 308.5), (264.5, 308.5), (264.5, 229), (0, 0), (298, 0), (0, 536), (0, 0), ] }, id="wdth=-0.5", ), # an axis pinned at the default normalized location (0.0) means # the default glyf outline stays the same pytest.param( {"wdth": 0.0}, { "hyphen": [ (40, 229), (40, 307), (282, 307), (282, 229), (0, 0), (322, 0), (0, 536), (0, 0), ] }, id="wdth=0.0", ), ], ) def test_pin_and_drop_axis(self, varfont, glyph_name, location, expected, optimize): location = instancer.NormalizedAxisLimits(location) instancer.instantiateGvar(varfont, location, optimize=optimize) assert _get_coordinates(varfont, glyph_name) == expected[glyph_name] # check that the pinned axis has been dropped from gvar assert not any( "wdth" in t.axes for tuples in varfont["gvar"].variations.values() for t in tuples ) def test_full_instance(self, varfont, optimize): location = instancer.NormalizedAxisLimits(wght=0.0, wdth=-0.5) instancer.instantiateGvar(varfont, location, optimize=optimize) assert _get_coordinates(varfont, "hyphen") == [ (33.5, 229), (33.5, 308.5), (264.5, 308.5), (264.5, 229), (0, 0), (298, 0), (0, 536), (0, 0), ] assert "gvar" not in varfont def test_composite_glyph_not_in_gvar(self, varfont): """The 'minus' glyph is a composite glyph, which references 'hyphen' as a component, but has no tuple variations in gvar table, so the component offset and the phantom points do not change; however the sidebearings and bounding box do change as a result of the parent glyph 'hyphen' changing. """ hmtx = varfont["hmtx"] vmtx = varfont["vmtx"] hyphenCoords = _get_coordinates(varfont, "hyphen") assert hyphenCoords == [ (40, 229), (40, 307), (282, 307), (282, 229), (0, 0), (322, 0), (0, 536), (0, 0), ] assert hmtx["hyphen"] == (322, 40) assert vmtx["hyphen"] == (536, 229) minusCoords = _get_coordinates(varfont, "minus") assert minusCoords == [(0, 0), (0, 0), (422, 0), (0, 536), (0, 0)] assert hmtx["minus"] == (422, 40) assert vmtx["minus"] == (536, 229) location = instancer.NormalizedAxisLimits(wght=-1.0, wdth=-1.0) instancer.instantiateGvar(varfont, location) # check 'hyphen' coordinates changed assert _get_coordinates(varfont, "hyphen") == [ (26, 259), (26, 286), (237, 286), (237, 259), (0, 0), (263, 0), (0, 536), (0, 0), ] # check 'minus' coordinates (i.e. component offset and phantom points) # did _not_ change assert _get_coordinates(varfont, "minus") == minusCoords assert hmtx["hyphen"] == (263, 26) assert vmtx["hyphen"] == (536, 250) assert hmtx["minus"] == (422, 26) # 'minus' left sidebearing changed assert vmtx["minus"] == (536, 250) # 'minus' top sidebearing too class InstantiateCvarTest(object): @pytest.mark.parametrize( "location, expected", [ pytest.param({"wght": -1.0}, [500, -400, 150, 250], id="wght=-1.0"), pytest.param({"wdth": -1.0}, [500, -400, 180, 200], id="wdth=-1.0"), pytest.param({"wght": -0.5}, [500, -400, 165, 250], id="wght=-0.5"), pytest.param({"wdth": -0.3}, [500, -400, 180, 235], id="wdth=-0.3"), ], ) def test_pin_and_drop_axis(self, varfont, location, expected): location = instancer.NormalizedAxisLimits(location) instancer.instantiateCvar(varfont, location) assert list(varfont["cvt "].values) == expected # check that the pinned axis has been dropped from cvar pinned_axes = location.keys() assert not any( axis in t.axes for t in varfont["cvar"].variations for axis in pinned_axes ) def test_full_instance(self, varfont): location = instancer.NormalizedAxisLimits(wght=-0.5, wdth=-0.5) instancer.instantiateCvar(varfont, location) assert list(varfont["cvt "].values) == [500, -400, 165, 225] assert "cvar" not in varfont class InstantiateMVARTest(object): @pytest.mark.parametrize( "location, expected", [ pytest.param( {"wght": 1.0}, {"strs": 100, "undo": -200, "unds": 150, "xhgt": 530}, id="wght=1.0", ), pytest.param( {"wght": 0.5}, {"strs": 75, "undo": -150, "unds": 100, "xhgt": 515}, id="wght=0.5", ), pytest.param( {"wght": 0.0}, {"strs": 50, "undo": -100, "unds": 50, "xhgt": 500}, id="wght=0.0", ), pytest.param( {"wdth": -1.0}, {"strs": 20, "undo": -100, "unds": 50, "xhgt": 500}, id="wdth=-1.0", ), pytest.param( {"wdth": -0.5}, {"strs": 35, "undo": -100, "unds": 50, "xhgt": 500}, id="wdth=-0.5", ), pytest.param( {"wdth": 0.0}, {"strs": 50, "undo": -100, "unds": 50, "xhgt": 500}, id="wdth=0.0", ), ], ) def test_pin_and_drop_axis(self, varfont, location, expected): mvar = varfont["MVAR"].table # initially we have two VarData: the first contains deltas associated with 3 # regions: 1 with only wght, 1 with only wdth, and 1 with both wght and wdth assert len(mvar.VarStore.VarData) == 2 assert mvar.VarStore.VarRegionList.RegionCount == 3 assert mvar.VarStore.VarData[0].VarRegionCount == 3 assert all(len(item) == 3 for item in mvar.VarStore.VarData[0].Item) # The second VarData has deltas associated only with 1 region (wght only). assert mvar.VarStore.VarData[1].VarRegionCount == 1 assert all(len(item) == 1 for item in mvar.VarStore.VarData[1].Item) location = instancer.NormalizedAxisLimits(location) instancer.instantiateMVAR(varfont, location) for mvar_tag, expected_value in expected.items(): table_tag, item_name = MVAR_ENTRIES[mvar_tag] assert getattr(varfont[table_tag], item_name) == expected_value # check that regions and accompanying deltas have been dropped num_regions_left = len(mvar.VarStore.VarRegionList.Region) assert num_regions_left < 3 assert mvar.VarStore.VarRegionList.RegionCount == num_regions_left assert mvar.VarStore.VarData[0].VarRegionCount == num_regions_left # VarData subtables have been merged assert len(mvar.VarStore.VarData) == 1 @pytest.mark.parametrize( "location, expected, sync_vmetrics", [ pytest.param( {"wght": 1.0, "wdth": 0.0}, {"strs": 100, "undo": -200, "unds": 150, "hasc": 1100}, True, id="wght=1.0,wdth=0.0", ), pytest.param( {"wght": 0.0, "wdth": -1.0}, {"strs": 20, "undo": -100, "unds": 50, "hasc": 1000}, True, id="wght=0.0,wdth=-1.0", ), pytest.param( {"wght": 0.5, "wdth": -0.5}, {"strs": 55, "undo": -145, "unds": 95, "hasc": 1050}, True, id="wght=0.5,wdth=-0.5", ), pytest.param( {"wght": 1.0, "wdth": -1.0}, {"strs": 50, "undo": -180, "unds": 130, "hasc": 1100}, True, id="wght=0.5,wdth=-0.5", ), pytest.param( {"wght": 1.0, "wdth": 0.0}, {"strs": 100, "undo": -200, "unds": 150, "hasc": 1100}, False, id="wght=1.0,wdth=0.0,no_sync_vmetrics", ), ], ) def test_full_instance(self, varfont, location, sync_vmetrics, expected): location = instancer.NormalizedAxisLimits(location) # check vertical metrics are in sync before... if sync_vmetrics: assert varfont["OS/2"].sTypoAscender == varfont["hhea"].ascender assert varfont["OS/2"].sTypoDescender == varfont["hhea"].descender assert varfont["OS/2"].sTypoLineGap == varfont["hhea"].lineGap else: # force them not to be in sync varfont["OS/2"].sTypoDescender -= 100 varfont["OS/2"].sTypoLineGap += 200 instancer.instantiateMVAR(varfont, location) for mvar_tag, expected_value in expected.items(): table_tag, item_name = MVAR_ENTRIES[mvar_tag] assert getattr(varfont[table_tag], item_name) == expected_value # ... as well as after instancing, but only if they were already # https://github.com/fonttools/fonttools/issues/3297 if sync_vmetrics: assert varfont["OS/2"].sTypoAscender == varfont["hhea"].ascender assert varfont["OS/2"].sTypoDescender == varfont["hhea"].descender assert varfont["OS/2"].sTypoLineGap == varfont["hhea"].lineGap else: assert varfont["OS/2"].sTypoDescender != varfont["hhea"].descender assert varfont["OS/2"].sTypoLineGap != varfont["hhea"].lineGap assert "MVAR" not in varfont class InstantiateHVARTest(object): # the 'expectedDeltas' below refer to the VarData item deltas for the "hyphen" # glyph in the PartialInstancerTest-VF.ttx test font, that are left after # partial instancing @pytest.mark.parametrize( "location, expectedRegions, expectedDeltas", [ ({"wght": -1.0}, [{"wdth": (-1.0, -1.0, 0)}], [-59]), ({"wght": 0}, [{"wdth": (-1.0, -1.0, 0)}], [-48]), ({"wght": 1.0}, [{"wdth": (-1.0, -1.0, 0)}], [7]), ( {"wdth": -1.0}, [ {"wght": (-1.0, -1.0, 0.0)}, {"wght": (0.0, 0.6099854, 1.0)}, {"wght": (0.6099854, 1.0, 1.0)}, ], [-11, 31, 51], ), ({"wdth": 0}, [{"wght": (0.6099854, 1.0, 1.0)}], [-4]), ], ) def test_partial_instance(self, varfont, location, expectedRegions, expectedDeltas): location = instancer.NormalizedAxisLimits(location) instancer.instantiateHVAR(varfont, location) assert "HVAR" in varfont hvar = varfont["HVAR"].table varStore = hvar.VarStore regions = varStore.VarRegionList.Region fvarAxes = [a for a in varfont["fvar"].axes if a.axisTag not in location] regionDicts = [reg.get_support(fvarAxes) for reg in regions] assert len(regionDicts) == len(expectedRegions) for region, expectedRegion in zip(regionDicts, expectedRegions): assert region.keys() == expectedRegion.keys() for axisTag, support in region.items(): assert support == pytest.approx(expectedRegion[axisTag]) assert len(varStore.VarData) == 1 assert varStore.VarData[0].ItemCount == 2 assert hvar.AdvWidthMap is not None advWithMap = hvar.AdvWidthMap.mapping assert advWithMap[".notdef"] == advWithMap["space"] varIdx = advWithMap[".notdef"] # these glyphs have no metrics variations in the test font assert varStore.VarData[varIdx >> 16].Item[varIdx & 0xFFFF] == ( [0] * varStore.VarData[0].VarRegionCount ) varIdx = advWithMap["hyphen"] assert varStore.VarData[varIdx >> 16].Item[varIdx & 0xFFFF] == expectedDeltas def test_full_instance(self, varfont): location = instancer.NormalizedAxisLimits(wght=0, wdth=0) instancer.instantiateHVAR(varfont, location) assert "HVAR" not in varfont def test_partial_instance_keep_empty_table(self, varfont): # Append an additional dummy axis to fvar, for which the current HVAR table # in our test 'varfont' contains no variation data. # Instancing the other two wght and wdth axes should leave HVAR table empty, # to signal there are variations to the glyph's advance widths. fvar = varfont["fvar"] axis = _f_v_a_r.Axis() axis.axisTag = "TEST" fvar.axes.append(axis) location = instancer.NormalizedAxisLimits(wght=0, wdth=0) instancer.instantiateHVAR(varfont, location) assert "HVAR" in varfont varStore = varfont["HVAR"].table.VarStore assert varStore.VarRegionList.RegionCount == 0 assert not varStore.VarRegionList.Region assert varStore.VarRegionList.RegionAxisCount == 1 class InstantiateItemVariationStoreTest(object): def test_VarRegion_get_support(self): axisOrder = ["wght", "wdth", "opsz"] regionAxes = {"wdth": (-1.0, -1.0, 0.0), "wght": (0.0, 1.0, 1.0)} region = builder.buildVarRegion(regionAxes, axisOrder) assert len(region.VarRegionAxis) == 3 assert region.VarRegionAxis[2].PeakCoord == 0 fvarAxes = [SimpleNamespace(axisTag=axisTag) for axisTag in axisOrder] assert region.get_support(fvarAxes) == regionAxes @pytest.fixture def varStore(self): return builder.buildVarStore( builder.buildVarRegionList( [ {"wght": (-1.0, -1.0, 0)}, {"wght": (0, 0.5, 1.0)}, {"wght": (0.5, 1.0, 1.0)}, {"wdth": (-1.0, -1.0, 0)}, {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0, 0.5, 1.0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0.5, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, ], ["wght", "wdth"], ), [ builder.buildVarData([0, 1, 2], [[100, 100, 100], [100, 100, 100]]), builder.buildVarData( [3, 4, 5, 6], [[100, 100, 100, 100], [100, 100, 100, 100]] ), ], ) @pytest.mark.parametrize( "location, expected_deltas, num_regions", [ ({"wght": 0}, [[0, 0], [0, 0]], 1), ({"wght": 0.25}, [[50, 50], [0, 0]], 1), ({"wdth": 0}, [[0, 0], [0, 0]], 3), ({"wdth": -0.75}, [[0, 0], [75, 75]], 3), ({"wght": 0, "wdth": 0}, [[0, 0], [0, 0]], 0), ({"wght": 0.25, "wdth": 0}, [[50, 50], [0, 0]], 0), ({"wght": 0, "wdth": -0.75}, [[0, 0], [75, 75]], 0), ], ) def test_instantiate_default_deltas( self, varStore, fvarAxes, location, expected_deltas, num_regions ): location = instancer.NormalizedAxisLimits(location) defaultDeltas = instancer.instantiateItemVariationStore( varStore, fvarAxes, location ) defaultDeltaArray = [] for varidx, delta in sorted(defaultDeltas.items()): if varidx == varStore.NO_VARIATION_INDEX: continue major, minor = varidx >> 16, varidx & 0xFFFF if major == len(defaultDeltaArray): defaultDeltaArray.append([]) assert len(defaultDeltaArray[major]) == minor defaultDeltaArray[major].append(delta) assert defaultDeltaArray == expected_deltas assert varStore.VarRegionList.RegionCount == num_regions class TupleVarStoreAdapterTest(object): def test_instantiate(self): regions = [ {"wght": (-1.0, -1.0, 0)}, {"wght": (0.0, 1.0, 1.0)}, {"wdth": (-1.0, -1.0, 0)}, {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, ] axisOrder = ["wght", "wdth"] tupleVarData = [ [ TupleVariation({"wght": (-1.0, -1.0, 0)}, [10, 70]), TupleVariation({"wght": (0.0, 1.0, 1.0)}, [30, 90]), TupleVariation( {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, [-40, -100] ), TupleVariation( {"wght": (0, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, [-60, -120] ), ], [ TupleVariation({"wdth": (-1.0, -1.0, 0)}, [5, 45]), TupleVariation( {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, [-15, -55] ), TupleVariation( {"wght": (0, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, [-35, -75] ), ], ] adapter = instancer._TupleVarStoreAdapter( regions, axisOrder, tupleVarData, itemCounts=[2, 2] ) location = instancer.NormalizedAxisLimits(wght=0.5) defaultDeltaArray = adapter.instantiate(location) assert defaultDeltaArray == [[15, 45], [0, 0]] assert adapter.regions == [{"wdth": (-1.0, -1.0, 0)}] assert adapter.tupleVarData == [ [TupleVariation({"wdth": (-1.0, -1.0, 0)}, [-30, -60])], [TupleVariation({"wdth": (-1.0, -1.0, 0)}, [-12, 8])], ] def test_rebuildRegions(self): regions = [ {"wght": (-1.0, -1.0, 0)}, {"wght": (0.0, 1.0, 1.0)}, {"wdth": (-1.0, -1.0, 0)}, {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, ] axisOrder = ["wght", "wdth"] variations = [] for region in regions: variations.append(TupleVariation(region, [100])) tupleVarData = [variations[:3], variations[3:]] adapter = instancer._TupleVarStoreAdapter( regions, axisOrder, tupleVarData, itemCounts=[1, 1] ) adapter.rebuildRegions() assert adapter.regions == regions del tupleVarData[0][2] tupleVarData[1][0].axes = {"wght": (-1.0, -0.5, 0)} tupleVarData[1][1].axes = {"wght": (0, 0.5, 1.0)} adapter.rebuildRegions() assert adapter.regions == [ {"wght": (-1.0, -1.0, 0)}, {"wght": (0.0, 1.0, 1.0)}, {"wght": (-1.0, -0.5, 0)}, {"wght": (0, 0.5, 1.0)}, ] def test_roundtrip(self, fvarAxes): regions = [ {"wght": (-1.0, -1.0, 0)}, {"wght": (0, 0.5, 1.0)}, {"wght": (0.5, 1.0, 1.0)}, {"wdth": (-1.0, -1.0, 0)}, {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0, 0.5, 1.0), "wdth": (-1.0, -1.0, 0)}, {"wght": (0.5, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, ] axisOrder = [axis.axisTag for axis in fvarAxes] itemVarStore = builder.buildVarStore( builder.buildVarRegionList(regions, axisOrder), [ builder.buildVarData( [0, 1, 2, 4, 5, 6], [[10, -20, 30, -40, 50, -60], [70, -80, 90, -100, 110, -120]], ), builder.buildVarData( [3, 4, 5, 6], [[5, -15, 25, -35], [45, -55, 65, -75]] ), ], ) adapter = instancer._TupleVarStoreAdapter.fromItemVarStore( itemVarStore, fvarAxes ) assert adapter.tupleVarData == [ [ TupleVariation({"wght": (-1.0, -1.0, 0)}, [10, 70]), TupleVariation({"wght": (0, 0.5, 1.0)}, [-20, -80]), TupleVariation({"wght": (0.5, 1.0, 1.0)}, [30, 90]), TupleVariation( {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, [-40, -100] ), TupleVariation( {"wght": (0, 0.5, 1.0), "wdth": (-1.0, -1.0, 0)}, [50, 110] ), TupleVariation( {"wght": (0.5, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, [-60, -120] ), ], [ TupleVariation({"wdth": (-1.0, -1.0, 0)}, [5, 45]), TupleVariation( {"wght": (-1.0, -1.0, 0), "wdth": (-1.0, -1.0, 0)}, [-15, -55] ), TupleVariation( {"wght": (0, 0.5, 1.0), "wdth": (-1.0, -1.0, 0)}, [25, 65] ), TupleVariation( {"wght": (0.5, 1.0, 1.0), "wdth": (-1.0, -1.0, 0)}, [-35, -75] ), ], ] assert adapter.itemCounts == [data.ItemCount for data in itemVarStore.VarData] assert adapter.regions == regions assert adapter.axisOrder == axisOrder itemVarStore2 = adapter.asItemVarStore() assert [ reg.get_support(fvarAxes) for reg in itemVarStore2.VarRegionList.Region ] == regions assert itemVarStore2.VarDataCount == 2 assert itemVarStore2.VarData[0].VarRegionIndex == [0, 1, 2, 4, 5, 6] assert itemVarStore2.VarData[0].Item == [ [10, -20, 30, -40, 50, -60], [70, -80, 90, -100, 110, -120], ] assert itemVarStore2.VarData[1].VarRegionIndex == [3, 4, 5, 6] assert itemVarStore2.VarData[1].Item == [[5, -15, 25, -35], [45, -55, 65, -75]] def makeTTFont(glyphOrder, features): font = ttLib.TTFont() font.setGlyphOrder(glyphOrder) addOpenTypeFeaturesFromString(font, features) font["name"] = ttLib.newTable("name") return font def _makeDSAxesDict(axes): dsAxes = collections.OrderedDict() for axisTag, axisValues in axes: axis = designspaceLib.AxisDescriptor() axis.name = axis.tag = axis.labelNames["en"] = axisTag axis.minimum, axis.default, axis.maximum = axisValues dsAxes[axis.tag] = axis return dsAxes def makeVariableFont(masters, baseIndex, axes, masterLocations): vf = deepcopy(masters[baseIndex]) dsAxes = _makeDSAxesDict(axes) fvar = varLib._add_fvar(vf, dsAxes, instances=()) axisTags = [axis.axisTag for axis in fvar.axes] normalizedLocs = [models.normalizeLocation(m, dict(axes)) for m in masterLocations] model = models.VariationModel(normalizedLocs, axisOrder=axisTags) varLib._merge_OTL(vf, model, masters, axisTags) return vf def makeParametrizedVF(glyphOrder, features, values, increments): # Create a test VF with given glyphs and parametrized OTL features. # The VF is built from 9 masters (3 x 3 along wght and wdth), with # locations hard-coded and base master at wght=400 and wdth=100. # 'values' is a list of initial values that are interpolated in the # 'features' string, and incremented for each subsequent master by the # given 'increments' (list of 2-tuple) along the two axes. assert values and len(values) == len(increments) assert all(len(i) == 2 for i in increments) masterLocations = [ {"wght": 100, "wdth": 50}, {"wght": 100, "wdth": 100}, {"wght": 100, "wdth": 150}, {"wght": 400, "wdth": 50}, {"wght": 400, "wdth": 100}, # base master {"wght": 400, "wdth": 150}, {"wght": 700, "wdth": 50}, {"wght": 700, "wdth": 100}, {"wght": 700, "wdth": 150}, ] n = len(values) values = list(values) masters = [] for _ in range(3): for _ in range(3): master = makeTTFont(glyphOrder, features=features % tuple(values)) masters.append(master) for i in range(n): values[i] += increments[i][1] for i in range(n): values[i] += increments[i][0] baseIndex = 4 axes = [("wght", (100, 400, 700)), ("wdth", (50, 100, 150))] vf = makeVariableFont(masters, baseIndex, axes, masterLocations) return vf @pytest.fixture def varfontGDEF(): glyphOrder = [".notdef", "f", "i", "f_i"] features = ( "feature liga { sub f i by f_i;} liga;" "table GDEF { LigatureCaretByPos f_i %d; } GDEF;" ) values = [100] increments = [(+30, +10)] return makeParametrizedVF(glyphOrder, features, values, increments) @pytest.fixture def varfontGPOS(): glyphOrder = [".notdef", "V", "A"] features = "feature kern { pos V A %d; } kern;" values = [-80] increments = [(-10, -5)] return makeParametrizedVF(glyphOrder, features, values, increments) @pytest.fixture def varfontGPOS2(): glyphOrder = [".notdef", "V", "A", "acutecomb"] features = ( "markClass [acutecomb] @TOP_MARKS;" "feature mark {" " pos base A mark @TOP_MARKS;" "} mark;" "feature kern {" " pos V A %d;" "} kern;" ) values = [200, -80] increments = [(+30, +10), (-10, -5)] return makeParametrizedVF(glyphOrder, features, values, increments) class InstantiateOTLTest(object): @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0}, 110), # -60 ({"wght": 0}, 170), ({"wght": 0.5}, 200), # +30 ({"wght": 1.0}, 230), # +60 ({"wdth": -1.0}, 160), # -10 ({"wdth": -0.3}, 167), # -3 ({"wdth": 0}, 170), ({"wdth": 1.0}, 180), # +10 ], ) def test_pin_and_drop_axis_GDEF(self, varfontGDEF, location, expected): vf = varfontGDEF assert "GDEF" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) assert "GDEF" in vf gdef = vf["GDEF"].table assert gdef.Version == 0x00010003 assert gdef.VarStore assert gdef.LigCaretList caretValue = gdef.LigCaretList.LigGlyph[0].CaretValue[0] assert caretValue.Format == 3 assert hasattr(caretValue, "DeviceTable") assert caretValue.DeviceTable.DeltaFormat == 0x8000 assert caretValue.Coordinate == expected @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0, "wdth": -1.0}, 100), # -60 - 10 ({"wght": -1.0, "wdth": 0.0}, 110), # -60 ({"wght": -1.0, "wdth": 1.0}, 120), # -60 + 10 ({"wght": 0.0, "wdth": -1.0}, 160), # -10 ({"wght": 0.0, "wdth": 0.0}, 170), ({"wght": 0.0, "wdth": 1.0}, 180), # +10 ({"wght": 1.0, "wdth": -1.0}, 220), # +60 - 10 ({"wght": 1.0, "wdth": 0.0}, 230), # +60 ({"wght": 1.0, "wdth": 1.0}, 240), # +60 + 10 ], ) def test_full_instance_GDEF(self, varfontGDEF, location, expected): vf = varfontGDEF assert "GDEF" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) assert "GDEF" in vf gdef = vf["GDEF"].table assert gdef.Version == 0x00010000 assert not hasattr(gdef, "VarStore") assert gdef.LigCaretList caretValue = gdef.LigCaretList.LigGlyph[0].CaretValue[0] assert caretValue.Format == 1 assert not hasattr(caretValue, "DeviceTable") assert caretValue.Coordinate == expected @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0}, -85), # +25 ({"wght": 0}, -110), ({"wght": 1.0}, -135), # -25 ({"wdth": -1.0}, -105), # +5 ({"wdth": 0}, -110), ({"wdth": 1.0}, -115), # -5 ], ) def test_pin_and_drop_axis_GPOS_kern(self, varfontGPOS, location, expected): vf = varfontGPOS assert "GDEF" in vf assert "GPOS" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) gdef = vf["GDEF"].table gpos = vf["GPOS"].table assert gdef.Version == 0x00010003 assert gdef.VarStore assert gpos.LookupList.Lookup[0].LookupType == 2 # PairPos pairPos = gpos.LookupList.Lookup[0].SubTable[0] valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert valueRec1.XAdvDevice assert valueRec1.XAdvDevice.DeltaFormat == 0x8000 assert valueRec1.XAdvance == expected @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0, "wdth": -1.0}, -80), # +25 + 5 ({"wght": -1.0, "wdth": 0.0}, -85), # +25 ({"wght": -1.0, "wdth": 1.0}, -90), # +25 - 5 ({"wght": 0.0, "wdth": -1.0}, -105), # +5 ({"wght": 0.0, "wdth": 0.0}, -110), ({"wght": 0.0, "wdth": 1.0}, -115), # -5 ({"wght": 1.0, "wdth": -1.0}, -130), # -25 + 5 ({"wght": 1.0, "wdth": 0.0}, -135), # -25 ({"wght": 1.0, "wdth": 1.0}, -140), # -25 - 5 ], ) def test_full_instance_GPOS_kern(self, varfontGPOS, location, expected): vf = varfontGPOS assert "GDEF" in vf assert "GPOS" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) assert "GDEF" not in vf gpos = vf["GPOS"].table assert gpos.LookupList.Lookup[0].LookupType == 2 # PairPos pairPos = gpos.LookupList.Lookup[0].SubTable[0] valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert not hasattr(valueRec1, "XAdvDevice") assert valueRec1.XAdvance == expected @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0}, (210, -85)), # -60, +25 ({"wght": 0}, (270, -110)), ({"wght": 0.5}, (300, -122)), # +30, -12 ({"wght": 1.0}, (330, -135)), # +60, -25 ({"wdth": -1.0}, (260, -105)), # -10, +5 ({"wdth": -0.3}, (267, -108)), # -3, +2 ({"wdth": 0}, (270, -110)), ({"wdth": 1.0}, (280, -115)), # +10, -5 ], ) def test_pin_and_drop_axis_GPOS_mark_and_kern( self, varfontGPOS2, location, expected ): vf = varfontGPOS2 assert "GDEF" in vf assert "GPOS" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) v1, v2 = expected gdef = vf["GDEF"].table gpos = vf["GPOS"].table assert gdef.Version == 0x00010003 assert gdef.VarStore assert gdef.GlyphClassDef assert gpos.LookupList.Lookup[0].LookupType == 4 # MarkBasePos markBasePos = gpos.LookupList.Lookup[0].SubTable[0] baseAnchor = markBasePos.BaseArray.BaseRecord[0].BaseAnchor[0] assert baseAnchor.Format == 3 assert baseAnchor.XDeviceTable assert baseAnchor.XDeviceTable.DeltaFormat == 0x8000 assert not baseAnchor.YDeviceTable assert baseAnchor.XCoordinate == v1 assert baseAnchor.YCoordinate == 450 assert gpos.LookupList.Lookup[1].LookupType == 2 # PairPos pairPos = gpos.LookupList.Lookup[1].SubTable[0] valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert valueRec1.XAdvDevice assert valueRec1.XAdvDevice.DeltaFormat == 0x8000 assert valueRec1.XAdvance == v2 @pytest.mark.parametrize( "location, expected", [ ({"wght": -1.0, "wdth": -1.0}, (200, -80)), # -60 - 10, +25 + 5 ({"wght": -1.0, "wdth": 0.0}, (210, -85)), # -60, +25 ({"wght": -1.0, "wdth": 1.0}, (220, -90)), # -60 + 10, +25 - 5 ({"wght": 0.0, "wdth": -1.0}, (260, -105)), # -10, +5 ({"wght": 0.0, "wdth": 0.0}, (270, -110)), ({"wght": 0.0, "wdth": 1.0}, (280, -115)), # +10, -5 ({"wght": 1.0, "wdth": -1.0}, (320, -130)), # +60 - 10, -25 + 5 ({"wght": 1.0, "wdth": 0.0}, (330, -135)), # +60, -25 ({"wght": 1.0, "wdth": 1.0}, (340, -140)), # +60 + 10, -25 - 5 ], ) def test_full_instance_GPOS_mark_and_kern(self, varfontGPOS2, location, expected): vf = varfontGPOS2 assert "GDEF" in vf assert "GPOS" in vf location = instancer.NormalizedAxisLimits(location) instancer.instantiateOTL(vf, location) v1, v2 = expected gdef = vf["GDEF"].table gpos = vf["GPOS"].table assert gdef.Version == 0x00010000 assert not hasattr(gdef, "VarStore") assert gdef.GlyphClassDef assert gpos.LookupList.Lookup[0].LookupType == 4 # MarkBasePos markBasePos = gpos.LookupList.Lookup[0].SubTable[0] baseAnchor = markBasePos.BaseArray.BaseRecord[0].BaseAnchor[0] assert baseAnchor.Format == 1 assert not hasattr(baseAnchor, "XDeviceTable") assert not hasattr(baseAnchor, "YDeviceTable") assert baseAnchor.XCoordinate == v1 assert baseAnchor.YCoordinate == 450 assert gpos.LookupList.Lookup[1].LookupType == 2 # PairPos pairPos = gpos.LookupList.Lookup[1].SubTable[0] valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert not hasattr(valueRec1, "XAdvDevice") assert valueRec1.XAdvance == v2 def test_GPOS_ValueRecord_XAdvDevice_wtihout_XAdvance(self): # Test VF contains a PairPos adjustment in which the default instance # has no XAdvance but there are deltas in XAdvDevice (VariationIndex). vf = ttLib.TTFont() vf.importXML(os.path.join(TESTDATA, "PartialInstancerTest4-VF.ttx")) pairPos = vf["GPOS"].table.LookupList.Lookup[0].SubTable[0] assert pairPos.ValueFormat1 == 0x40 valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert not hasattr(valueRec1, "XAdvance") assert valueRec1.XAdvDevice.DeltaFormat == 0x8000 outer = valueRec1.XAdvDevice.StartSize inner = valueRec1.XAdvDevice.EndSize assert vf["GDEF"].table.VarStore.VarData[outer].Item[inner] == [-50] # check that MutatorMerger for ValueRecord doesn't raise AttributeError # when XAdvDevice is present but there's no corresponding XAdvance. instancer.instantiateOTL(vf, instancer.NormalizedAxisLimits(wght=0.5)) pairPos = vf["GPOS"].table.LookupList.Lookup[0].SubTable[0] assert pairPos.ValueFormat1 == 0x4 valueRec1 = pairPos.PairSet[0].PairValueRecord[0].Value1 assert not hasattr(valueRec1, "XAdvDevice") assert valueRec1.XAdvance == -25 class InstantiateAvarTest(object): @pytest.mark.parametrize("location", [{"wght": 0.0}, {"wdth": 0.0}]) def test_pin_and_drop_axis(self, varfont, location): location = instancer.AxisLimits(location) instancer.instantiateAvar(varfont, location) assert set(varfont["avar"].segments).isdisjoint(location) def test_full_instance(self, varfont): location = instancer.AxisLimits(wght=0.0, wdth=0.0) instancer.instantiateAvar(varfont, location) assert "avar" not in varfont @staticmethod def quantizeF2Dot14Floats(mapping): return { floatToFixedToFloat(k, 14): floatToFixedToFloat(v, 14) for k, v in mapping.items() } # the following values come from NotoSans-VF.ttf DFLT_WGHT_MAPPING = { -1.0: -1.0, -0.6667: -0.7969, -0.3333: -0.5, 0: 0, 0.2: 0.18, 0.4: 0.38, 0.6: 0.61, 0.8: 0.79, 1.0: 1.0, } DFLT_WDTH_MAPPING = {-1.0: -1.0, -0.6667: -0.7, -0.3333: -0.36664, 0: 0, 1.0: 1.0} @pytest.fixture def varfont(self): fvarAxes = ("wght", (100, 400, 900)), ("wdth", (62.5, 100, 100)) avarSegments = { "wght": self.quantizeF2Dot14Floats(self.DFLT_WGHT_MAPPING), "wdth": self.quantizeF2Dot14Floats(self.DFLT_WDTH_MAPPING), } varfont = ttLib.TTFont() varfont["name"] = ttLib.newTable("name") varLib._add_fvar(varfont, _makeDSAxesDict(fvarAxes), instances=()) avar = varfont["avar"] = ttLib.newTable("avar") avar.segments = avarSegments return varfont @pytest.mark.parametrize( "axisLimits, expectedSegments", [ pytest.param( {"wght": (100, 900)}, {"wght": DFLT_WGHT_MAPPING, "wdth": DFLT_WDTH_MAPPING}, id="wght=100:900", ), pytest.param( {"wght": (400, 900)}, { "wght": { -1.0: -1.0, 0: 0, 0.2: 0.18, 0.4: 0.38, 0.6: 0.61, 0.8: 0.79, 1.0: 1.0, }, "wdth": DFLT_WDTH_MAPPING, }, id="wght=400:900", ), pytest.param( {"wght": (100, 400)}, { "wght": { -1.0: -1.0, -0.6667: -0.7969, -0.3333: -0.5, 0: 0, 1.0: 1.0, }, "wdth": DFLT_WDTH_MAPPING, }, id="wght=100:400", ), pytest.param( {"wght": (400, 800)}, { "wght": { -1.0: -1.0, 0: 0, 0.25: 0.22784, 0.50006: 0.48103, 0.75: 0.77214, 1.0: 1.0, }, "wdth": DFLT_WDTH_MAPPING, }, id="wght=400:800", ), pytest.param( {"wght": (400, 700)}, { "wght": { -1.0: -1.0, 0: 0, 0.3334: 0.2951, 0.66675: 0.623, 1.0: 1.0, }, "wdth": DFLT_WDTH_MAPPING, }, id="wght=400:700", ), pytest.param( {"wght": (400, 600)}, { "wght": {-1.0: -1.0, 0: 0, 0.5: 0.47363, 1.0: 1.0}, "wdth": DFLT_WDTH_MAPPING, }, id="wght=400:600", ), pytest.param( {"wdth": (62.5, 100)}, { "wght": DFLT_WGHT_MAPPING, "wdth": { -1.0: -1.0, -0.6667: -0.7, -0.3333: -0.36664, 0: 0, 1.0: 1.0, }, }, id="wdth=62.5:100", ), pytest.param( {"wdth": (70, 100)}, { "wght": DFLT_WGHT_MAPPING, "wdth": { -1.0: -1.0, -0.8334: -0.85364, -0.4166: -0.44714, 0: 0, 1.0: 1.0, }, }, id="wdth=70:100", ), pytest.param( {"wdth": (75, 100)}, { "wght": DFLT_WGHT_MAPPING, "wdth": {-1.0: -1.0, -0.49994: -0.52374, 0: 0, 1.0: 1.0}, }, id="wdth=75:100", ), pytest.param( {"wdth": (77, 100)}, { "wght": DFLT_WGHT_MAPPING, "wdth": {-1.0: -1.0, -0.54346: -0.56696, 0: 0, 1.0: 1.0}, }, id="wdth=77:100", ), pytest.param( {"wdth": (87.5, 100)}, {"wght": DFLT_WGHT_MAPPING, "wdth": {-1.0: -1.0, 0: 0, 1.0: 1.0}}, id="wdth=87.5:100", ), ], ) def test_limit_axes(self, varfont, axisLimits, expectedSegments): axisLimits = instancer.AxisLimits(axisLimits) instancer.instantiateAvar(varfont, axisLimits) newSegments = varfont["avar"].segments expectedSegments = { axisTag: self.quantizeF2Dot14Floats(mapping) for axisTag, mapping in expectedSegments.items() } assert newSegments == expectedSegments @pytest.mark.parametrize( "invalidSegmentMap", [ pytest.param({0.5: 0.5}, id="missing-required-maps-1"), pytest.param({-1.0: -1.0, 1.0: 1.0}, id="missing-required-maps-2"), pytest.param( {-1.0: -1.0, 0: 0, 0.5: 0.5, 0.6: 0.4, 1.0: 1.0}, id="retrograde-value-maps", ), ], ) def test_drop_invalid_segment_map(self, varfont, invalidSegmentMap, caplog): varfont["avar"].segments["wght"] = invalidSegmentMap axisLimits = instancer.AxisLimits(wght=(100, 400)) with caplog.at_level(logging.WARNING, logger="fontTools.varLib.instancer"): instancer.instantiateAvar(varfont, axisLimits) assert "Invalid avar" in caplog.text assert "wght" not in varfont["avar"].segments def test_isValidAvarSegmentMap(self): assert instancer._isValidAvarSegmentMap("FOOO", {}) assert instancer._isValidAvarSegmentMap("FOOO", {-1.0: -1.0, 0: 0, 1.0: 1.0}) assert instancer._isValidAvarSegmentMap( "FOOO", {-1.0: -1.0, 0: 0, 0.5: 0.5, 1.0: 1.0} ) assert instancer._isValidAvarSegmentMap( "FOOO", {-1.0: -1.0, 0: 0, 0.5: 0.5, 0.7: 0.5, 1.0: 1.0} ) class InstantiateFvarTest(object): @pytest.mark.parametrize( "location, instancesLeft", [ ( {"wght": 400.0}, ["Regular", "SemiCondensed", "Condensed", "ExtraCondensed"], ), ( {"wght": 100.0}, ["Thin", "SemiCondensed Thin", "Condensed Thin", "ExtraCondensed Thin"], ), ( {"wdth": 100.0}, [ "Thin", "ExtraLight", "Light", "Regular", "Medium", "SemiBold", "Bold", "ExtraBold", "Black", ], ), # no named instance at pinned location ({"wdth": 90.0}, []), ], ) def test_pin_and_drop_axis(self, varfont, location, instancesLeft): location = instancer.AxisLimits(location) instancer.instantiateFvar(varfont, location) fvar = varfont["fvar"] assert {a.axisTag for a in fvar.axes}.isdisjoint(location) for instance in fvar.instances: assert set(instance.coordinates).isdisjoint(location) name = varfont["name"] assert [ name.getDebugName(instance.subfamilyNameID) for instance in fvar.instances ] == instancesLeft def test_full_instance(self, varfont): location = instancer.AxisLimits({"wght": 0.0, "wdth": 0.0}) instancer.instantiateFvar(varfont, location) assert "fvar" not in varfont @pytest.mark.parametrize( "location, expected", [ ({"wght": (30, 40, 700)}, (100, 100, 700)), ({"wght": (30, 40, None)}, (100, 100, 900)), ({"wght": (30, None, 700)}, (100, 400, 700)), ({"wght": (None, 200, 700)}, (100, 200, 700)), ({"wght": (40, None, None)}, (100, 400, 900)), ({"wght": (None, 40, None)}, (100, 100, 900)), ({"wght": (None, None, 700)}, (100, 400, 700)), ({"wght": (None, None, None)}, (100, 400, 900)), ], ) def test_axis_limits(self, varfont, location, expected): location = instancer.AxisLimits(location) varfont = instancer.instantiateVariableFont(varfont, location) fvar = varfont["fvar"] axes = {a.axisTag: a for a in fvar.axes} assert axes["wght"].minValue == expected[0] assert axes["wght"].defaultValue == expected[1] assert axes["wght"].maxValue == expected[2] class InstantiateSTATTest(object): @pytest.mark.parametrize( "location, expected", [ ({"wght": 400}, ["Regular", "Condensed", "Upright", "Normal"]), ( {"wdth": 100}, ["Thin", "Regular", "Medium", "Black", "Upright", "Normal"], ), ], ) def test_pin_and_drop_axis(self, varfont, location, expected): location = instancer.AxisLimits(location) instancer.instantiateSTAT(varfont, location) stat = varfont["STAT"].table designAxes = {a.AxisTag for a in stat.DesignAxisRecord.Axis} assert designAxes == {"wght", "wdth", "ital"} name = varfont["name"] valueNames = [] for axisValueTable in stat.AxisValueArray.AxisValue: valueName = name.getDebugName(axisValueTable.ValueNameID) valueNames.append(valueName) assert valueNames == expected def test_skip_table_no_axis_value_array(self, varfont): varfont["STAT"].table.AxisValueArray = None instancer.instantiateSTAT(varfont, instancer.AxisLimits(wght=100)) assert len(varfont["STAT"].table.DesignAxisRecord.Axis) == 3 assert varfont["STAT"].table.AxisValueArray is None def test_skip_table_axis_value_array_empty(self, varfont): varfont["STAT"].table.AxisValueArray.AxisValue = [] instancer.instantiateSTAT(varfont, {"wght": 100}) assert len(varfont["STAT"].table.DesignAxisRecord.Axis) == 3 assert not varfont["STAT"].table.AxisValueArray.AxisValue def test_skip_table_no_design_axes(self, varfont): stat = otTables.STAT() stat.Version = 0x00010001 stat.populateDefaults() assert not stat.DesignAxisRecord assert not stat.AxisValueArray varfont["STAT"].table = stat instancer.instantiateSTAT(varfont, {"wght": 100}) assert not varfont["STAT"].table.DesignAxisRecord @staticmethod def get_STAT_axis_values(stat): axes = stat.DesignAxisRecord.Axis result = [] for axisValue in stat.AxisValueArray.AxisValue: if axisValue.Format == 1: result.append((axes[axisValue.AxisIndex].AxisTag, axisValue.Value)) elif axisValue.Format == 3: result.append( ( axes[axisValue.AxisIndex].AxisTag, (axisValue.Value, axisValue.LinkedValue), ) ) elif axisValue.Format == 2: result.append( ( axes[axisValue.AxisIndex].AxisTag, ( axisValue.RangeMinValue, axisValue.NominalValue, axisValue.RangeMaxValue, ), ) ) elif axisValue.Format == 4: result.append( tuple( (axes[rec.AxisIndex].AxisTag, rec.Value) for rec in axisValue.AxisValueRecord ) ) else: raise AssertionError(axisValue.Format) return result def test_limit_axes(self, varfont2): axisLimits = instancer.AxisLimits({"wght": (400, 500), "wdth": (75, 100)}) instancer.instantiateSTAT(varfont2, axisLimits) assert len(varfont2["STAT"].table.AxisValueArray.AxisValue) == 5 assert self.get_STAT_axis_values(varfont2["STAT"].table) == [ ("wght", (400.0, 700.0)), ("wght", 500.0), ("wdth", (93.75, 100.0, 100.0)), ("wdth", (81.25, 87.5, 93.75)), ("wdth", (68.75, 75.0, 81.25)), ] def test_limit_axis_value_format_4(self, varfont2): stat = varfont2["STAT"].table axisValue = otTables.AxisValue() axisValue.Format = 4 axisValue.AxisValueRecord = [] for tag, value in (("wght", 575), ("wdth", 90)): rec = otTables.AxisValueRecord() rec.AxisIndex = next( i for i, a in enumerate(stat.DesignAxisRecord.Axis) if a.AxisTag == tag ) rec.Value = value axisValue.AxisValueRecord.append(rec) stat.AxisValueArray.AxisValue.append(axisValue) instancer.instantiateSTAT(varfont2, instancer.AxisLimits(wght=(100, 600))) assert axisValue in varfont2["STAT"].table.AxisValueArray.AxisValue instancer.instantiateSTAT(varfont2, instancer.AxisLimits(wdth=(62.5, 87.5))) assert axisValue not in varfont2["STAT"].table.AxisValueArray.AxisValue def test_unknown_axis_value_format(self, varfont2, caplog): stat = varfont2["STAT"].table axisValue = otTables.AxisValue() axisValue.Format = 5 stat.AxisValueArray.AxisValue.append(axisValue) with caplog.at_level(logging.WARNING, logger="fontTools.varLib.instancer"): instancer.instantiateSTAT(varfont2, instancer.AxisLimits(wght=400)) assert "Unknown AxisValue table format (5)" in caplog.text assert axisValue in varfont2["STAT"].table.AxisValueArray.AxisValue def test_setMacOverlapFlags(): flagOverlapCompound = _g_l_y_f.OVERLAP_COMPOUND flagOverlapSimple = _g_l_y_f.flagOverlapSimple glyf = ttLib.newTable("glyf") glyf.glyphOrder = ["a", "b", "c"] a = _g_l_y_f.Glyph() a.numberOfContours = 1 a.flags = [0] b = _g_l_y_f.Glyph() b.numberOfContours = -1 comp = _g_l_y_f.GlyphComponent() comp.flags = 0 b.components = [comp] c = _g_l_y_f.Glyph() c.numberOfContours = 0 glyf.glyphs = {"a": a, "b": b, "c": c} instancer.setMacOverlapFlags(glyf) assert a.flags[0] & flagOverlapSimple != 0 assert b.components[0].flags & flagOverlapCompound != 0 @pytest.fixture def varfont2(): f = ttLib.TTFont(recalcTimestamp=False) f.importXML(os.path.join(TESTDATA, "PartialInstancerTest2-VF.ttx")) return f @pytest.fixture def varfont3(): f = ttLib.TTFont(recalcTimestamp=False) f.importXML(os.path.join(TESTDATA, "PartialInstancerTest3-VF.ttx")) return f def _dump_ttx(ttFont): # compile to temporary bytes stream, reload and dump to XML tmp = BytesIO() ttFont.save(tmp) tmp.seek(0) ttFont2 = ttLib.TTFont(tmp, recalcBBoxes=False, recalcTimestamp=False) s = StringIO() ttFont2.saveXML(s) return stripVariableItemsFromTTX(s.getvalue()) def _get_expected_instance_ttx( name, *locations, overlap=instancer.OverlapMode.KEEP_AND_SET_FLAGS ): filename = f"{name}-VF-instance-{','.join(str(loc) for loc in locations)}" if overlap == instancer.OverlapMode.KEEP_AND_DONT_SET_FLAGS: filename += "-no-overlap-flags" elif overlap == instancer.OverlapMode.REMOVE: filename += "-no-overlaps" with open( os.path.join(TESTDATA, "test_results", f"{filename}.ttx"), "r", encoding="utf-8", ) as fp: return stripVariableItemsFromTTX(fp.read()) class InstantiateVariableFontTest(object): @pytest.mark.parametrize( "wght, wdth", [(100, 100), (400, 100), (900, 100), (100, 62.5), (400, 62.5), (900, 62.5)], ) def test_multiple_instancing(self, varfont2, wght, wdth): partial = instancer.instantiateVariableFont(varfont2, {"wght": wght}) instance = instancer.instantiateVariableFont(partial, {"wdth": wdth}) expected = _get_expected_instance_ttx("PartialInstancerTest2", wght, wdth) assert _dump_ttx(instance) == expected def test_default_instance(self, varfont2): instance = instancer.instantiateVariableFont( varfont2, {"wght": None, "wdth": None} ) expected = _get_expected_instance_ttx("PartialInstancerTest2", 400, 100) assert _dump_ttx(instance) == expected def test_move_weight_width_axis_default(self, varfont2): # https://github.com/fonttools/fonttools/issues/2885 assert varfont2["OS/2"].usWeightClass == 400 assert varfont2["OS/2"].usWidthClass == 5 varfont = instancer.instantiateVariableFont( varfont2, {"wght": (100, 500, 900), "wdth": 87.5} ) assert varfont["OS/2"].usWeightClass == 500 assert varfont["OS/2"].usWidthClass == 4 @pytest.mark.parametrize( "overlap, wght", [ (instancer.OverlapMode.KEEP_AND_DONT_SET_FLAGS, 400), (instancer.OverlapMode.REMOVE, 400), (instancer.OverlapMode.REMOVE, 700), ], ) def test_overlap(self, varfont3, wght, overlap): pytest.importorskip("pathops") location = {"wght": wght} instance = instancer.instantiateVariableFont( varfont3, location, overlap=overlap ) expected = _get_expected_instance_ttx( "PartialInstancerTest3", wght, overlap=overlap ) assert _dump_ttx(instance) == expected def test_singlepos(self): varfont = ttLib.TTFont(recalcTimestamp=False) varfont.importXML(os.path.join(TESTDATA, "SinglePos.ttx")) location = {"wght": 280, "opsz": 18} instance = instancer.instantiateVariableFont( varfont, location, ) expected = _get_expected_instance_ttx("SinglePos", *location.values()) assert _dump_ttx(instance) == expected def test_varComposite(self): input_path = os.path.join( TESTDATA, "..", "..", "..", "ttLib", "data", "varc-ac00-ac01.ttf" ) varfont = ttLib.TTFont(input_path) location = {"wght": 600} instance = instancer.instantiateVariableFont( varfont, location, ) location = {"0000": 0.5} instance = instancer.instantiateVariableFont( varfont, location, ) def _conditionSetAsDict(conditionSet, axisOrder): result = {} conditionSets = conditionSet.ConditionTable if conditionSet is not None else [] for cond in conditionSets: assert cond.Format == 1 axisTag = axisOrder[cond.AxisIndex] result[axisTag] = (cond.FilterRangeMinValue, cond.FilterRangeMaxValue) return result def _getSubstitutions(gsub, lookupIndices): subs = {} for index, lookup in enumerate(gsub.LookupList.Lookup): if index in lookupIndices: for subtable in lookup.SubTable: subs.update(subtable.mapping) return subs def makeFeatureVarsFont(conditionalSubstitutions): axes = set() glyphs = set() for region, substitutions in conditionalSubstitutions: for box in region: axes.update(box.keys()) glyphs.update(*substitutions.items()) varfont = ttLib.TTFont() varfont.setGlyphOrder(sorted(glyphs)) fvar = varfont["fvar"] = ttLib.newTable("fvar") fvar.axes = [] for axisTag in sorted(axes): axis = _f_v_a_r.Axis() axis.axisTag = Tag(axisTag) fvar.axes.append(axis) featureVars.addFeatureVariations(varfont, conditionalSubstitutions) return varfont class InstantiateFeatureVariationsTest(object): @pytest.mark.parametrize( "location, appliedSubs, expectedRecords", [ ({"wght": 0}, {}, [({"cntr": (0.75, 1.0)}, {"uni0041": "uni0061"})]), ( {"wght": -1.0}, {"uni0061": "uni0041"}, [ ({"cntr": (0, 0.25)}, {"uni0061": "uni0041"}), ({"cntr": (0.75, 1.0)}, {"uni0041": "uni0061"}), ({}, {}), ], ), ( {"wght": 1.0}, {"uni0024": "uni0024.nostroke"}, [ ( {"cntr": (0.75, 1.0)}, {"uni0024": "uni0024.nostroke", "uni0041": "uni0061"}, ), ({}, {}), ], ), ( {"cntr": 0}, {}, [ ({"wght": (-1.0, -0.45654)}, {"uni0061": "uni0041"}), ({"wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke"}), ], ), ( {"cntr": 1.0}, {"uni0041": "uni0061"}, [ ( {"wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke", "uni0041": "uni0061"}, ), ({}, {}), ], ), ( {"cntr": (-0.5, 0, 1.0)}, {}, [ ( {"wght": (0.20886, 1.0), "cntr": (0.75, 1)}, {"uni0024": "uni0024.nostroke", "uni0041": "uni0061"}, ), ( {"wght": (-1.0, -0.45654), "cntr": (0, 0.25)}, {"uni0061": "uni0041"}, ), ( {"cntr": (0.75, 1.0)}, {"uni0041": "uni0061"}, ), ( {"wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke"}, ), ], ), ( {"cntr": (0.8, 0.9, 1.0)}, {"uni0041": "uni0061"}, [ ( {"wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke", "uni0041": "uni0061"}, ), ( {}, {"uni0041": "uni0061"}, ), ], ), ( {"cntr": (0.7, 0.9, 1.0)}, {"uni0041": "uni0061"}, [ ( {"cntr": (-0.7499999999999999, 1.0), "wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke", "uni0041": "uni0061"}, ), ( {"cntr": (-0.7499999999999999, 1.0)}, {"uni0041": "uni0061"}, ), ( {"wght": (0.20886, 1.0)}, {"uni0024": "uni0024.nostroke"}, ), ( {}, {}, ), ], ), ], ) def test_partial_instance(self, location, appliedSubs, expectedRecords): font = makeFeatureVarsFont( [ ([{"wght": (0.20886, 1.0)}], {"uni0024": "uni0024.nostroke"}), ([{"cntr": (0.75, 1.0)}], {"uni0041": "uni0061"}), ( [{"wght": (-1.0, -0.45654), "cntr": (0, 0.25)}], {"uni0061": "uni0041"}, ), ] ) limits = instancer.NormalizedAxisLimits(location) instancer.instantiateFeatureVariations(font, limits) gsub = font["GSUB"].table featureVariations = gsub.FeatureVariations assert featureVariations.FeatureVariationCount == len(expectedRecords) axisOrder = [ a.axisTag for a in font["fvar"].axes if a.axisTag not in location or isinstance(location[a.axisTag], tuple) ] for i, (expectedConditionSet, expectedSubs) in enumerate(expectedRecords): rec = featureVariations.FeatureVariationRecord[i] conditionSet = _conditionSetAsDict(rec.ConditionSet, axisOrder) assert conditionSet == expectedConditionSet, i subsRecord = rec.FeatureTableSubstitution.SubstitutionRecord[0] lookupIndices = subsRecord.Feature.LookupListIndex substitutions = _getSubstitutions(gsub, lookupIndices) assert substitutions == expectedSubs, i appliedLookupIndices = gsub.FeatureList.FeatureRecord[0].Feature.LookupListIndex assert _getSubstitutions(gsub, appliedLookupIndices) == appliedSubs @pytest.mark.parametrize( "location, appliedSubs", [ ({"wght": 0, "cntr": 0}, None), ({"wght": -1.0, "cntr": 0}, {"uni0061": "uni0041"}), ({"wght": 1.0, "cntr": 0}, {"uni0024": "uni0024.nostroke"}), ({"wght": 0.0, "cntr": 1.0}, {"uni0041": "uni0061"}), ( {"wght": 1.0, "cntr": 1.0}, {"uni0041": "uni0061", "uni0024": "uni0024.nostroke"}, ), ({"wght": -1.0, "cntr": 0.3}, None), ], ) def test_full_instance(self, location, appliedSubs): font = makeFeatureVarsFont( [ ([{"wght": (0.20886, 1.0)}], {"uni0024": "uni0024.nostroke"}), ([{"cntr": (0.75, 1.0)}], {"uni0041": "uni0061"}), ( [{"wght": (-1.0, -0.45654), "cntr": (0, 0.25)}], {"uni0061": "uni0041"}, ), ] ) gsub = font["GSUB"].table assert gsub.FeatureVariations assert gsub.Version == 0x00010001 location = instancer.NormalizedAxisLimits(location) instancer.instantiateFeatureVariations(font, location) assert not hasattr(gsub, "FeatureVariations") assert gsub.Version == 0x00010000 if appliedSubs: lookupIndices = gsub.FeatureList.FeatureRecord[0].Feature.LookupListIndex assert _getSubstitutions(gsub, lookupIndices) == appliedSubs else: assert not gsub.FeatureList.FeatureRecord def test_null_conditionset(self): # A null ConditionSet offset should be treated like an empty ConditionTable, i.e. # all contexts are matched; see https://github.com/fonttools/fonttools/issues/3211 font = makeFeatureVarsFont( [([{"wght": (-1.0, 1.0)}], {"uni0024": "uni0024.nostroke"})] ) gsub = font["GSUB"].table gsub.FeatureVariations.FeatureVariationRecord[0].ConditionSet = None location = instancer.NormalizedAxisLimits({"wght": 0.5}) instancer.instantiateFeatureVariations(font, location) assert not hasattr(gsub, "FeatureVariations") assert gsub.Version == 0x00010000 lookupIndices = gsub.FeatureList.FeatureRecord[0].Feature.LookupListIndex assert _getSubstitutions(gsub, lookupIndices) == {"uni0024": "uni0024.nostroke"} def test_unsupported_condition_format(self, caplog): font = makeFeatureVarsFont( [ ( [{"wdth": (-1.0, -0.5), "wght": (0.5, 1.0)}], {"dollar": "dollar.nostroke"}, ) ] ) featureVariations = font["GSUB"].table.FeatureVariations rec1 = featureVariations.FeatureVariationRecord[0] assert len(rec1.ConditionSet.ConditionTable) == 2 rec1.ConditionSet.ConditionTable[0].Format = 2 with caplog.at_level(logging.WARNING, logger="fontTools.varLib.instancer"): instancer.instantiateFeatureVariations( font, instancer.NormalizedAxisLimits(wdth=0) ) assert ( "Condition table 0 of FeatureVariationRecord 0 " "has unsupported format (2); ignored" ) in caplog.text # check that record with unsupported condition format (but whose other # conditions do not reference pinned axes) is kept as is featureVariations = font["GSUB"].table.FeatureVariations assert featureVariations.FeatureVariationRecord[0] is rec1 assert len(rec1.ConditionSet.ConditionTable) == 2 assert rec1.ConditionSet.ConditionTable[0].Format == 2 def test_GSUB_FeatureVariations_is_None(self, varfont2): varfont2["GSUB"].table.Version = 0x00010001 varfont2["GSUB"].table.FeatureVariations = None tmp = BytesIO() varfont2.save(tmp) varfont = ttLib.TTFont(tmp) # DO NOT raise an exception when the optional 'FeatureVariations' attribute is # present but is set to None (e.g. with GSUB 1.1); skip and do nothing. assert varfont["GSUB"].table.FeatureVariations is None instancer.instantiateFeatureVariations(varfont, {"wght": 400, "wdth": 100}) assert varfont["GSUB"].table.FeatureVariations is None class LimitTupleVariationAxisRangesTest: def check_limit_single_var_axis_range(self, var, axisTag, axisRange, expected): result = instancer.changeTupleVariationAxisLimit(var, axisTag, axisRange) print(result) assert len(result) == len(expected) for v1, v2 in zip(result, expected): assert v1.coordinates == pytest.approx(v2.coordinates) assert v1.axes.keys() == v2.axes.keys() for k in v1.axes: p, q = v1.axes[k], v2.axes[k] assert p == pytest.approx(q) @pytest.mark.parametrize( "var, axisTag, newMax, expected", [ ( TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100]), "wdth", 0.5, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100])], ), ( TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100]), "wght", 0.5, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [50, 50])], ), ( TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100]), "wght", 0.8, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [80, 80])], ), ( TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100]), "wght", 1.0, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100])], ), (TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100]), "wght", 0.0, []), (TupleVariation({"wght": (0.5, 1.0, 1.0)}, [100, 100]), "wght", 0.4, []), ( TupleVariation({"wght": (0.0, 0.5, 1.0)}, [100, 100]), "wght", 0.5, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [100, 100])], ), ( TupleVariation({"wght": (0.0, 0.5, 1.0)}, [100, 100]), "wght", 0.4, [TupleVariation({"wght": (0.0, 1.0, 1.0)}, [80, 80])], ), ( TupleVariation({"wght": (0.0, 0.5, 1.0)}, [100, 100]), "wght", 0.6, [ TupleVariation({"wght": (0.0, 0.833334, 1.0)}, [100, 100]), TupleVariation({"wght": (0.833334, 1.0, 1.0)}, [80, 80]), ], ), ( TupleVariation({"wght": (0.0, 0.2, 1.0)}, [100, 100]), "wght", 0.4, [ TupleVariation({"wght": (0.0, 0.5, 1.0)}, [100, 100]), TupleVariation({"wght": (0.5, 1.0, 1.0)}, [75, 75]), ], ), ( TupleVariation({"wght": (0.0, 0.2, 1.0)}, [100, 100]), "wght", 0.5, [ TupleVariation({"wght": (0.0, 0.4, 1)}, [100, 100]), TupleVariation({"wght": (0.4, 1, 1)}, [62.5, 62.5]), ], ), ( TupleVariation({"wght": (0.5, 0.5, 1.0)}, [100, 100]), "wght", 0.5, [TupleVariation({"wght": (1.0, 1.0, 1.0)}, [100, 100])], ), ], ) def test_positive_var(self, var, axisTag, newMax, expected): axisRange = instancer.NormalizedAxisTripleAndDistances(0, 0, newMax) self.check_limit_single_var_axis_range(var, axisTag, axisRange, expected) @pytest.mark.parametrize( "var, axisTag, newMin, expected", [ ( TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100]), "wdth", -0.5, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100])], ), ( TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100]), "wght", -0.5, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [50, 50])], ), ( TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100]), "wght", -0.8, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [80, 80])], ), ( TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100]), "wght", -1.0, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100])], ), (TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100]), "wght", 0.0, []), ( TupleVariation({"wght": (-1.0, -1.0, -0.5)}, [100, 100]), "wght", -0.4, [], ), ( TupleVariation({"wght": (-1.0, -0.5, 0.0)}, [100, 100]), "wght", -0.5, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [100, 100])], ), ( TupleVariation({"wght": (-1.0, -0.5, 0.0)}, [100, 100]), "wght", -0.4, [TupleVariation({"wght": (-1.0, -1.0, 0.0)}, [80, 80])], ), ( TupleVariation({"wght": (-1.0, -0.5, 0.0)}, [100, 100]), "wght", -0.6, [ TupleVariation({"wght": (-1.0, -0.833334, 0.0)}, [100, 100]), TupleVariation({"wght": (-1.0, -1.0, -0.833334)}, [80, 80]), ], ), ( TupleVariation({"wght": (-1.0, -0.2, 0.0)}, [100, 100]), "wght", -0.4, [ TupleVariation({"wght": (-1.0, -0.5, -0.0)}, [100, 100]), TupleVariation({"wght": (-1.0, -1.0, -0.5)}, [75, 75]), ], ), ( TupleVariation({"wght": (-1.0, -0.2, 0.0)}, [100, 100]), "wght", -0.5, [ TupleVariation({"wght": (-1.0, -0.4, 0.0)}, [100, 100]), TupleVariation({"wght": (-1.0, -1.0, -0.4)}, [62.5, 62.5]), ], ), ( TupleVariation({"wght": (-1.0, -0.5, -0.5)}, [100, 100]), "wght", -0.5, [TupleVariation({"wght": (-1.0, -1.0, -1.0)}, [100, 100])], ), ], ) def test_negative_var(self, var, axisTag, newMin, expected): axisRange = instancer.NormalizedAxisTripleAndDistances(newMin, 0, 0, 1, 1) self.check_limit_single_var_axis_range(var, axisTag, axisRange, expected) @pytest.mark.parametrize( "oldRange, newLimit, expected", [ ((1.0, -1.0), (-1.0, 0, 1.0), None), # invalid oldRange min > max ((0.6, 1.0), (0, 0, 0.5), None), ((-1.0, -0.6), (-0.5, 0, 0), None), ((0.4, 1.0), (0, 0, 0.5), (0.8, 1.0)), ((-1.0, -0.4), (-0.5, 0, 0), (-1.0, -0.8)), ((0.4, 1.0), (0, 0, 0.4), (1.0, 1.0)), ((-1.0, -0.4), (-0.4, 0, 0), (-1.0, -1.0)), ((-0.5, 0.5), (-0.4, 0, 0.4), (-1.0, 1.0)), ((0, 1.0), (-1.0, 0, 0), (0, 0)), # or None? ((-1.0, 0), (0, 0, 1.0), (0, 0)), # or None? ], ) def test_limitFeatureVariationConditionRange(oldRange, newLimit, expected): condition = featureVars.buildConditionTable(0, *oldRange) result = instancer.featureVars._limitFeatureVariationConditionRange( condition, instancer.NormalizedAxisTripleAndDistances(*newLimit, 1, 1) ) assert result == expected @pytest.mark.parametrize( "limits, expected", [ (["wght=400", "wdth=100"], {"wght": 400, "wdth": 100}), (["wght=400:900"], {"wght": (400, 900)}), (["wght=400:700:900"], {"wght": (400, 700, 900)}), (["slnt=11.4"], {"slnt": 11.399994}), (["ABCD=drop"], {"ABCD": None}), (["wght=:500:"], {"wght": (None, 500, None)}), (["wght=::700"], {"wght": (None, None, 700)}), (["wght=200::"], {"wght": (200, None, None)}), (["wght=200:300:"], {"wght": (200, 300, None)}), (["wght=:300:500"], {"wght": (None, 300, 500)}), (["wght=300::700"], {"wght": (300, None, 700)}), (["wght=300:700"], {"wght": (300, None, 700)}), (["wght=:700"], {"wght": (None, None, 700)}), (["wght=200:"], {"wght": (200, None, None)}), ], ) def test_parseLimits(limits, expected): limits = instancer.parseLimits(limits) expected = instancer.AxisLimits(expected) assert limits.keys() == expected.keys() for axis, triple in limits.items(): expected_triple = expected[axis] if expected_triple is None: assert triple is None else: assert isinstance(triple, instancer.AxisTriple) assert isinstance(expected_triple, instancer.AxisTriple) assert triple == pytest.approx(expected_triple) @pytest.mark.parametrize( "limits", [["abcde=123", "=0", "wght=:", "wght=1:", "wght=abcd", "wght=x:y"]] ) def test_parseLimits_invalid(limits): with pytest.raises(ValueError, match="invalid location format"): instancer.parseLimits(limits) @pytest.mark.parametrize( "limits, expected", [ # 300, 500 come from the font having 100,400,900 fvar axis limits. ({"wght": (100, 400)}, {"wght": (-1.0, 0, 0, 300, 500)}), ({"wght": (100, 400, 400)}, {"wght": (-1.0, 0, 0, 300, 500)}), ({"wght": (100, 300, 400)}, {"wght": (-1.0, -0.5, 0, 300, 500)}), ], ) def test_normalizeAxisLimits(varfont, limits, expected): limits = instancer.AxisLimits(limits) normalized = limits.normalize(varfont) assert normalized == instancer.NormalizedAxisLimits(expected) def test_normalizeAxisLimits_no_avar(varfont): del varfont["avar"] limits = instancer.AxisLimits(wght=(400, 400, 500)) normalized = limits.normalize(varfont) assert normalized["wght"] == pytest.approx((0, 0, 0.2, 300, 500), 1e-4) def test_normalizeAxisLimits_missing_from_fvar(varfont): with pytest.raises(ValueError, match="not present in fvar"): instancer.AxisLimits({"ZZZZ": 1000}).normalize(varfont) def test_sanityCheckVariableTables(varfont): font = ttLib.TTFont() with pytest.raises(ValueError, match="Missing required table fvar"): instancer.sanityCheckVariableTables(font) del varfont["glyf"] with pytest.raises(ValueError, match="Can't have gvar without glyf"): instancer.sanityCheckVariableTables(varfont) def test_main(varfont, tmpdir): fontfile = str(tmpdir / "PartialInstancerTest-VF.ttf") varfont.save(fontfile) args = [fontfile, "wght=400"] # exits without errors assert instancer.main(args) is None def test_main_exit_nonexistent_file(capsys): with pytest.raises(SystemExit): instancer.main([""]) captured = capsys.readouterr() assert "No such file ''" in captured.err def test_main_exit_invalid_location(varfont, tmpdir, capsys): fontfile = str(tmpdir / "PartialInstancerTest-VF.ttf") varfont.save(fontfile) with pytest.raises(SystemExit): instancer.main([fontfile, "wght:100"]) captured = capsys.readouterr() assert "invalid location format" in captured.err def test_main_exit_multiple_limits(varfont, tmpdir, capsys): fontfile = str(tmpdir / "PartialInstancerTest-VF.ttf") varfont.save(fontfile) with pytest.raises(SystemExit): instancer.main([fontfile, "wght=400", "wght=90"]) captured = capsys.readouterr() assert "Specified multiple limits for the same axis" in captured.err def test_set_ribbi_bits(): varfont = ttLib.TTFont() varfont.importXML(os.path.join(TESTDATA, "STATInstancerTest.ttx")) for location in [instance.coordinates for instance in varfont["fvar"].instances]: instance = instancer.instantiateVariableFont( varfont, location, updateFontNames=True ) name_id_2 = instance["name"].getDebugName(2) mac_style = instance["head"].macStyle fs_selection = instance["OS/2"].fsSelection & 0b1100001 # Just bits 0, 5, 6 if location["ital"] == 0: if location["wght"] == 700: assert name_id_2 == "Bold", location assert mac_style == 0b01, location assert fs_selection == 0b0100000, location else: assert name_id_2 == "Regular", location assert mac_style == 0b00, location assert fs_selection == 0b1000000, location else: if location["wght"] == 700: assert name_id_2 == "Bold Italic", location assert mac_style == 0b11, location assert fs_selection == 0b0100001, location else: assert name_id_2 == "Italic", location assert mac_style == 0b10, location assert fs_selection == 0b0000001, location