Merge pull request #360 from brawer/unittest
[otTables] Add unit tests for SingleSubst, LigatureSubst and AlternatateSubst
This commit is contained in:
Sascha Brawer
commit
83115774f3
272
Lib/fontTools/ttLib/tables/otTables_test.py
Normal file
272
Lib/fontTools/ttLib/tables/otTables_test.py
Normal file
@ -0,0 +1,272 @@
|
||||
from __future__ import print_function, division, absolute_import
|
||||
from fontTools.misc.py23 import *
|
||||
from fontTools.misc.xmlWriter import XMLWriter
|
||||
import fontTools.ttLib.tables.otTables as otTables
|
||||
import unittest
|
||||
|
||||
|
||||
class FakeFont:
|
||||
def __init__(self, glyphs):
|
||||
self.glyphOrder_ = glyphs
|
||||
|
||||
def getGlyphID(self, name):
|
||||
return self.glyphOrder_.index(name)
|
||||
|
||||
def getGlyphName(self, glyphID):
|
||||
return self.glyphOrder_[glyphID]
|
||||
|
||||
|
||||
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_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()
|
||||
table.fromXML("Substitution", {"in": "A", "out": "a"}, [], self.font)
|
||||
table.fromXML("Substitution", {"in": "B", "out": "b"}, [], self.font)
|
||||
table.fromXML("Substitution", {"in": "C", "out": "c"}, [], self.font)
|
||||
self.assertEqual(table.mapping, {"A": "a", "B": "b", "C": "c"})
|
||||
|
||||
|
||||
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()
|
||||
table.fromXML("LigatureSet", {"glyph": "f"}, [
|
||||
("Ligature", {"components": "f,f,i", "glyph": "f_f_i"}, []),
|
||||
("Ligature", {"components": "f,f", "glyph": "f_f"}, []),
|
||||
], 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.alt1 G.alt2"),
|
||||
self.makeAlternateSet("Z.fina")
|
||||
]
|
||||
}
|
||||
table.postRead(rawTable, self.font)
|
||||
self.assertEqual(table.alternates, {
|
||||
"G": ["G.alt1", "G.alt2"],
|
||||
"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.alt1", "G.alt2"], "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.alt1", "G.alt2"])
|
||||
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.alt1", "G.alt2"], "Z": ["Z.fina"]}
|
||||
table.toXML2(writer, self.font)
|
||||
self.assertEqual(writer.file.getvalue().splitlines()[1:], [
|
||||
'<AlternateSet glyph="G">',
|
||||
' <Alternate glyph="G.alt1"/>',
|
||||
' <Alternate glyph="G.alt2"/>',
|
||||
'</AlternateSet>',
|
||||
'<AlternateSet glyph="Z">',
|
||||
' <Alternate glyph="Z.fina"/>',
|
||||
'</AlternateSet>'
|
||||
])
|
||||
|
||||
def test_fromXML(self):
|
||||
table = otTables.AlternateSubst()
|
||||
table.fromXML("AlternateSet", {"glyph": "G"}, [
|
||||
("Alternate", {"glyph": "G.alt1"}, []),
|
||||
("Alternate", {"glyph": "G.alt2"}, [])
|
||||
], self.font)
|
||||
table.fromXML("AlternateSet", {"glyph": "Z"}, [
|
||||
("Alternate", {"glyph": "Z.fina"}, [])
|
||||
], self.font)
|
||||
self.assertEqual(table.alternates, {
|
||||
"G": ["G.alt1", "G.alt2"],
|
||||
"Z": ["Z.fina"]
|
||||
})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Loading…
x
Reference in New Issue
Block a user