def testDecompileToXML(self):
a = otTables.InsertionMorphAction()
actionReader = OTTableReader(
deHexStr("DEAD BEEF 0002 0001 0004 0002 0003 DEAD BEEF"))
a.decompile(OTTableReader(deHexStr("1234 FC43 0005 0002")),
self.font, actionReader)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(getXML(toXML, self.font), self.MORPH_ACTION_XML)
def testDecompileToXML(self):
a = otTables.InsertionMorphAction()
actionReader = OTTableReader(
deHexStr("DEAD BEEF 0002 0001 0004 0002 0003 DEAD BEEF"))
a.decompile(OTTableReader(deHexStr("1234 FC43 0005 0002")), self.font,
actionReader)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(getXML(toXML, self.font), self.MORPH_ACTION_XML)
def test_decompileDeltas(self):
decompileDeltas = TupleVariation.decompileDeltas_
# 83 = zero values (0x80), count = 4 (1 + 0x83 & 0x3F)
self.assertEqual(([0, 0, 0, 0], 1), decompileDeltas(4, deHexStr("83"), 0))
# 41 01 02 FF FF = signed 16-bit values (0x40), count = 2 (1 + 0x41 & 0x3F)
self.assertEqual(([258, -1], 5), decompileDeltas(2, deHexStr("41 01 02 FF FF"), 0))
# 01 81 07 = signed 8-bit values, count = 2 (1 + 0x01 & 0x3F)
self.assertEqual(([-127, 7], 3), decompileDeltas(2, deHexStr("01 81 07"), 0))
# combination of all three encodings, preceded and followed by 4 bytes of unused data
data = deHexStr("DE AD BE EF 83 40 01 02 01 81 80 DE AD BE EF")
self.assertEqual(([0, 0, 0, 0, 258, -127, -128], 11), decompileDeltas(7, data, 4))
def test_decompileDeltas(self):
decompileDeltas = TupleVariation.decompileDeltas_
# 83 = zero values (0x80), count = 4 (1 + 0x83 & 0x3F)
self.assertEqual(([0, 0, 0, 0], 1), decompileDeltas(4, deHexStr("83"), 0))
# 41 01 02 FF FF = signed 16-bit values (0x40), count = 2 (1 + 0x41 & 0x3F)
self.assertEqual(([258, -1], 5), decompileDeltas(2, deHexStr("41 01 02 FF FF"), 0))
# 01 81 07 = signed 8-bit values, count = 2 (1 + 0x01 & 0x3F)
self.assertEqual(([-127, 7], 3), decompileDeltas(2, deHexStr("01 81 07"), 0))
# combination of all three encodings, preceded and followed by 4 bytes of unused data
data = deHexStr("DE AD BE EF 83 40 01 02 01 81 80 DE AD BE EF")
self.assertEqual(([0, 0, 0, 0, 258, -127, -128], 11), decompileDeltas(7, data, 4))
def test_decompile_additional_SB(self):
font = self.makeFont(numGlyphs=4, numberOfMetrics=2)
metrics = deHexStr("02A2 FFF5 0278 004F")
extraSideBearings = deHexStr("0036 FFFC")
data = metrics + extraSideBearings
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(mtxTable['A'], (674, -11))
self.assertEqual(mtxTable['B'], (632, 79))
# all following have same width as the previous
self.assertEqual(mtxTable['C'], (632, 54))
self.assertEqual(mtxTable['D'], (632, -4))
def test_decompile_additional_SB(self):
font = self.makeFont(numGlyphs=4, numberOfMetrics=2)
metrics = deHexStr("02A2 FFF5 0278 004F")
extraSideBearings = deHexStr("0036 FFFC")
data = metrics + extraSideBearings
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(mtxTable['A'], (674, -11))
self.assertEqual(mtxTable['B'], (632, 79))
# all following have same width as the previous
self.assertEqual(mtxTable['C'], (632, 54))
self.assertEqual(mtxTable['D'], (632, -4))
def testDecompileToXML(self):
a = otTables.LigatureMorphAction()
actionReader = OTTableReader(deHexStr("DEADBEEF 7FFFFFFE 80000003"))
a.decompile(OTTableReader(deHexStr("1234FAB30001")),
self.font, actionReader)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(getXML(toXML, self.font), [
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="SetComponent,DontAdvance"/>',
' <ReservedFlags value="0x1AB3"/>',
' <Action GlyphIndexDelta="-2" Flags="Store"/>',
' <Action GlyphIndexDelta="3"/>',
'</Transition>',
])
def test_decompileCoord_roundTrip(self):
# Make sure we are not affected by https://github.com/behdad/fonttools/issues/286
data = deHexStr("7F B9 80 35")
values, _ = TupleVariation.decompileCoord_(["wght", "wdth"], data, 0)
axisValues = {axis:(val, val, val) for axis, val in values.items()}
var = TupleVariation(axisValues, [None] * 4)
self.assertEqual("7F B9 80 35", hexencode(var.compileCoord(["wght", "wdth"])))
def test_decompileOffsets_shortFormat(self):
decompileOffsets = gvarClass.decompileOffsets_
data = deHexStr("00 11 22 33 44 55 66 77 88 99 aa bb")
self.assertEqual(
[2 * 0x0011, 2 * 0x2233, 2 * 0x4455, 2 * 0x6677, 2 * 0x8899, 2 * 0xAABB],
list(decompileOffsets(data, tableFormat=0, glyphCount=5)),
)
def test_decompileCoord_roundTrip(self):
# Make sure we are not affected by https://github.com/fonttools/fonttools/issues/286
data = deHexStr("7F B9 80 35")
values, _ = TupleVariation.decompileCoord_(["wght", "wdth"], data, 0)
axisValues = {axis:(val, val, val) for axis, val in values.items()}
var = TupleVariation(axisValues, [None] * 4)
self.assertEqual("7F B9 80 35", hexencode(var.compileCoord(["wght", "wdth"])))
def test_decompileOffsets_shortFormat(self):
decompileOffsets = table__g_v_a_r.decompileOffsets_
data = deHexStr("00 11 22 33 44 55 66 77 88 99 aa bb")
self.assertEqual([
2 * 0x0011, 2 * 0x2233, 2 * 0x4455, 2 * 0x6677, 2 * 0x8899,
2 * 0xaabb
], list(decompileOffsets(data, tableFormat=0, glyphCount=5)))
def test_decompileCoord(self):
decompileCoord = GlyphVariation.decompileCoord_
data = deHexStr("DE AD C0 00 20 00 DE AD")
self.assertEqual(({
"wght": -1.0,
"wdth": 0.5
}, 6), decompileCoord(["wght", "wdth"], data, 2))
def test_decompileOffsets_longFormat(self):
decompileOffsets = table__g_v_a_r.decompileOffsets_
data = deHexStr("00 11 22 33 44 55 66 77 88 99 aa bb")
self.assertEqual([0x00112233, 0x44556677, 0x8899aabb],
list(
decompileOffsets(data,
tableFormat=1,
glyphCount=2)))
def testDecompileToXML(self):
a = otTables.LigatureMorphAction()
actionReader = OTTableReader(deHexStr("DEADBEEF 7FFFFFFE 80000003"))
a.decompile(OTTableReader(deHexStr("1234FAB30001")), self.font,
actionReader)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(
getXML(toXML, self.font),
[
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="SetComponent,DontAdvance"/>',
' <ReservedFlags value="0x1AB3"/>',
' <Action GlyphIndexDelta="-2" Flags="Store"/>',
' <Action GlyphIndexDelta="3"/>',
'</Transition>',
])
def test_decompilePoints_shouldAcceptBadPointNumbers(self):
decompilePoints = TupleVariation.decompilePoints_
# 2 points; first run: [3, 9].
numPointsInGlyph = 8
with CapturingLogHandler(log, "WARNING") as captor:
decompilePoints(numPointsInGlyph,
deHexStr("02 01 03 06"), 0, "cvar")
self.assertIn("point 9 out of range in 'cvar' table",
[r.msg for r in captor.records])
def test_decompilePoints_shouldAcceptBadPointNumbers(self):
decompilePoints = TupleVariation.decompilePoints_
# 2 points; first run: [3, 9].
numPointsInGlyph = 8
with CapturingLogHandler(log, "WARNING") as captor:
decompilePoints(numPointsInGlyph,
deHexStr("02 01 03 06"), 0, "cvar")
self.assertIn("point 9 out of range in 'cvar' table",
[r.msg for r in captor.records])
def test_readFormat0(self):
reader = OTTableReader(deHexStr("0000 0000 0001 0002 0000 7D00 0001"))
self.assertEqual(self.converter.read(reader, self.font, None), {
".notdef": ".notdef",
"A": "A",
"B": "B",
"C": ".notdef",
"D": "glyph32000",
"E": "A"
})
def test_readFormat6(self):
reader = OTTableReader(deHexStr(
"0006 0004 0002 0008 0001 0004 "
"0003 0001 " # C --> A
"0005 0002 " # E --> B
"FFFF FFFF")) # end of search table
self.assertEqual(self.converter.read(reader, self.font, None), {
"C": "A",
"E": "B",
})
def test_decompile(self):
font = self.makeFont(numGlyphs=3, numberOfMetrics=3)
data = deHexStr("02A2 FFF5 0278 004F 02C6 0036")
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(mtxTable['A'], (674, -11))
self.assertEqual(mtxTable['B'], (632, 79))
self.assertEqual(mtxTable['C'], (710, 54))
def test_readFormat8(self):
reader = OTTableReader(deHexStr(
"0008 "
"0003 0003 " # first: C, count: 3
"0007 0001 0002")) # [G, A, B]
self.assertEqual(self.converter.read(reader, self.font, None), {
"C": "G",
"D": "A",
"E": "B",
})
def test_writeFormat0(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C".split())
self.converter.write(writer, font, {}, {
".notdef": ".notdef",
"A": "C",
"B": "C",
"C": "A"
})
self.assertEqual(writer.getData(), deHexStr("0000 0000 0003 0003 0001"))
def testCompileActions_shouldShareSubsequences(self):
state = otTables.AATState()
t = state.Transitions = {i: otTables.LigatureMorphAction()
for i in range(3)}
ligs = [otTables.LigAction() for _ in range(3)]
for i, lig in enumerate(ligs):
lig.GlyphIndexDelta = i
t[0].Actions = ligs[1:2]
t[1].Actions = ligs[0:3]
t[2].Actions = ligs[1:3]
actions, actionIndex = t[0].compileActions(self.font, [state])
self.assertEqual(actions,
deHexStr("00000000 00000001 80000002 80000001"))
self.assertEqual(actionIndex, {
deHexStr("00000000 00000001 80000002"): 0,
deHexStr("00000001 80000002"): 1,
deHexStr("80000002"): 2,
deHexStr("80000001"): 3,
})
def test_decompileCoords(self):
decompileCoords = GlyphVariation.decompileCoords_
axes = ["wght", "wdth", "opsz"]
coords = [
{"wght": 1.0, "wdth": 0.0, "opsz": 0.5},
{"wght": -1.0, "wdth": 0.0, "opsz": 0.25},
{"wght": 0.0, "wdth": -1.0, "opsz": 1.0}
]
data = deHexStr("DE AD 40 00 00 00 20 00 C0 00 00 00 10 00 00 00 C0 00 40 00")
self.assertEqual((coords, 20), decompileCoords(axes, numCoords=3, data=data, offset=2))
def test_decompile(self):
font = self.makeFont(numGlyphs=3, numberOfMetrics=3)
data = deHexStr("02A2 FFF5 0278 004F 02C6 0036")
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(mtxTable['A'], (674, -11))
self.assertEqual(mtxTable['B'], (632, 79))
self.assertEqual(mtxTable['C'], (710, 54))
def test_readFormat8(self):
reader = OTTableReader(
deHexStr("0008 "
"0003 0003 " # first: C, count: 3
"0007 0001 0002")) # [G, A, B]
self.assertEqual(self.converter.read(reader, self.font, None), {
"C": "G",
"D": "A",
"E": "B",
})
def test_readFormat6(self):
reader = OTTableReader(
deHexStr("0006 0004 0002 0008 0001 0004 "
"0003 0001 " # C --> A
"0005 0002 " # E --> B
"FFFF FFFF")) # end of search table
self.assertEqual(self.converter.read(reader, self.font, None), {
"C": "A",
"E": "B",
})
def test_compile_format_unknown(self, version, st_length, expected):
kern = newTable("kern")
kern.version = version
kern.kernTables = []
for unknown_fmt, kern_data in zip((4, 5), ("1234 5678", "9ABC DEF0")):
if version > 0:
coverage = 0
header_fmt = deHexStr("%08X %02X %02X %04X" %
(st_length, coverage, unknown_fmt, 0))
else:
coverage = 1
header_fmt = deHexStr("%04X %04X %02X %02X" %
(0, st_length, unknown_fmt, coverage))
st = KernTable_format_unkown(unknown_fmt)
st.data = header_fmt + deHexStr(kern_data)
kern.kernTables.append(st)
data = kern.compile(font)
assert data == expected
def test_readFormat0(self):
reader = OTTableReader(deHexStr("0000 0000 0001 0002 0000 7D00 0001"))
self.assertEqual(
self.converter.read(reader, self.font, None), {
".notdef": ".notdef",
"A": "A",
"B": "B",
"C": ".notdef",
"D": "glyph32000",
"E": "A"
})
def test_writeFormat0(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C".split())
self.converter.write(writer, font, {}, {
".notdef": ".notdef",
"A": "C",
"B": "C",
"C": "A"
})
self.assertEqual(writer.getData(),
deHexStr("0000 0000 0003 0003 0001"))
def test_compile_round_float_values(self):
font = self.makeFont(numGlyphs=3, numberOfMetrics=2)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (0.5, 0.5), # round -> (1, 1)
'B': (0.1, 0.9), # round -> (0, 1)
'C': (0.1, 0.1), # round -> (0, 0)
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0001 0001 0000 0001 0000"))
def test_compile_round_float_values(self):
font = self.makeFont(numGlyphs=3, numberOfMetrics=2)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (0.5, 0.5), # round -> (0, 0)
'B': (0.1, 0.9), # round -> (0, 1)
'C': (0.1, 0.1), # round -> (0, 0)
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0000 0000 0000 0001 0000"))
def testDecompileToXML(self):
r = otTables.RearrangementMorphAction()
r.decompile(OTTableReader(deHexStr("1234fffd")),
self.font, actionReader=None)
toXML = lambda w, f: r.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(getXML(toXML, self.font), [
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="MarkFirst,DontAdvance,MarkLast"/>',
' <ReservedFlags value="0x1FF0"/>',
' <Verb value="13"/><!-- ABxCD ⇒ CDxBA -->',
'</Transition>',
])
def test_decompile_possibly_negative_advance(self):
font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
# we warn if advance is > 0x7FFF as it might be interpreted as signed
# by some authoring tools
data = deHexStr("8000 0000")
mtxTable = newTable(self.tag)
with CapturingLogHandler(log, "WARNING") as captor:
mtxTable.decompile(data, font)
self.assertTrue(
len([r for r in captor.records
if "has a huge advance" in r.msg]) == 1)
def test_readFormat2(self):
reader = OTTableReader(deHexStr(
"0002 0006 0002 000C 0001 0006 "
"0002 0001 0003 " # glyph A..B: map to C
"0007 0005 0008 " # glyph E..G: map to H
"FFFF FFFF FFFF")) # end of search table
self.assertEqual(self.converter.read(reader, self.font, None), {
"A": "C",
"B": "C",
"E": "H",
"F": "H",
"G": "H",
})
def test_compile_additional_SB(self):
font = self.makeFont(numGlyphs=4, numberOfMetrics=1)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (632, -11),
'B': (632, 79),
'C': (632, 54),
'D': (632, -4),
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0278 FFF5 004F 0036 FFFC"))
def testCompileActions_shouldShareSubsequences(self):
state = otTables.AATState()
t = state.Transitions = {
i: otTables.LigatureMorphAction()
for i in range(3)
}
ligs = [otTables.LigAction() for _ in range(3)]
for i, lig in enumerate(ligs):
lig.GlyphIndexDelta = i
t[0].Actions = ligs[1:2]
t[1].Actions = ligs[0:3]
t[2].Actions = ligs[1:3]
actions, actionIndex = t[0].compileActions(self.font, [state])
self.assertEqual(actions,
deHexStr("00000000 00000001 80000002 80000001"))
self.assertEqual(
actionIndex, {
deHexStr("00000000 00000001 80000002"): 0,
deHexStr("00000001 80000002"): 1,
deHexStr("80000002"): 2,
deHexStr("80000001"): 3,
})
def test_readFormat4(self):
reader = OTTableReader(
deHexStr("0004 0006 0003 000C 0001 0006 "
"0002 0001 001E " # glyph 1..2: mapping at offset 0x1E
"0005 0004 001E " # glyph 4..5: mapping at offset 0x1E
"FFFF FFFF FFFF " # end of search table
"0007 0008")) # offset 0x18: glyphs [7, 8] = [G, H]
self.assertEqual(self.converter.read(reader, self.font, None), {
"A": "G",
"B": "H",
"D": "G",
"E": "H",
})
def test_compile_format_unknown(self, version, st_length, expected):
kern = newTable("kern")
kern.version = version
kern.kernTables = []
for unknown_fmt, kern_data in zip((4, 5), ("1234 5678", "9ABC DEF0")):
if version > 0:
coverage = 0
header_fmt = deHexStr(
"%08X %02X %02X %04X" % (
st_length, coverage, unknown_fmt, 0))
else:
coverage = 1
header_fmt = deHexStr(
"%04X %04X %02X %02X" % (
0, st_length, unknown_fmt, coverage))
st = KernTable_format_unkown(unknown_fmt)
st.data = header_fmt + deHexStr(kern_data)
kern.kernTables.append(st)
data = kern.compile(font)
assert data == expected
def test_readFormat2(self):
reader = OTTableReader(
deHexStr("0002 0006 0002 000C 0001 0006 "
"0002 0001 0003 " # glyph A..B: map to C
"0007 0005 0008 " # glyph E..G: map to H
"FFFF FFFF FFFF")) # end of search table
self.assertEqual(self.converter.read(reader, self.font, None), {
"A": "C",
"B": "C",
"E": "H",
"F": "H",
"G": "H",
})
def test_decompile_possibly_negative_advance(self):
font = self.makeFont(numGlyphs=1, numberOfMetrics=1)
# we warn if advance is > 0x7FFF as it might be interpreted as signed
# by some authoring tools
data = deHexStr("8000 0000")
mtxTable = newTable(self.tag)
with CapturingLogHandler(log, "WARNING") as captor:
mtxTable.decompile(data, font)
self.assertTrue(
len([r for r in captor.records
if "has a huge advance" in r.msg]) == 1)
def test_compile_additional_SB(self):
font = self.makeFont(numGlyphs=4, numberOfMetrics=1)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (632, -11),
'B': (632, 79),
'C': (632, 54),
'D': (632, -4),
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0278 FFF5 004F 0036 FFFC"))
def test_readFormat4(self):
reader = OTTableReader(deHexStr(
"0004 0006 0003 000C 0001 0006 "
"0002 0001 001E " # glyph 1..2: mapping at offset 0x1E
"0005 0004 001E " # glyph 4..5: mapping at offset 0x1E
"FFFF FFFF FFFF " # end of search table
"0007 0008")) # offset 0x18: glyphs [7, 8] = [G, H]
self.assertEqual(self.converter.read(reader, self.font, None), {
"A": "G",
"B": "H",
"D": "G",
"E": "H",
})
def testDecompileToXML(self):
r = otTables.RearrangementMorphAction()
r.decompile(OTTableReader(deHexStr("1234fffd")), self.font)
toXML = lambda w, f: r.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(
getXML(toXML, self.font),
[
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="MarkFirst,DontAdvance,MarkLast"/>',
' <ReservedFlags value="0x1FF0"/>',
' <Verb value="13"/><!-- ABxCD ⇒ CDxBA -->',
'</Transition>',
])
def testDecompileToXML(self):
a = otTables.ContextualMorphAction()
a.decompile(OTTableReader(deHexStr("1234f117deadbeef")),
self.font, actionReader=None)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(getXML(toXML, self.font), [
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="SetMark,DontAdvance"/>',
' <ReservedFlags value="0x3117"/>',
' <MarkIndex value="57005"/>', # 0xDEAD = 57005
' <CurrentIndex value="48879"/>', # 0xBEEF = 48879
'</Transition>',
])
def _readRowImageData(bitmapObject, name, attrs, content, ttFont):
bitDepth = safeEval(attrs["bitDepth"])
metrics = SmallGlyphMetrics()
metrics.width = safeEval(attrs["width"])
metrics.height = safeEval(attrs["height"])
dataRows = []
for element in content:
if not isinstance(element, tuple):
continue
name, attr, content = element
# Chop off 'imagedata' from the tag to get just the option.
if name == "row":
dataRows.append(deHexStr(attr["value"]))
bitmapObject.setRows(dataRows, bitDepth=bitDepth, metrics=metrics)
def testDecompileToXML(self):
a = otTables.ContextualMorphAction()
a.decompile(OTTableReader(deHexStr("1234f117deadbeef")), self.font)
toXML = lambda w, f: a.toXML(w, f, {"Test": "Foo"}, "Transition")
self.assertEqual(
getXML(toXML, self.font),
[
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="SetMark,DontAdvance"/>',
' <ReservedFlags value="0x3117"/>',
' <MarkIndex value="57005"/>', # 0xDEAD = 57005
' <CurrentIndex value="48879"/>', # 0xBEEF = 48879
'</Transition>',
])
def _readRowImageData(bitmapObject, name, attrs, content, ttFont): bitDepth = safeEval(attrs['bitDepth']) metrics = SmallGlyphMetrics() metrics.width = safeEval(attrs['width']) metrics.height = safeEval(attrs['height']) dataRows = [] for element in content: if not isinstance(element, tuple): continue name, attr, content = element # Chop off 'imagedata' from the tag to get just the option. if name == 'row': dataRows.append(deHexStr(attr['value'])) bitmapObject.setRows(dataRows, bitDepth=bitDepth, metrics=metrics)
def test_compile_no_header_table(self):
font = TTFont()
maxp = font['maxp'] = newTable('maxp')
maxp.numGlyphs = 3
font.glyphOrder = [chr(i) for i in range(65, 68)]
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
"A": (400, 30),
"B": (400, 40),
"C": (400, 50),
}
self.assertNotIn(self.tableClass.headerTag, font)
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0190 001E 0190 0028 0190 0032"))
def test_compile(self):
# we set the wrong 'numberOfMetrics' to check it gets adjusted
font = self.makeFont(numGlyphs=3, numberOfMetrics=4)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (674, -11),
'B': (632, 79),
'C': (710, 54),
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("02A2 FFF5 0278 004F 02C6 0036"))
headerTable = font[self.tableClass.headerTag]
self.assertEqual(
getattr(headerTable, self.tableClass.numberOfMetricsName), 3)
def test_writeFormat8(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C D E F G H".split())
self.converter.write(writer, font, {}, {
"B": "B",
"C": "A",
"D": "B",
"E": "C",
"F": "B",
"G": "A",
})
self.assertEqual(writer.getData(), deHexStr(
"0008 " # format=8
"0002 " # firstGlyph=B
"0006 " # glyphCount=6
"0002 0001 0002 0003 0002 0001" # valueArray=[B, A, B, C, B, A]
))
def test_compile(self):
# we set the wrong 'numberOfMetrics' to check it gets adjusted
font = self.makeFont(numGlyphs=3, numberOfMetrics=4)
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
'A': (674, -11),
'B': (632, 79),
'C': (710, 54),
}
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("02A2 FFF5 0278 004F 02C6 0036"))
headerTable = font[self.tableClass.headerTag]
self.assertEqual(
getattr(headerTable, self.tableClass.numberOfMetricsName), 3)
def test_decompile_no_header_table(self):
font = TTFont()
maxp = font['maxp'] = newTable('maxp')
maxp.numGlyphs = 3
font.glyphOrder = ["A", "B", "C"]
self.assertNotIn(self.tableClass.headerTag, font)
data = deHexStr("0190 001E 0190 0028 0190 0032")
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(mtxTable.metrics, {
"A": (400, 30),
"B": (400, 40),
"C": (400, 50),
})
def test_compile_no_header_table(self):
font = TTFont()
maxp = font['maxp'] = newTable('maxp')
maxp.numGlyphs = 3
font.glyphOrder = [chr(i) for i in range(65, 68)]
mtxTable = font[self.tag] = newTable(self.tag)
mtxTable.metrics = {
"A": (400, 30),
"B": (400, 40),
"C": (400, 50),
}
self.assertNotIn(self.tableClass.headerTag, font)
data = mtxTable.compile(font)
self.assertEqual(data, deHexStr("0190 001E 0190 0028 0190 0032"))
def test_writeFormat8(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C D E F G H".split())
self.converter.write(writer, font, {}, {
"B": "B",
"C": "A",
"D": "B",
"E": "C",
"F": "B",
"G": "A",
})
self.assertEqual(
writer.getData(),
deHexStr(
"0008 " # format=8
"0002 " # firstGlyph=B
"0006 " # glyphCount=6
"0002 0001 0002 0003 0002 0001" # valueArray=[B, A, B, C, B, A]
))
def test_decompile_no_header_table(self):
font = TTFont()
maxp = font['maxp'] = newTable('maxp')
maxp.numGlyphs = 3
font.glyphOrder = ["A", "B", "C"]
self.assertNotIn(self.tableClass.headerTag, font)
data = deHexStr("0190 001E 0190 0028 0190 0032")
mtxTable = newTable(self.tag)
mtxTable.decompile(data, font)
self.assertEqual(
mtxTable.metrics,
{
"A": (400, 30),
"B": (400, 40),
"C": (400, 50),
}
)
def testCompileActions_shouldShareSubsequences(self):
state = otTables.AATState()
t = state.Transitions = {i: otTables.InsertionMorphAction()
for i in range(3)}
t[1].CurrentInsertionAction = []
t[0].MarkedInsertionAction = ['A']
t[1].CurrentInsertionAction = ['C', 'D']
t[1].MarkedInsertionAction = ['B']
t[2].CurrentInsertionAction = ['B', 'C', 'D']
t[2].MarkedInsertionAction = ['C', 'D']
actions, actionIndex = t[0].compileActions(self.font, [state])
self.assertEqual(actions, deHexStr('0002 0003 0004 0001'))
self.assertEqual(actionIndex, {
('A',): 3,
('B',): 0,
('B', 'C'): 0,
('B', 'C', 'D'): 0,
('C',): 1,
('C', 'D'): 1,
('D',): 2,
})
def test_writeFormat2(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C D E F G H".split())
self.converter.write(writer, font, {}, {
"B": "C",
"C": "C",
"D": "C",
"E": "C",
"G": "A",
"H": "A",
})
self.assertEqual(writer.getData(), deHexStr(
"0002 " # format=2
"0006 " # binSrchHeader.unitSize=6
"0002 " # binSrchHeader.nUnits=2
"000C " # binSrchHeader.searchRange=12
"0001 " # binSrchHeader.entrySelector=1
"0000 " # binSrchHeader.rangeShift=0
"0005 0002 0003 " # segments[0].lastGlyph=E, firstGlyph=B, value=C
"0008 0007 0001 " # segments[1].lastGlyph=H, firstGlyph=G, value=A
"FFFF FFFF 0000 " # segments[2]=<END>
))
def test_writeFormat6(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C D E".split())
self.converter.write(writer, font, {}, {
"A": "C",
"C": "B",
"D": "D",
"E": "E",
})
self.assertEqual(writer.getData(), deHexStr(
"0006 " # format=6
"0004 " # binSrchHeader.unitSize=4
"0004 " # binSrchHeader.nUnits=4
"0010 " # binSrchHeader.searchRange=16
"0002 " # binSrchHeader.entrySelector=2
"0000 " # binSrchHeader.rangeShift=0
"0001 0003 " # entries[0].glyph=A, .value=C
"0003 0002 " # entries[1].glyph=C, .value=B
"0004 0004 " # entries[2].glyph=D, .value=D
"0005 0005 " # entries[3].glyph=E, .value=E
"FFFF 0000 " # entries[4]=<END>
))
def test_decompileCoords(self):
decompileCoords = GlyphVariation.decompileCoords_
axes = ["wght", "wdth", "opsz"]
coords = [{
"wght": 1.0,
"wdth": 0.0,
"opsz": 0.5
}, {
"wght": -1.0,
"wdth": 0.0,
"opsz": 0.25
}, {
"wght": 0.0,
"wdth": -1.0,
"opsz": 1.0
}]
data = deHexStr(
"DE AD 40 00 00 00 20 00 C0 00 00 00 10 00 00 00 C0 00 40 00")
self.assertEqual((coords, 20),
decompileCoords(axes,
numCoords=3,
data=data,
offset=2))
def test_writeFormat6(self):
writer = OTTableWriter()
font = FakeFont(".notdef A B C D E".split())
self.converter.write(writer, font, {}, {
"A": "C",
"C": "B",
"D": "D",
"E": "E",
})
self.assertEqual(
writer.getData(),
deHexStr("0006 " # format=6
"0004 " # binSrchHeader.unitSize=4
"0004 " # binSrchHeader.nUnits=4
"0010 " # binSrchHeader.searchRange=16
"0002 " # binSrchHeader.entrySelector=2
"0000 " # binSrchHeader.rangeShift=0
"0001 0003 " # entries[0].glyph=A, .value=C
"0003 0002 " # entries[1].glyph=C, .value=B
"0004 0004 " # entries[2].glyph=D, .value=D
"0005 0005 " # entries[3].glyph=E, .value=E
"FFFF 0000 " # entries[4]=<END>
))