# coding: utf-8
from __future__ import print_function, division, absolute_import, \
unicode_literals
from fontTools.misc.py23 import *
from fontTools.misc.loggingTools import CapturingLogHandler
from fontTools.misc.testTools import FakeFont, makeXMLWriter
from fontTools.misc.textTools import deHexStr
import fontTools.ttLib.tables.otConverters as otConverters
from fontTools.ttLib import newTable
from fontTools.ttLib.tables.otBase import OTTableReader, OTTableWriter
import unittest
class Char64Test(unittest.TestCase):
font = FakeFont([])
converter = otConverters.Char64("char64", 0, None, None)
def test_read(self):
reader = OTTableReader(b"Hello\0junk after zero byte" + 100 * b"\0")
self.assertEqual(self.converter.read(reader, self.font, {}), "Hello")
self.assertEqual(reader.pos, 64)
def test_read_replace_not_ascii(self):
reader = OTTableReader(b"Hello \xE4 world" + 100 * b"\0")
with CapturingLogHandler(otConverters.log, "WARNING") as captor:
data = self.converter.read(reader, self.font, {})
self.assertEqual(data, "Hello � world")
self.assertEqual(reader.pos, 64)
self.assertIn('replaced non-ASCII characters in "Hello � world"',
[r.msg for r in captor.records])
def test_write(self):
writer = OTTableWriter()
self.converter.write(writer, self.font, {}, "Hello world")
self.assertEqual(writer.getData(), b"Hello world" + 53 * b"\0")
def test_write_replace_not_ascii(self):
writer = OTTableWriter()
with CapturingLogHandler(otConverters.log, "WARNING") as captor:
self.converter.write(writer, self.font, {}, "Hello ☃")
self.assertEqual(writer.getData(), b"Hello ?" + 57 * b"\0")
self.assertIn('replacing non-ASCII characters in "Hello ☃"',
[r.msg for r in captor.records])
def test_write_truncated(self):
writer = OTTableWriter()
with CapturingLogHandler(otConverters.log, "WARNING") as captor:
self.converter.write(writer, self.font, {}, "A" * 80)
self.assertEqual(writer.getData(), b"A" * 64)
self.assertIn('truncating overlong "' + "A" * 80 + '" to 64 bytes',
[r.msg for r in captor.records])
def test_xmlRead(self):
value = self.converter.xmlRead({"value": "Foo"}, [], self.font)
self.assertEqual(value, "Foo")
def test_xmlWrite(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer, self.font, "Hello world", "Element",
[("attr", "v")])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(xml, '<Element attr="v" value="Hello world"/>')
class GlyphIDTest(unittest.TestCase):
font = FakeFont(".notdef A B C".split())
converter = otConverters.GlyphID('GlyphID', 0, None, None)
def test_readArray(self):
reader = OTTableReader(deHexStr("0002 0001 DEAD 0002"))
self.assertEqual(self.converter.readArray(reader, self.font, {}, 4),
["B", "A", "glyph57005", "B"])
self.assertEqual(reader.pos, 8)
def test_read(self):
reader = OTTableReader(deHexStr("0003"))
self.assertEqual(self.converter.read(reader, self.font, {}), "C")
self.assertEqual(reader.pos, 2)
def test_write(self):
writer = OTTableWriter()
self.converter.write(writer, self.font, {}, "B")
self.assertEqual(writer.getData(), deHexStr("0002"))
class LongTest(unittest.TestCase):
font = FakeFont([])
converter = otConverters.Long('Long', 0, None, None)
def test_read(self):
reader = OTTableReader(deHexStr("FF0000EE"))
self.assertEqual(self.converter.read(reader, self.font, {}), -16776978)
self.assertEqual(reader.pos, 4)
def test_write(self):
writer = OTTableWriter()
self.converter.write(writer, self.font, {}, -16777213)
self.assertEqual(writer.getData(), deHexStr("FF000003"))
def test_xmlRead(self):
value = self.converter.xmlRead({"value": "314159"}, [], self.font)
self.assertEqual(value, 314159)
def test_xmlWrite(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer, self.font, 291, "Foo", [("attr", "v")])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(xml, '<Foo attr="v" value="291"/>')
class NameIDTest(unittest.TestCase):
converter = otConverters.NameID('NameID', 0, None, None)
def makeFont(self):
nameTable = newTable('name')
nameTable.setName(u"Demibold Condensed", 0x123, 3, 0, 0x409)
nameTable.setName(u"Copyright 2018", 0, 3, 0, 0x409)
return {"name": nameTable}
def test_read(self):
font = self.makeFont()
reader = OTTableReader(deHexStr("0123"))
self.assertEqual(self.converter.read(reader, font, {}), 0x123)
def test_write(self):
writer = OTTableWriter()
self.converter.write(writer, self.makeFont(), {}, 0x123)
self.assertEqual(writer.getData(), deHexStr("0123"))
def test_xmlWrite(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer, self.makeFont(), 291,
"FooNameID", [("attr", "val")])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(
xml,
'<FooNameID attr="val" value="291"/> <!-- Demibold Condensed -->')
def test_xmlWrite_missingID(self):
writer = makeXMLWriter()
with CapturingLogHandler(otConverters.log, "WARNING") as captor:
self.converter.xmlWrite(writer, self.makeFont(), 666,
"Entity", [("attrib", "val")])
self.assertIn("name id 666 missing from name table",
[r.msg for r in captor.records])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(
xml,
'<Entity attrib="val"'
' value="666"/> <!-- missing from name table -->')
def test_xmlWrite_NULL(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer, self.makeFont(), 0,
"FooNameID", [("attr", "val")])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(
xml, '<FooNameID attr="val" value="0"/>')
class UInt8Test(unittest.TestCase):
font = FakeFont([])
converter = otConverters.UInt8("UInt8", 0, None, None)
def test_read(self):
reader = OTTableReader(deHexStr("FE"))
self.assertEqual(self.converter.read(reader, self.font, {}), 254)
self.assertEqual(reader.pos, 1)
def test_write(self):
writer = OTTableWriter()
self.converter.write(writer, self.font, {}, 253)
self.assertEqual(writer.getData(), deHexStr("FD"))
def test_xmlRead(self):
value = self.converter.xmlRead({"value": "254"}, [], self.font)
self.assertEqual(value, 254)
def test_xmlWrite(self):
writer = makeXMLWriter()
self.converter.xmlWrite(writer, self.font, 251, "Foo", [("attr", "v")])
xml = writer.file.getvalue().decode("utf-8").rstrip()
self.assertEqual(xml, '<Foo attr="v" value="251"/>')
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>',
])
class LazyListTest(unittest.TestCase):
def test_slice(self):
ll = otConverters._LazyList([10, 11, 12, 13])
sl = ll[:]
self.assertIsNot(sl, ll)
self.assertIsInstance(sl, list)
self.assertEqual([10, 11, 12, 13], sl)
self.assertEqual([11, 12], ll[1:3])
def test_getitem(self):
count = 2
reader = OTTableReader(b"\x00\xFE\xFF\x00\x00\x00", offset=1)
converter = otConverters.UInt8("UInt8", 0, None, None)
recordSize = converter.staticSize
l = otConverters._LazyList()
l.reader = reader
l.pos = l.reader.pos
l.font = None
l.conv = converter
l.recordSize = recordSize
l.extend(otConverters._MissingItem([i]) for i in range(count))
reader.advance(count * recordSize)
self.assertEqual(l[0], 254)
self.assertEqual(l[1], 255)
def test_add_both_LazyList(self):
ll1 = otConverters._LazyList([1])
ll2 = otConverters._LazyList([2])
l3 = ll1 + ll2
self.assertIsInstance(l3, list)
self.assertEqual([1, 2], l3)
def test_add_LazyList_and_list(self):
ll1 = otConverters._LazyList([1])
l2 = [2]
l3 = ll1 + l2
self.assertIsInstance(l3, list)
self.assertEqual([1, 2], l3)
def test_add_not_implemented(self):
with self.assertRaises(TypeError):
otConverters._LazyList() + 0
with self.assertRaises(TypeError):
otConverters._LazyList() + tuple()
def test_radd_list_and_LazyList(self):
l1 = [1]
ll2 = otConverters._LazyList([2])
l3 = l1 + ll2
self.assertIsInstance(l3, list)
self.assertEqual([1, 2], l3)
def test_radd_not_implemented(self):
with self.assertRaises(TypeError):
0 + otConverters._LazyList()
with self.assertRaises(TypeError):
tuple() + otConverters._LazyList()
if __name__ == "__main__":
import sys
sys.exit(unittest.main())