def makeFont(self, variations):
glyphs = [".notdef", "space", "I"]
Axis = getTableModule("fvar").Axis
Glyph = getTableModule("glyf").Glyph
glyf, fvar, gvar = newTable("glyf"), newTable("fvar"), newTable("gvar")
font = FakeFont(glyphs)
font.tables = {"glyf": glyf, "gvar": gvar, "fvar": fvar}
glyf.glyphs = {glyph: Glyph() for glyph in glyphs}
glyf.glyphs["I"].coordinates = [(10, 10), (10, 20), (20, 20), (20, 10)]
fvar.axes = [Axis(), Axis()]
fvar.axes[0].axisTag, fvar.axes[1].axisTag = "wght", "wdth"
gvar.variations = variations
return font, gvar
class AATLookupTest(unittest.TestCase):
font = FakeFont(".notdef A B C D E F G H A.alt B.alt".split())
converter = otConverters.AATLookup("AATLookup",
0,
None,
tableClass=otConverters.GlyphID)
def __init__(self, methodName):
unittest.TestCase.__init__(self, methodName)
# Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
# and fires deprecation warnings if a program uses the old name.
if not hasattr(self, "assertRaisesRegex"):
self.assertRaisesRegex = self.assertRaisesRegexp
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_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_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_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_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_readUnknownFormat(self):
reader = OTTableReader(deHexStr("0009"))
self.assertRaisesRegex(AssertionError, "unsupported lookup format: 9",
self.converter.read, reader, self.font, None)
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_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_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_xmlRead(self):
value = self.converter.xmlRead({}, [
("Lookup", {
"glyph": "A",
"value": "A.alt"
}, []),
("Lookup", {
"glyph": "B",
"value": "B.alt"
}, []),
], self.font)
self.assertEqual(value, {"A": "A.alt", "B": "B.alt"})
def test_xmlWrite(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer,
self.font,
value={
"A": "A.alt",
"B": "B.alt"
},
name="Foo",
attrs=[("attr", "val")])
xml = writer.file.getvalue().decode("utf-8").splitlines()
self.assertEqual(xml, [
'<Foo attr="val">',
' <Lookup glyph="A" value="A.alt"/>',
' <Lookup glyph="B" value="B.alt"/>',
'</Foo>',
])
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C', 'D'])
self.maxDiff = None
def test_decompile_toXML_version_1_1(self):
table = newTable('STAT')
table.decompile(STAT_DATA_VERSION_1_1,
font=FakeFont(['.notdef']))
self.assertEqual(getXML(table.toXML), STAT_XML_VERSION_1_1)
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.notdef'] + ['g.%d' % i for i in range (1, 910)])
def setUp(self):
self.glyphs = ".notdef G G.alt1 G.alt2 Z Z.fina".split()
self.font = FakeFont(self.glyphs)
def setUp(self):
self.glyphs = ".notdef A B C D E a b c d e".split()
self.font = FakeFont(self.glyphs)
def overflowing_font():
return FakeFont(["glyph%i" % i for i in range(105)])
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.nodef', 'A', 'B', 'C'])
def setUpClass(cls):
cls.maxDiff = None
glyphs = ['.notdef'] + ['g.%d' % i for i in range(1, 140)]
glyphs[11], glyphs[13] = 'parenleft', 'parenright'
glyphs[135], glyphs[136] = 'parenleft.vertical', 'parenright.vertical'
cls.font = FakeFont(glyphs)
def setUpClass(cls):
cls.maxDiff = None
glyphs = ['.notdef'] + ['X.alt%d' for g in range(1, 50)]
glyphs[10] = 'C'
glyphs[43] = 'A'
cls.font = FakeFont(glyphs)
def test_compile_fromXML_version_1_1(self):
table = newTable('STAT')
font = FakeFont(['.notdef'])
for name, attrs, content in parseXML(STAT_XML_VERSION_1_1):
table.fromXML(name, attrs, content, font=font)
self.assertEqual(table.compile(font), STAT_DATA_VERSION_1_1)
def test_compile_fromXML_format3(self):
table = newTable('STAT')
font = FakeFont(['.notdef'])
for name, attrs, content in parseXML(STAT_XML_AXIS_VALUE_FORMAT3):
table.fromXML(name, attrs, content, font=font)
self.assertEqual(table.compile(font), STAT_DATA_AXIS_VALUE_FORMAT3)
def test_compile_fromXML_withAxisJunk(self):
table = newTable('STAT')
font = FakeFont(['.notdef'])
for name, attrs, content in parseXML(STAT_XML_WITH_AXIS_JUNK):
table.fromXML(name, attrs, content, font=font)
self.assertEqual(table.compile(font), STAT_DATA_WITH_AXIS_JUNK)
def setUp(self):
self.font = FakeFont(['.notdef', 'meh'])
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.notdef'] +
[g for g in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'])
def font():
return FakeFont(list("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"))
def test_decompile_toXML(self):
table = newTable('STAT')
table.decompile(STAT_DATA, font=FakeFont(['.notdef']))
self.maxDiff = None
self.assertEqual(getXML(table.toXML), STAT_XML)
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.notdef', 'A', 'B', 'C', 'D', 'E', 'F', 'G'])
def test_decompile_toXML_withAxisJunk(self):
table = newTable('STAT')
table.decompile(STAT_DATA_WITH_AXIS_JUNK, font=FakeFont(['.notdef']))
self.assertEqual(getXML(table.toXML), STAT_XML_WITH_AXIS_JUNK)
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 test_decompile_toXML_format3(self):
table = newTable('STAT')
table.decompile(STAT_DATA_AXIS_VALUE_FORMAT3,
font=FakeFont(['.notdef']))
self.assertEqual(getXML(table.toXML), STAT_XML_AXIS_VALUE_FORMAT3)
def setUp(self):
self.font = FakeFont(['.notdef', 'A', 'B', 'C'])
def setUpClass(cls):
cls.maxDiff = None
cls.font = FakeFont(['.notdef', 'f_r', 'X', 'f_f_l'])
