# coding: utf-8
from __future__ import print_function, division, absolute_import, unicode_literals
from fontTools.misc.py23 import *
from fontTools.misc.testTools import getXML, parseXML, FakeFont
from fontTools.misc.textTools import deHexStr, hexStr
from fontTools.misc.xmlWriter import XMLWriter
from fontTools.ttLib.tables.otBase import OTTableReader, OTTableWriter
import fontTools.ttLib.tables.otTables as otTables
import unittest
def makeCoverage(glyphs):
coverage = otTables.Coverage()
coverage.glyphs = glyphs
return coverage
class SingleSubstTest(unittest.TestCase):
def setUp(self):
self.glyphs = ".notdef A B C D E a b c d e".split()
self.font = FakeFont(self.glyphs)
def test_postRead_format1(self):
table = otTables.SingleSubst()
table.Format = 1
rawTable = {
"Coverage": makeCoverage(["A", "B", "C"]),
"DeltaGlyphID": 5
}
table.postRead(rawTable, self.font)
self.assertEqual(table.mapping, {"A": "a", "B": "b", "C": "c"})
def test_postRead_format2(self):
table = otTables.SingleSubst()
table.Format = 2
rawTable = {
"Coverage": makeCoverage(["A", "B", "C"]),
"GlyphCount": 3,
"Substitute": ["c", "b", "a"]
}
table.postRead(rawTable, self.font)
self.assertEqual(table.mapping, {"A": "c", "B": "b", "C": "a"})
def test_postRead_formatUnknown(self):
table = otTables.SingleSubst()
table.Format = 987
rawTable = {"Coverage": makeCoverage(["A", "B", "C"])}
self.assertRaises(AssertionError, table.postRead, rawTable, self.font)
def test_preWrite_format1(self):
table = otTables.SingleSubst()
table.mapping = {"A": "a", "B": "b", "C": "c"}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 1)
self.assertEqual(rawTable["Coverage"].glyphs, ["A", "B", "C"])
self.assertEqual(rawTable["DeltaGlyphID"], 5)
def test_preWrite_format2(self):
table = otTables.SingleSubst()
table.mapping = {"A": "c", "B": "b", "C": "a"}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 2)
self.assertEqual(rawTable["Coverage"].glyphs, ["A", "B", "C"])
self.assertEqual(rawTable["Substitute"], ["c", "b", "a"])
def test_preWrite_emptyMapping(self):
table = otTables.SingleSubst()
table.mapping = {}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 2)
self.assertEqual(rawTable["Coverage"].glyphs, [])
self.assertEqual(rawTable["Substitute"], [])
def test_toXML2(self):
writer = XMLWriter(StringIO())
table = otTables.SingleSubst()
table.mapping = {"A": "a", "B": "b", "C": "c"}
table.toXML2(writer, self.font)
self.assertEqual(writer.file.getvalue().splitlines()[1:], [
'<Substitution in="A" out="a"/>',
'<Substitution in="B" out="b"/>',
'<Substitution in="C" out="c"/>',
])
def test_fromXML(self):
table = otTables.SingleSubst()
for name, attrs, content in parseXML(
'<Substitution in="A" out="a"/>'
'<Substitution in="B" out="b"/>'
'<Substitution in="C" out="c"/>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(table.mapping, {"A": "a", "B": "b", "C": "c"})
class MultipleSubstTest(unittest.TestCase):
def setUp(self):
self.glyphs = ".notdef c f i t c_t f_f_i".split()
self.font = FakeFont(self.glyphs)
def test_postRead_format1(self):
makeSequence = otTables.MultipleSubst.makeSequence_
table = otTables.MultipleSubst()
table.Format = 1
rawTable = {
"Coverage": makeCoverage(["c_t", "f_f_i"]),
"Sequence": [
makeSequence(["c", "t"]),
makeSequence(["f", "f", "i"])
]
}
table.postRead(rawTable, self.font)
self.assertEqual(table.mapping, {
"c_t": ["c", "t"],
"f_f_i": ["f", "f", "i"]
})
def test_postRead_formatUnknown(self):
table = otTables.MultipleSubst()
table.Format = 987
self.assertRaises(AssertionError, table.postRead, {}, self.font)
def test_preWrite_format1(self):
table = otTables.MultipleSubst()
table.mapping = {"c_t": ["c", "t"], "f_f_i": ["f", "f", "i"]}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 1)
self.assertEqual(rawTable["Coverage"].glyphs, ["c_t", "f_f_i"])
def test_toXML2(self):
writer = XMLWriter(StringIO())
table = otTables.MultipleSubst()
table.mapping = {"c_t": ["c", "t"], "f_f_i": ["f", "f", "i"]}
table.toXML2(writer, self.font)
self.assertEqual(writer.file.getvalue().splitlines()[1:], [
'<Substitution in="c_t" out="c,t"/>',
'<Substitution in="f_f_i" out="f,f,i"/>',
])
def test_fromXML(self):
table = otTables.MultipleSubst()
for name, attrs, content in parseXML(
'<Substitution in="c_t" out="c,t"/>'
'<Substitution in="f_f_i" out="f,f,i"/>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(table.mapping,
{'c_t': ['c', 't'], 'f_f_i': ['f', 'f', 'i']})
def test_fromXML_oldFormat(self):
table = otTables.MultipleSubst()
for name, attrs, content in parseXML(
'<Coverage>'
' <Glyph value="c_t"/>'
' <Glyph value="f_f_i"/>'
'</Coverage>'
'<Sequence index="0">'
' <Substitute index="0" value="c"/>'
' <Substitute index="1" value="t"/>'
'</Sequence>'
'<Sequence index="1">'
' <Substitute index="0" value="f"/>'
' <Substitute index="1" value="f"/>'
' <Substitute index="2" value="i"/>'
'</Sequence>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(table.mapping,
{'c_t': ['c', 't'], 'f_f_i': ['f', 'f', 'i']})
def test_fromXML_oldFormat_bug385(self):
# https://github.com/fonttools/fonttools/issues/385
table = otTables.MultipleSubst()
table.Format = 1
for name, attrs, content in parseXML(
'<Coverage Format="1">'
' <Glyph value="o"/>'
' <Glyph value="l"/>'
'</Coverage>'
'<Sequence>'
' <Substitute value="o"/>'
' <Substitute value="l"/>'
' <Substitute value="o"/>'
'</Sequence>'
'<Sequence>'
' <Substitute value="o"/>'
'</Sequence>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(table.mapping,
{'o': ['o', 'l', 'o'], 'l': ['o']})
class LigatureSubstTest(unittest.TestCase):
def setUp(self):
self.glyphs = ".notdef c f i t c_t f_f f_i f_f_i".split()
self.font = FakeFont(self.glyphs)
def makeLigature(self, s):
"""'ffi' --> Ligature(LigGlyph='f_f_i', Component=['f', 'f', 'i'])"""
lig = otTables.Ligature()
lig.Component = list(s)
lig.LigGlyph = "_".join(lig.Component)
return lig
def makeLigatures(self, s):
"""'ffi fi' --> [otTables.Ligature, otTables.Ligature]"""
return [self.makeLigature(lig) for lig in s.split()]
def test_postRead_format1(self):
table = otTables.LigatureSubst()
table.Format = 1
ligs_c = otTables.LigatureSet()
ligs_c.Ligature = self.makeLigatures("ct")
ligs_f = otTables.LigatureSet()
ligs_f.Ligature = self.makeLigatures("ffi ff fi")
rawTable = {
"Coverage": makeCoverage(["c", "f"]),
"LigatureSet": [ligs_c, ligs_f]
}
table.postRead(rawTable, self.font)
self.assertEqual(set(table.ligatures.keys()), {"c", "f"})
self.assertEqual(len(table.ligatures["c"]), 1)
self.assertEqual(table.ligatures["c"][0].LigGlyph, "c_t")
self.assertEqual(table.ligatures["c"][0].Component, ["c", "t"])
self.assertEqual(len(table.ligatures["f"]), 3)
self.assertEqual(table.ligatures["f"][0].LigGlyph, "f_f_i")
self.assertEqual(table.ligatures["f"][0].Component, ["f", "f", "i"])
self.assertEqual(table.ligatures["f"][1].LigGlyph, "f_f")
self.assertEqual(table.ligatures["f"][1].Component, ["f", "f"])
self.assertEqual(table.ligatures["f"][2].LigGlyph, "f_i")
self.assertEqual(table.ligatures["f"][2].Component, ["f", "i"])
def test_postRead_formatUnknown(self):
table = otTables.LigatureSubst()
table.Format = 987
rawTable = {"Coverage": makeCoverage(["f"])}
self.assertRaises(AssertionError, table.postRead, rawTable, self.font)
def test_preWrite_format1(self):
table = otTables.LigatureSubst()
table.ligatures = {
"c": self.makeLigatures("ct"),
"f": self.makeLigatures("ffi ff fi")
}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 1)
self.assertEqual(rawTable["Coverage"].glyphs, ["c", "f"])
[c, f] = rawTable["LigatureSet"]
self.assertIsInstance(c, otTables.LigatureSet)
self.assertIsInstance(f, otTables.LigatureSet)
[ct] = c.Ligature
self.assertIsInstance(ct, otTables.Ligature)
self.assertEqual(ct.LigGlyph, "c_t")
self.assertEqual(ct.Component, ["c", "t"])
[ffi, ff, fi] = f.Ligature
self.assertIsInstance(ffi, otTables.Ligature)
self.assertEqual(ffi.LigGlyph, "f_f_i")
self.assertEqual(ffi.Component, ["f", "f", "i"])
self.assertIsInstance(ff, otTables.Ligature)
self.assertEqual(ff.LigGlyph, "f_f")
self.assertEqual(ff.Component, ["f", "f"])
self.assertIsInstance(fi, otTables.Ligature)
self.assertEqual(fi.LigGlyph, "f_i")
self.assertEqual(fi.Component, ["f", "i"])
def test_toXML2(self):
writer = XMLWriter(StringIO())
table = otTables.LigatureSubst()
table.ligatures = {
"c": self.makeLigatures("ct"),
"f": self.makeLigatures("ffi ff fi")
}
table.toXML2(writer, self.font)
self.assertEqual(writer.file.getvalue().splitlines()[1:], [
'<LigatureSet glyph="c">',
' <Ligature components="c,t" glyph="c_t"/>',
'</LigatureSet>',
'<LigatureSet glyph="f">',
' <Ligature components="f,f,i" glyph="f_f_i"/>',
' <Ligature components="f,f" glyph="f_f"/>',
' <Ligature components="f,i" glyph="f_i"/>',
'</LigatureSet>'
])
def test_fromXML(self):
table = otTables.LigatureSubst()
for name, attrs, content in parseXML(
'<LigatureSet glyph="f">'
' <Ligature components="f,f,i" glyph="f_f_i"/>'
' <Ligature components="f,f" glyph="f_f"/>'
'</LigatureSet>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(set(table.ligatures.keys()), {"f"})
[ffi, ff] = table.ligatures["f"]
self.assertEqual(ffi.LigGlyph, "f_f_i")
self.assertEqual(ffi.Component, ["f", "f", "i"])
self.assertEqual(ff.LigGlyph, "f_f")
self.assertEqual(ff.Component, ["f", "f"])
class AlternateSubstTest(unittest.TestCase):
def setUp(self):
self.glyphs = ".notdef G G.alt1 G.alt2 Z Z.fina".split()
self.font = FakeFont(self.glyphs)
def makeAlternateSet(self, s):
result = otTables.AlternateSet()
result.Alternate = s.split()
return result
def test_postRead_format1(self):
table = otTables.AlternateSubst()
table.Format = 1
rawTable = {
"Coverage": makeCoverage(["G", "Z"]),
"AlternateSet": [
self.makeAlternateSet("G.alt2 G.alt1"),
self.makeAlternateSet("Z.fina")
]
}
table.postRead(rawTable, self.font)
self.assertEqual(table.alternates, {
"G": ["G.alt2", "G.alt1"],
"Z": ["Z.fina"]
})
def test_postRead_formatUnknown(self):
table = otTables.AlternateSubst()
table.Format = 987
self.assertRaises(AssertionError, table.postRead, {}, self.font)
def test_preWrite_format1(self):
table = otTables.AlternateSubst()
table.alternates = {"G": ["G.alt2", "G.alt1"], "Z": ["Z.fina"]}
rawTable = table.preWrite(self.font)
self.assertEqual(table.Format, 1)
self.assertEqual(rawTable["Coverage"].glyphs, ["G", "Z"])
[g, z] = rawTable["AlternateSet"]
self.assertIsInstance(g, otTables.AlternateSet)
self.assertEqual(g.Alternate, ["G.alt2", "G.alt1"])
self.assertIsInstance(z, otTables.AlternateSet)
self.assertEqual(z.Alternate, ["Z.fina"])
def test_toXML2(self):
writer = XMLWriter(StringIO())
table = otTables.AlternateSubst()
table.alternates = {"G": ["G.alt2", "G.alt1"], "Z": ["Z.fina"]}
table.toXML2(writer, self.font)
self.assertEqual(writer.file.getvalue().splitlines()[1:], [
'<AlternateSet glyph="G">',
' <Alternate glyph="G.alt2"/>',
' <Alternate glyph="G.alt1"/>',
'</AlternateSet>',
'<AlternateSet glyph="Z">',
' <Alternate glyph="Z.fina"/>',
'</AlternateSet>'
])
def test_fromXML(self):
table = otTables.AlternateSubst()
for name, attrs, content in parseXML(
'<AlternateSet glyph="G">'
' <Alternate glyph="G.alt2"/>'
' <Alternate glyph="G.alt1"/>'
'</AlternateSet>'
'<AlternateSet glyph="Z">'
' <Alternate glyph="Z.fina"/>'
'</AlternateSet>'):
table.fromXML(name, attrs, content, self.font)
self.assertEqual(table.alternates, {
"G": ["G.alt2", "G.alt1"],
"Z": ["Z.fina"]
})
class RearrangementMorphActionTest(unittest.TestCase):
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C'])
def testCompile(self):
r = otTables.RearrangementMorphAction()
r.NewState = 0x1234
r.MarkFirst = r.DontAdvance = r.MarkLast = True
r.ReservedFlags, r.Verb = 0x1FF0, 0xD
writer = OTTableWriter()
r.compile(writer, self.font, actionIndex=None)
self.assertEqual(hexStr(writer.getAllData()), "1234fffd")
def testCompileActions(self):
act = otTables.RearrangementMorphAction()
self.assertEqual(act.compileActions(self.font, []), (None, None))
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>',
])
class ContextualMorphActionTest(unittest.TestCase):
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C'])
def testCompile(self):
a = otTables.ContextualMorphAction()
a.NewState = 0x1234
a.SetMark, a.DontAdvance, a.ReservedFlags = True, True, 0x3117
a.MarkIndex, a.CurrentIndex = 0xDEAD, 0xBEEF
writer = OTTableWriter()
a.compile(writer, self.font, actionIndex=None)
self.assertEqual(hexStr(writer.getAllData()), "1234f117deadbeef")
def testCompileActions(self):
act = otTables.ContextualMorphAction()
self.assertEqual(act.compileActions(self.font, []), (None, None))
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>',
])
class LigatureMorphActionTest(unittest.TestCase):
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C'])
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 testCompileActions_empty(self):
act = otTables.LigatureMorphAction()
actions, actionIndex = act.compileActions(self.font, [])
self.assertEqual(actions, b'')
self.assertEqual(actionIndex, {})
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,
})
class InsertionMorphActionTest(unittest.TestCase):
MORPH_ACTION_XML = [
'<Transition Test="Foo">',
' <NewState value="4660"/>', # 0x1234 = 4660
' <Flags value="SetMark,DontAdvance,CurrentIsKashidaLike,'
'MarkedIsKashidaLike,CurrentInsertBefore,MarkedInsertBefore"/>',
' <CurrentInsertionAction glyph="B"/>',
' <CurrentInsertionAction glyph="C"/>',
' <MarkedInsertionAction glyph="B"/>',
' <MarkedInsertionAction glyph="A"/>',
' <MarkedInsertionAction glyph="D"/>',
'</Transition>'
]
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C', 'D'])
self.maxDiff = None
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 testCompileFromXML(self):
a = otTables.InsertionMorphAction()
for name, attrs, content in parseXML(self.MORPH_ACTION_XML):
a.fromXML(name, attrs, content, self.font)
writer = OTTableWriter()
a.compile(writer, self.font,
actionIndex={('B', 'C'): 9, ('B', 'A', 'D'): 7})
self.assertEqual(hexStr(writer.getAllData()), "1234fc4300090007")
def testCompileActions_empty(self):
act = otTables.InsertionMorphAction()
actions, actionIndex = act.compileActions(self.font, [])
self.assertEqual(actions, b'')
self.assertEqual(actionIndex, {})
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_splitMarkBasePos():
from fontTools.otlLib.builder import buildAnchor, buildMarkBasePosSubtable
marks = {
"acutecomb": (0, buildAnchor(0, 600)),
"gravecomb": (0, buildAnchor(0, 590)),
"cedillacomb": (1, buildAnchor(0, 0)),
}
bases = {
"a": {
0: buildAnchor(350, 500),
1: None,
},
"c": {
0: buildAnchor(300, 700),
1: buildAnchor(300, 0),
},
}
glyphOrder = ["a", "c", "acutecomb", "gravecomb", "cedillacomb"]
glyphMap = {g: i for i, g in enumerate(glyphOrder)}
oldSubTable = buildMarkBasePosSubtable(marks, bases, glyphMap)
oldSubTable.MarkCoverage.Format = oldSubTable.BaseCoverage.Format = 1
newSubTable = otTables.MarkBasePos()
ok = otTables.splitMarkBasePos(oldSubTable, newSubTable, overflowRecord=None)
assert ok
assert oldSubTable.Format == newSubTable.Format
assert oldSubTable.MarkCoverage.glyphs == [
"acutecomb", "gravecomb"
]
assert newSubTable.MarkCoverage.glyphs == ["cedillacomb"]
assert newSubTable.MarkCoverage.Format == 1
assert oldSubTable.BaseCoverage.glyphs == newSubTable.BaseCoverage.glyphs
assert newSubTable.BaseCoverage.Format == 1
assert oldSubTable.ClassCount == newSubTable.ClassCount == 1
assert oldSubTable.MarkArray.MarkCount == 2
assert newSubTable.MarkArray.MarkCount == 1
assert oldSubTable.BaseArray.BaseCount == newSubTable.BaseArray.BaseCount
assert newSubTable.BaseArray.BaseRecord[0].BaseAnchor[0] is None
assert newSubTable.BaseArray.BaseRecord[1].BaseAnchor[0] == buildAnchor(300, 0)
if __name__ == "__main__":
import sys
sys.exit(unittest.main())