1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
from __future__ import print_function, division, absolute_import
from fontTools.misc.py23 import *
from fontTools.misc.fixedTools import otRound
from fontTools.ttLib import TTFont, newTable
from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
import sys
import array
import pytest
import re
import os
import unittest
class GlyphCoordinatesTest(object):
def test_translate(self):
g = GlyphCoordinates([(1,2)])
g.translate((.5,0))
assert g == GlyphCoordinates([(1.5,2.0)])
def test_scale(self):
g = GlyphCoordinates([(1,2)])
g.scale((.5,0))
assert g == GlyphCoordinates([(0.5,0.0)])
def test_transform(self):
g = GlyphCoordinates([(1,2)])
g.transform(((.5,0),(.2,.5)))
assert g[0] == GlyphCoordinates([(0.9,1.0)])[0]
def test__eq__(self):
g = GlyphCoordinates([(1,2)])
g2 = GlyphCoordinates([(1.0,2)])
g3 = GlyphCoordinates([(1.5,2)])
assert g == g2
assert not g == g3
assert not g2 == g3
assert not g == object()
def test__ne__(self):
g = GlyphCoordinates([(1,2)])
g2 = GlyphCoordinates([(1.0,2)])
g3 = GlyphCoordinates([(1.5,2)])
assert not (g != g2)
assert g != g3
assert g2 != g3
assert g != object()
def test__pos__(self):
g = GlyphCoordinates([(1,2)])
g2 = +g
assert g == g2
def test__neg__(self):
g = GlyphCoordinates([(1,2)])
g2 = -g
assert g2 == GlyphCoordinates([(-1, -2)])
@pytest.mark.skipif(sys.version_info[0] < 3,
reason="__round___ requires Python 3")
def test__round__(self):
g = GlyphCoordinates([(-1.5,2)])
g2 = round(g)
assert g2 == GlyphCoordinates([(-1,2)])
def test__add__(self):
g1 = GlyphCoordinates([(1,2)])
g2 = GlyphCoordinates([(3,4)])
g3 = GlyphCoordinates([(4,6)])
assert g1 + g2 == g3
assert g1 + (1, 1) == GlyphCoordinates([(2,3)])
with pytest.raises(TypeError) as excinfo:
assert g1 + object()
assert 'unsupported operand' in str(excinfo.value)
def test__sub__(self):
g1 = GlyphCoordinates([(1,2)])
g2 = GlyphCoordinates([(3,4)])
g3 = GlyphCoordinates([(-2,-2)])
assert g1 - g2 == g3
assert g1 - (1, 1) == GlyphCoordinates([(0,1)])
with pytest.raises(TypeError) as excinfo:
assert g1 - object()
assert 'unsupported operand' in str(excinfo.value)
def test__rsub__(self):
g = GlyphCoordinates([(1,2)])
# other + (-self)
assert (1, 1) - g == GlyphCoordinates([(0,-1)])
def test__mul__(self):
g = GlyphCoordinates([(1,2)])
assert g * 3 == GlyphCoordinates([(3,6)])
assert g * (3,2) == GlyphCoordinates([(3,4)])
assert g * (1,1) == g
with pytest.raises(TypeError) as excinfo:
assert g * object()
assert 'unsupported operand' in str(excinfo.value)
def test__truediv__(self):
g = GlyphCoordinates([(1,2)])
assert g / 2 == GlyphCoordinates([(.5,1)])
assert g / (1, 2) == GlyphCoordinates([(1,1)])
assert g / (1, 1) == g
with pytest.raises(TypeError) as excinfo:
assert g / object()
assert 'unsupported operand' in str(excinfo.value)
def test__iadd__(self):
g = GlyphCoordinates([(1,2)])
g += (.5,0)
assert g == GlyphCoordinates([(1.5, 2.0)])
g2 = GlyphCoordinates([(3,4)])
g += g2
assert g == GlyphCoordinates([(4.5, 6.0)])
def test__isub__(self):
g = GlyphCoordinates([(1,2)])
g -= (.5, 0)
assert g == GlyphCoordinates([(0.5, 2.0)])
g2 = GlyphCoordinates([(3,4)])
g -= g2
assert g == GlyphCoordinates([(-2.5, -2.0)])
def __test__imul__(self):
g = GlyphCoordinates([(1,2)])
g *= (2,.5)
g *= 2
assert g == GlyphCoordinates([(4.0, 2.0)])
g = GlyphCoordinates([(1,2)])
g *= 2
assert g == GlyphCoordinates([(2, 4)])
def test__itruediv__(self):
g = GlyphCoordinates([(1,3)])
g /= (.5,1.5)
g /= 2
assert g == GlyphCoordinates([(1.0, 1.0)])
def test__bool__(self):
g = GlyphCoordinates([])
assert bool(g) == False
g = GlyphCoordinates([(0,0), (0.,0)])
assert bool(g) == True
g = GlyphCoordinates([(0,0), (1,0)])
assert bool(g) == True
g = GlyphCoordinates([(0,.5), (0,0)])
assert bool(g) == True
def test_double_precision_float(self):
# https://github.com/fonttools/fonttools/issues/963
afloat = 242.50000000000003
g = GlyphCoordinates([(afloat, 0)])
g.toInt()
# this would return 242 if the internal array.array typecode is 'f',
# since the Python float is truncated to a C float.
# when using typecode 'd' it should return the correct value 243
assert g[0][0] == otRound(afloat)
def test__checkFloat_overflow(self):
g = GlyphCoordinates([(1, 1)], typecode="h")
g.append((0x8000, 0))
assert g.array.typecode == "d"
assert g.array == array.array("d", [1.0, 1.0, 32768.0, 0.0])
CURR_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
DATA_DIR = os.path.join(CURR_DIR, 'data')
GLYF_TTX = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.ttx")
GLYF_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.glyf.bin")
HEAD_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.head.bin")
LOCA_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.loca.bin")
MAXP_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.maxp.bin")
def strip_ttLibVersion(string):
return re.sub(' ttLibVersion=".*"', '', string)
class glyfTableTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
with open(GLYF_BIN, 'rb') as f:
cls.glyfData = f.read()
with open(HEAD_BIN, 'rb') as f:
cls.headData = f.read()
with open(LOCA_BIN, 'rb') as f:
cls.locaData = f.read()
with open(MAXP_BIN, 'rb') as f:
cls.maxpData = f.read()
with open(GLYF_TTX, 'r') as f:
cls.glyfXML = strip_ttLibVersion(f.read()).splitlines()
def test_toXML(self):
font = TTFont(sfntVersion="\x00\x01\x00\x00")
glyfTable = font['glyf'] = newTable('glyf')
font['head'] = newTable('head')
font['loca'] = newTable('loca')
font['maxp'] = newTable('maxp')
font['maxp'].decompile(self.maxpData, font)
font['head'].decompile(self.headData, font)
font['loca'].decompile(self.locaData, font)
glyfTable.decompile(self.glyfData, font)
out = UnicodeIO()
font.saveXML(out)
glyfXML = strip_ttLibVersion(out.getvalue()).splitlines()
self.assertEqual(glyfXML, self.glyfXML)
def test_fromXML(self):
font = TTFont(sfntVersion="\x00\x01\x00\x00")
font.importXML(GLYF_TTX)
glyfTable = font['glyf']
glyfData = glyfTable.compile(font)
self.assertEqual(glyfData, self.glyfData)
if __name__ == "__main__":
import sys
sys.exit(unittest.main())
|
