aboutsummaryrefslogtreecommitdiff
path: root/Tests/ttLib/tables/otConverters_test.py
diff options
context:
space:
mode:
Diffstat (limited to 'Tests/ttLib/tables/otConverters_test.py')
-rw-r--r--Tests/ttLib/tables/otConverters_test.py382
1 files changed, 227 insertions, 155 deletions
diff --git a/Tests/ttLib/tables/otConverters_test.py b/Tests/ttLib/tables/otConverters_test.py
index 1aff03bd..94b62a1f 100644
--- a/Tests/ttLib/tables/otConverters_test.py
+++ b/Tests/ttLib/tables/otConverters_test.py
@@ -22,8 +22,10 @@ class Char64Test(unittest.TestCase):
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])
+ self.assertIn(
+ 'replaced non-ASCII characters in "Hello � world"',
+ [r.msg for r in captor.records],
+ )
def test_write(self):
writer = OTTableWriter()
@@ -35,16 +37,20 @@ class Char64Test(unittest.TestCase):
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])
+ 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])
+ 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)
@@ -52,20 +58,23 @@ class Char64Test(unittest.TestCase):
def test_xmlWrite(self):
writer = makeXMLWriter()
- self.converter.xmlWrite(writer, self.font, "Hello world", "Element",
- [("attr", "v")])
+ 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)
+ 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(
+ self.converter.readArray(reader, self.font, {}, 4),
+ ["B", "A", "glyph57005", "B"],
+ )
self.assertEqual(reader.pos, 8)
def test_read(self):
@@ -81,7 +90,7 @@ class GlyphIDTest(unittest.TestCase):
class LongTest(unittest.TestCase):
font = FakeFont([])
- converter = otConverters.Long('Long', 0, None, None)
+ converter = otConverters.Long("Long", 0, None, None)
def test_read(self):
reader = OTTableReader(deHexStr("FF0000EE"))
@@ -105,12 +114,12 @@ class LongTest(unittest.TestCase):
class NameIDTest(unittest.TestCase):
- converter = otConverters.NameID('NameID', 0, None, None)
+ 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)
+ nameTable = newTable("name")
+ nameTable.setName("Demibold Condensed", 0x123, 3, 0, 0x409)
+ nameTable.setName("Copyright 2018", 0, 3, 0, 0x409)
return {"name": nameTable}
def test_read(self):
@@ -125,33 +134,36 @@ class NameIDTest(unittest.TestCase):
def test_xmlWrite(self):
writer = makeXMLWriter()
- self.converter.xmlWrite(writer, self.makeFont(), 291,
- "FooNameID", [("attr", "val")])
+ 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 -->')
+ 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])
+ 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 -->')
+ '<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")])
+ 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"/>')
+ self.assertEqual(xml, '<FooNameID attr="val" value="0"/>')
class UInt8Test(unittest.TestCase):
@@ -181,8 +193,9 @@ class UInt8Test(unittest.TestCase):
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)
+ converter = otConverters.AATLookup(
+ "AATLookup", 0, None, tableClass=otConverters.GlyphID
+ )
def __init__(self, methodName):
unittest.TestCase.__init__(self, methodName)
@@ -193,170 +206,228 @@ class AATLookupTest(unittest.TestCase):
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"
- })
+ 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",
- })
+ 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",
- })
+ 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",
- })
+ 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",
- })
+ reader = OTTableReader(
+ deHexStr("0008 " "0003 0003 " "0007 0001 0002") # first: C, count: 3
+ ) # [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)
+ 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.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>
- ))
+ 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>
- ))
+ 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]
- ))
+ 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)
+ 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")])
+ 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>',
- ])
+ 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[:]
@@ -426,4 +497,5 @@ class LazyListTest(unittest.TestCase):
if __name__ == "__main__":
import sys
+
sys.exit(unittest.main())
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-05 19:10:16 +0000