418 lines
12 KiB
Python
418 lines
12 KiB
Python
from fontTools.ttLib import newTable
|
|
from fontTools.ttLib.tables._k_e_r_n import KernTable_format_0, KernTable_format_unkown
|
|
from fontTools.misc.textTools import deHexStr
|
|
from fontTools.misc.testTools import FakeFont, getXML, parseXML
|
|
import itertools
|
|
import pytest
|
|
|
|
|
|
KERN_VER_0_FMT_0_DATA = deHexStr(
|
|
"0000 " # 0: version=0
|
|
"0001 " # 2: nTables=1
|
|
"0000 " # 4: version=0 (bogus field, unused)
|
|
"0020 " # 6: length=32
|
|
"00 " # 8: format=0
|
|
"01 " # 9: coverage=1
|
|
"0003 " # 10: nPairs=3
|
|
"000C " # 12: searchRange=12
|
|
"0001 " # 14: entrySelector=1
|
|
"0006 " # 16: rangeShift=6
|
|
"0004 000C FFD8 " # 18: l=4, r=12, v=-40
|
|
"0004 001C 0028 " # 24: l=4, r=28, v=40
|
|
"0005 0028 FFCE " # 30: l=5, r=40, v=-50
|
|
)
|
|
assert len(KERN_VER_0_FMT_0_DATA) == 36
|
|
|
|
KERN_VER_0_FMT_0_XML = [
|
|
'<version value="0"/>',
|
|
'<kernsubtable coverage="1" format="0">',
|
|
' <pair l="E" r="M" v="-40"/>',
|
|
' <pair l="E" r="c" v="40"/>',
|
|
' <pair l="F" r="o" v="-50"/>',
|
|
"</kernsubtable>",
|
|
]
|
|
|
|
KERN_VER_1_FMT_0_DATA = deHexStr(
|
|
"0001 0000 " # 0: version=1
|
|
"0000 0001 " # 4: nTables=1
|
|
"0000 0022 " # 8: length=34
|
|
"00 " # 12: coverage=0
|
|
"00 " # 13: format=0
|
|
"0000 " # 14: tupleIndex=0
|
|
"0003 " # 16: nPairs=3
|
|
"000C " # 18: searchRange=12
|
|
"0001 " # 20: entrySelector=1
|
|
"0006 " # 22: rangeShift=6
|
|
"0004 000C FFD8 " # 24: l=4, r=12, v=-40
|
|
"0004 001C 0028 " # 30: l=4, r=28, v=40
|
|
"0005 0028 FFCE " # 36: l=5, r=40, v=-50
|
|
)
|
|
assert len(KERN_VER_1_FMT_0_DATA) == 42
|
|
|
|
KERN_VER_1_FMT_0_XML = [
|
|
'<version value="1.0"/>',
|
|
'<kernsubtable coverage="0" format="0" tupleIndex="0">',
|
|
' <pair l="E" r="M" v="-40"/>',
|
|
' <pair l="E" r="c" v="40"/>',
|
|
' <pair l="F" r="o" v="-50"/>',
|
|
"</kernsubtable>",
|
|
]
|
|
|
|
KERN_VER_0_FMT_UNKNOWN_DATA = deHexStr(
|
|
"0000 " # 0: version=0
|
|
"0002 " # 2: nTables=2
|
|
"0000 " # 4: version=0
|
|
"000A " # 6: length=10
|
|
"04 " # 8: format=4 (format 4 doesn't exist)
|
|
"01 " # 9: coverage=1
|
|
"1234 5678 " # 10: garbage...
|
|
"0000 " # 14: version=0
|
|
"000A " # 16: length=10
|
|
"05 " # 18: format=5 (format 5 doesn't exist)
|
|
"01 " # 19: coverage=1
|
|
"9ABC DEF0 " # 20: garbage...
|
|
)
|
|
assert len(KERN_VER_0_FMT_UNKNOWN_DATA) == 24
|
|
|
|
KERN_VER_0_FMT_UNKNOWN_XML = [
|
|
'<version value="0"/>',
|
|
'<kernsubtable format="4">',
|
|
" <!-- unknown 'kern' subtable format -->",
|
|
" 0000000A 04011234",
|
|
" 5678 ",
|
|
"</kernsubtable>",
|
|
'<kernsubtable format="5">',
|
|
"<!-- unknown 'kern' subtable format -->",
|
|
" 0000000A 05019ABC",
|
|
" DEF0 ",
|
|
"</kernsubtable>",
|
|
]
|
|
|
|
KERN_VER_1_FMT_UNKNOWN_DATA = deHexStr(
|
|
"0001 0000 " # 0: version=1
|
|
"0000 0002 " # 4: nTables=2
|
|
"0000 000C " # 8: length=12
|
|
"00 " # 12: coverage=0
|
|
"04 " # 13: format=4 (format 4 doesn't exist)
|
|
"0000 " # 14: tupleIndex=0
|
|
"1234 5678" # 16: garbage...
|
|
"0000 000C " # 20: length=12
|
|
"00 " # 24: coverage=0
|
|
"05 " # 25: format=5 (format 5 doesn't exist)
|
|
"0000 " # 26: tupleIndex=0
|
|
"9ABC DEF0 " # 28: garbage...
|
|
)
|
|
assert len(KERN_VER_1_FMT_UNKNOWN_DATA) == 32
|
|
|
|
KERN_VER_1_FMT_UNKNOWN_XML = [
|
|
'<version value="1"/>',
|
|
'<kernsubtable format="4">',
|
|
" <!-- unknown 'kern' subtable format -->",
|
|
" 0000000C 00040000",
|
|
" 12345678 ",
|
|
"</kernsubtable>",
|
|
'<kernsubtable format="5">',
|
|
" <!-- unknown 'kern' subtable format -->",
|
|
" 0000000C 00050000",
|
|
" 9ABCDEF0 ",
|
|
"</kernsubtable>",
|
|
]
|
|
|
|
KERN_VER_0_FMT_0_OVERFLOWING_DATA = deHexStr(
|
|
"0000 " # 0: version=0
|
|
"0001 " # 2: nTables=1
|
|
"0000 " # 4: version=0 (bogus field, unused)
|
|
"0274 " # 6: length=628 (bogus value for 66164 % 0x10000)
|
|
"00 " # 8: format=0
|
|
"01 " # 9: coverage=1
|
|
"2B11 " # 10: nPairs=11025
|
|
"C000 " # 12: searchRange=49152
|
|
"000D " # 14: entrySelector=13
|
|
"4266 " # 16: rangeShift=16998
|
|
) + deHexStr(
|
|
" ".join(
|
|
"%04X %04X %04X" % (a, b, 0)
|
|
for (a, b) in itertools.product(range(105), repeat=2)
|
|
)
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def font():
|
|
return FakeFont(list("ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"))
|
|
|
|
|
|
@pytest.fixture
|
|
def overflowing_font():
|
|
return FakeFont(["glyph%i" % i for i in range(105)])
|
|
|
|
|
|
class KernTableTest(object):
|
|
@pytest.mark.parametrize(
|
|
"data, version",
|
|
[
|
|
(KERN_VER_0_FMT_0_DATA, 0),
|
|
(KERN_VER_1_FMT_0_DATA, 1.0),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_decompile_single_format_0(self, data, font, version):
|
|
kern = newTable("kern")
|
|
kern.decompile(data, font)
|
|
|
|
assert kern.version == version
|
|
assert len(kern.kernTables) == 1
|
|
|
|
st = kern.kernTables[0]
|
|
assert st.apple is (version == 1.0)
|
|
assert st.format == 0
|
|
# horizontal kerning in OT kern is coverage 0x01, while in
|
|
# AAT kern it's the default (0)
|
|
assert st.coverage == (0 if st.apple else 1)
|
|
assert st.tupleIndex == (0 if st.apple else None)
|
|
assert len(st.kernTable) == 3
|
|
assert st.kernTable == {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
|
|
|
|
@pytest.mark.parametrize(
|
|
"version, expected",
|
|
[
|
|
(0, KERN_VER_0_FMT_0_DATA),
|
|
(1.0, KERN_VER_1_FMT_0_DATA),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_compile_single_format_0(self, font, version, expected):
|
|
kern = newTable("kern")
|
|
kern.version = version
|
|
apple = version == 1.0
|
|
st = KernTable_format_0(apple)
|
|
kern.kernTables = [st]
|
|
st.coverage = 0 if apple else 1
|
|
st.tupleIndex = 0 if apple else None
|
|
st.kernTable = {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
|
|
data = kern.compile(font)
|
|
assert data == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"xml, version",
|
|
[
|
|
(KERN_VER_0_FMT_0_XML, 0),
|
|
(KERN_VER_1_FMT_0_XML, 1.0),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_fromXML_single_format_0(self, xml, font, version):
|
|
kern = newTable("kern")
|
|
for name, attrs, content in parseXML(xml):
|
|
kern.fromXML(name, attrs, content, ttFont=font)
|
|
|
|
assert kern.version == version
|
|
assert len(kern.kernTables) == 1
|
|
|
|
st = kern.kernTables[0]
|
|
assert st.apple is (version == 1.0)
|
|
assert st.format == 0
|
|
assert st.coverage == (0 if st.apple else 1)
|
|
assert st.tupleIndex == (0 if st.apple else None)
|
|
assert len(st.kernTable) == 3
|
|
assert st.kernTable == {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
|
|
|
|
@pytest.mark.parametrize(
|
|
"version, expected",
|
|
[
|
|
(0, KERN_VER_0_FMT_0_XML),
|
|
(1.0, KERN_VER_1_FMT_0_XML),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_toXML_single_format_0(self, font, version, expected):
|
|
kern = newTable("kern")
|
|
kern.version = version
|
|
apple = version == 1.0
|
|
st = KernTable_format_0(apple)
|
|
kern.kernTables = [st]
|
|
st.coverage = 0 if apple else 1
|
|
st.tupleIndex = 0 if apple else None
|
|
st.kernTable = {("E", "M"): -40, ("E", "c"): 40, ("F", "o"): -50}
|
|
xml = getXML(kern.toXML, font)
|
|
assert xml == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"data, version, header_length, st_length",
|
|
[
|
|
(KERN_VER_0_FMT_UNKNOWN_DATA, 0, 4, 10),
|
|
(KERN_VER_1_FMT_UNKNOWN_DATA, 1.0, 8, 12),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_decompile_format_unknown(
|
|
self, data, font, version, header_length, st_length
|
|
):
|
|
kern = newTable("kern")
|
|
kern.decompile(data, font)
|
|
|
|
assert kern.version == version
|
|
assert len(kern.kernTables) == 2
|
|
|
|
st_data = data[header_length:]
|
|
st0 = kern.kernTables[0]
|
|
assert st0.format == 4
|
|
assert st0.data == st_data[:st_length]
|
|
st_data = st_data[st_length:]
|
|
|
|
st1 = kern.kernTables[1]
|
|
assert st1.format == 5
|
|
assert st1.data == st_data[:st_length]
|
|
|
|
@pytest.mark.parametrize(
|
|
"version, st_length, expected",
|
|
[
|
|
(0, 10, KERN_VER_0_FMT_UNKNOWN_DATA),
|
|
(1.0, 12, KERN_VER_1_FMT_UNKNOWN_DATA),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_compile_format_unknown(self, version, st_length, expected):
|
|
kern = newTable("kern")
|
|
kern.version = version
|
|
kern.kernTables = []
|
|
|
|
for unknown_fmt, kern_data in zip((4, 5), ("1234 5678", "9ABC DEF0")):
|
|
if version > 0:
|
|
coverage = 0
|
|
header_fmt = deHexStr(
|
|
"%08X %02X %02X %04X" % (st_length, coverage, unknown_fmt, 0)
|
|
)
|
|
else:
|
|
coverage = 1
|
|
header_fmt = deHexStr(
|
|
"%04X %04X %02X %02X" % (0, st_length, unknown_fmt, coverage)
|
|
)
|
|
st = KernTable_format_unkown(unknown_fmt)
|
|
st.data = header_fmt + deHexStr(kern_data)
|
|
kern.kernTables.append(st)
|
|
|
|
data = kern.compile(font)
|
|
assert data == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"xml, version, st_length",
|
|
[
|
|
(KERN_VER_0_FMT_UNKNOWN_XML, 0, 10),
|
|
(KERN_VER_1_FMT_UNKNOWN_XML, 1.0, 12),
|
|
],
|
|
ids=["version_0", "version_1"],
|
|
)
|
|
def test_fromXML_format_unknown(self, xml, font, version, st_length):
|
|
kern = newTable("kern")
|
|
for name, attrs, content in parseXML(xml):
|
|
kern.fromXML(name, attrs, content, ttFont=font)
|
|
|
|
assert kern.version == version
|
|
assert len(kern.kernTables) == 2
|
|
|
|
st0 = kern.kernTables[0]
|
|
assert st0.format == 4
|
|
assert len(st0.data) == st_length
|
|
|
|
st1 = kern.kernTables[1]
|
|
assert st1.format == 5
|
|
assert len(st1.data) == st_length
|
|
|
|
@pytest.mark.parametrize("version", [0, 1.0], ids=["version_0", "version_1"])
|
|
def test_toXML_format_unknown(self, font, version):
|
|
kern = newTable("kern")
|
|
kern.version = version
|
|
st = KernTable_format_unkown(4)
|
|
st.data = b"ABCD"
|
|
kern.kernTables = [st]
|
|
|
|
xml = getXML(kern.toXML, font)
|
|
|
|
assert xml == [
|
|
'<version value="%s"/>' % version,
|
|
'<kernsubtable format="4">',
|
|
" <!-- unknown 'kern' subtable format -->",
|
|
" 41424344 ",
|
|
"</kernsubtable>",
|
|
]
|
|
|
|
def test_getkern(self):
|
|
table = newTable("kern")
|
|
table.version = 0
|
|
table.kernTables = []
|
|
|
|
assert table.getkern(0) is None
|
|
|
|
st0 = KernTable_format_0()
|
|
table.kernTables.append(st0)
|
|
|
|
assert table.getkern(0) is st0
|
|
assert table.getkern(4) is None
|
|
|
|
st1 = KernTable_format_unkown(4)
|
|
table.kernTables.append(st1)
|
|
|
|
|
|
class KernTable_format_0_Test(object):
|
|
def test_decompileBadGlyphId(self, font):
|
|
subtable = KernTable_format_0()
|
|
subtable.decompile(
|
|
b"\x00"
|
|
+ b"\x00"
|
|
+ b"\x00"
|
|
+ b"\x1a"
|
|
+ b"\x00"
|
|
+ b"\x00"
|
|
+ b"\x00"
|
|
+ b"\x02"
|
|
+ b"\x00" * 6
|
|
+ b"\x00"
|
|
+ b"\x01"
|
|
+ b"\x00"
|
|
+ b"\x03"
|
|
+ b"\x00"
|
|
+ b"\x01"
|
|
+ b"\x00"
|
|
+ b"\x01"
|
|
+ b"\xFF"
|
|
+ b"\xFF"
|
|
+ b"\x00"
|
|
+ b"\x02",
|
|
font,
|
|
)
|
|
assert subtable[("B", "D")] == 1
|
|
assert subtable[("B", "glyph65535")] == 2
|
|
|
|
def test_compileOverflowingSubtable(self, overflowing_font):
|
|
font = overflowing_font
|
|
kern = newTable("kern")
|
|
kern.version = 0
|
|
st = KernTable_format_0(0)
|
|
kern.kernTables = [st]
|
|
st.coverage = 1
|
|
st.tupleIndex = None
|
|
st.kernTable = {
|
|
(a, b): 0 for (a, b) in itertools.product(font.getGlyphOrder(), repeat=2)
|
|
}
|
|
assert len(st.kernTable) == 11025
|
|
data = kern.compile(font)
|
|
assert data == KERN_VER_0_FMT_0_OVERFLOWING_DATA
|
|
|
|
def test_decompileOverflowingSubtable(self, overflowing_font):
|
|
font = overflowing_font
|
|
data = KERN_VER_0_FMT_0_OVERFLOWING_DATA
|
|
kern = newTable("kern")
|
|
kern.decompile(data, font)
|
|
|
|
st = kern.kernTables[0]
|
|
assert st.kernTable == {
|
|
(a, b): 0 for (a, b) in itertools.product(font.getGlyphOrder(), repeat=2)
|
|
}
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
sys.exit(pytest.main(sys.argv))
|