xref: /aosp_15_r20/external/fonttools/Tests/ufoLib/UFO2_test.py (revision e1fe3e4ad2793916b15cccdc4a7da52a7e1dd0e9) 
1import os
2import shutil
3import unittest
4import tempfile
5from io import open
6from fontTools.ufoLib import UFOReader, UFOWriter, UFOLibError
7from fontTools.ufoLib import plistlib
8from .testSupport import fontInfoVersion2
9
10
11class TestInfoObject:
12    pass
13
14
15class ReadFontInfoVersion2TestCase(unittest.TestCase):
16    def setUp(self):
17        self.dstDir = tempfile.mktemp()
18        os.mkdir(self.dstDir)
19        metaInfo = {"creator": "test", "formatVersion": 2}
20        path = os.path.join(self.dstDir, "metainfo.plist")
21        with open(path, "wb") as f:
22            plistlib.dump(metaInfo, f)
23
24    def tearDown(self):
25        shutil.rmtree(self.dstDir)
26
27    def _writeInfoToPlist(self, info):
28        path = os.path.join(self.dstDir, "fontinfo.plist")
29        with open(path, "wb") as f:
30            plistlib.dump(info, f)
31
32    def testRead(self):
33        originalData = dict(fontInfoVersion2)
34        self._writeInfoToPlist(originalData)
35        infoObject = TestInfoObject()
36        reader = UFOReader(self.dstDir, validate=True)
37        reader.readInfo(infoObject)
38        readData = {}
39        for attr in list(fontInfoVersion2.keys()):
40            readData[attr] = getattr(infoObject, attr)
41        self.assertEqual(originalData, readData)
42
43    def testGenericRead(self):
44        # familyName
45        info = dict(fontInfoVersion2)
46        info["familyName"] = 123
47        self._writeInfoToPlist(info)
48        reader = UFOReader(self.dstDir, validate=True)
49        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
50        # styleName
51        info = dict(fontInfoVersion2)
52        info["styleName"] = 123
53        self._writeInfoToPlist(info)
54        reader = UFOReader(self.dstDir, validate=True)
55        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
56        # styleMapFamilyName
57        info = dict(fontInfoVersion2)
58        info["styleMapFamilyName"] = 123
59        self._writeInfoToPlist(info)
60        reader = UFOReader(self.dstDir, validate=True)
61        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
62        # styleMapStyleName
63        ## not a string
64        info = dict(fontInfoVersion2)
65        info["styleMapStyleName"] = 123
66        self._writeInfoToPlist(info)
67        reader = UFOReader(self.dstDir, validate=True)
68        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
69        ## out of range
70        info = dict(fontInfoVersion2)
71        info["styleMapStyleName"] = "REGULAR"
72        self._writeInfoToPlist(info)
73        reader = UFOReader(self.dstDir, validate=True)
74        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
75        # versionMajor
76        info = dict(fontInfoVersion2)
77        info["versionMajor"] = "1"
78        self._writeInfoToPlist(info)
79        reader = UFOReader(self.dstDir, validate=True)
80        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
81        # versionMinor
82        info = dict(fontInfoVersion2)
83        info["versionMinor"] = "0"
84        self._writeInfoToPlist(info)
85        reader = UFOReader(self.dstDir, validate=True)
86        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
87        # copyright
88        info = dict(fontInfoVersion2)
89        info["copyright"] = 123
90        self._writeInfoToPlist(info)
91        reader = UFOReader(self.dstDir, validate=True)
92        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
93        # trademark
94        info = dict(fontInfoVersion2)
95        info["trademark"] = 123
96        self._writeInfoToPlist(info)
97        reader = UFOReader(self.dstDir, validate=True)
98        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
99        # unitsPerEm
100        info = dict(fontInfoVersion2)
101        info["unitsPerEm"] = "abc"
102        self._writeInfoToPlist(info)
103        reader = UFOReader(self.dstDir, validate=True)
104        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
105        # descender
106        info = dict(fontInfoVersion2)
107        info["descender"] = "abc"
108        self._writeInfoToPlist(info)
109        reader = UFOReader(self.dstDir, validate=True)
110        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
111        # xHeight
112        info = dict(fontInfoVersion2)
113        info["xHeight"] = "abc"
114        self._writeInfoToPlist(info)
115        reader = UFOReader(self.dstDir, validate=True)
116        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
117        # capHeight
118        info = dict(fontInfoVersion2)
119        info["capHeight"] = "abc"
120        self._writeInfoToPlist(info)
121        reader = UFOReader(self.dstDir, validate=True)
122        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
123        # ascender
124        info = dict(fontInfoVersion2)
125        info["ascender"] = "abc"
126        self._writeInfoToPlist(info)
127        reader = UFOReader(self.dstDir, validate=True)
128        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
129        # italicAngle
130        info = dict(fontInfoVersion2)
131        info["italicAngle"] = "abc"
132        self._writeInfoToPlist(info)
133        reader = UFOReader(self.dstDir, validate=True)
134        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
135
136    def testHeadRead(self):
137        # openTypeHeadCreated
138        ## not a string
139        info = dict(fontInfoVersion2)
140        info["openTypeHeadCreated"] = 123
141        self._writeInfoToPlist(info)
142        reader = UFOReader(self.dstDir, validate=True)
143        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
144        ## invalid format
145        info = dict(fontInfoVersion2)
146        info["openTypeHeadCreated"] = "2000-Jan-01 00:00:00"
147        self._writeInfoToPlist(info)
148        reader = UFOReader(self.dstDir, validate=True)
149        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
150        # openTypeHeadLowestRecPPEM
151        info = dict(fontInfoVersion2)
152        info["openTypeHeadLowestRecPPEM"] = "abc"
153        self._writeInfoToPlist(info)
154        reader = UFOReader(self.dstDir, validate=True)
155        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
156        # openTypeHeadFlags
157        info = dict(fontInfoVersion2)
158        info["openTypeHeadFlags"] = [-1]
159        self._writeInfoToPlist(info)
160        reader = UFOReader(self.dstDir, validate=True)
161        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
162
163    def testHheaRead(self):
164        # openTypeHheaAscender
165        info = dict(fontInfoVersion2)
166        info["openTypeHheaAscender"] = "abc"
167        self._writeInfoToPlist(info)
168        reader = UFOReader(self.dstDir, validate=True)
169        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
170        # openTypeHheaDescender
171        info = dict(fontInfoVersion2)
172        info["openTypeHheaDescender"] = "abc"
173        self._writeInfoToPlist(info)
174        reader = UFOReader(self.dstDir, validate=True)
175        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
176        # openTypeHheaLineGap
177        info = dict(fontInfoVersion2)
178        info["openTypeHheaLineGap"] = "abc"
179        self._writeInfoToPlist(info)
180        reader = UFOReader(self.dstDir, validate=True)
181        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
182        # openTypeHheaCaretSlopeRise
183        info = dict(fontInfoVersion2)
184        info["openTypeHheaCaretSlopeRise"] = "abc"
185        self._writeInfoToPlist(info)
186        reader = UFOReader(self.dstDir, validate=True)
187        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
188        # openTypeHheaCaretSlopeRun
189        info = dict(fontInfoVersion2)
190        info["openTypeHheaCaretSlopeRun"] = "abc"
191        self._writeInfoToPlist(info)
192        reader = UFOReader(self.dstDir, validate=True)
193        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
194        # openTypeHheaCaretOffset
195        info = dict(fontInfoVersion2)
196        info["openTypeHheaCaretOffset"] = "abc"
197        self._writeInfoToPlist(info)
198        reader = UFOReader(self.dstDir, validate=True)
199        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
200
201    def testNameRead(self):
202        # openTypeNameDesigner
203        info = dict(fontInfoVersion2)
204        info["openTypeNameDesigner"] = 123
205        self._writeInfoToPlist(info)
206        reader = UFOReader(self.dstDir, validate=True)
207        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
208        # openTypeNameDesignerURL
209        info = dict(fontInfoVersion2)
210        info["openTypeNameDesignerURL"] = 123
211        self._writeInfoToPlist(info)
212        reader = UFOReader(self.dstDir, validate=True)
213        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
214        # openTypeNameManufacturer
215        info = dict(fontInfoVersion2)
216        info["openTypeNameManufacturer"] = 123
217        self._writeInfoToPlist(info)
218        reader = UFOReader(self.dstDir, validate=True)
219        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
220        # openTypeNameManufacturerURL
221        info = dict(fontInfoVersion2)
222        info["openTypeNameManufacturerURL"] = 123
223        self._writeInfoToPlist(info)
224        reader = UFOReader(self.dstDir, validate=True)
225        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
226        # openTypeNameLicense
227        info = dict(fontInfoVersion2)
228        info["openTypeNameLicense"] = 123
229        self._writeInfoToPlist(info)
230        reader = UFOReader(self.dstDir, validate=True)
231        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
232        # openTypeNameLicenseURL
233        info = dict(fontInfoVersion2)
234        info["openTypeNameLicenseURL"] = 123
235        self._writeInfoToPlist(info)
236        reader = UFOReader(self.dstDir, validate=True)
237        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
238        # openTypeNameVersion
239        info = dict(fontInfoVersion2)
240        info["openTypeNameVersion"] = 123
241        self._writeInfoToPlist(info)
242        reader = UFOReader(self.dstDir, validate=True)
243        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
244        # openTypeNameUniqueID
245        info = dict(fontInfoVersion2)
246        info["openTypeNameUniqueID"] = 123
247        self._writeInfoToPlist(info)
248        reader = UFOReader(self.dstDir, validate=True)
249        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
250        # openTypeNameDescription
251        info = dict(fontInfoVersion2)
252        info["openTypeNameDescription"] = 123
253        self._writeInfoToPlist(info)
254        reader = UFOReader(self.dstDir, validate=True)
255        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
256        # openTypeNamePreferredFamilyName
257        info = dict(fontInfoVersion2)
258        info["openTypeNamePreferredFamilyName"] = 123
259        self._writeInfoToPlist(info)
260        reader = UFOReader(self.dstDir, validate=True)
261        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
262        # openTypeNamePreferredSubfamilyName
263        info = dict(fontInfoVersion2)
264        info["openTypeNamePreferredSubfamilyName"] = 123
265        self._writeInfoToPlist(info)
266        reader = UFOReader(self.dstDir, validate=True)
267        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
268        # openTypeNameCompatibleFullName
269        info = dict(fontInfoVersion2)
270        info["openTypeNameCompatibleFullName"] = 123
271        self._writeInfoToPlist(info)
272        reader = UFOReader(self.dstDir, validate=True)
273        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
274        # openTypeNameSampleText
275        info = dict(fontInfoVersion2)
276        info["openTypeNameSampleText"] = 123
277        self._writeInfoToPlist(info)
278        reader = UFOReader(self.dstDir, validate=True)
279        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
280        # openTypeNameWWSFamilyName
281        info = dict(fontInfoVersion2)
282        info["openTypeNameWWSFamilyName"] = 123
283        self._writeInfoToPlist(info)
284        reader = UFOReader(self.dstDir, validate=True)
285        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
286        # openTypeNameWWSSubfamilyName
287        info = dict(fontInfoVersion2)
288        info["openTypeNameWWSSubfamilyName"] = 123
289        self._writeInfoToPlist(info)
290        reader = UFOReader(self.dstDir, validate=True)
291        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
292
293    def testOS2Read(self):
294        # openTypeOS2WidthClass
295        ## not an int
296        info = dict(fontInfoVersion2)
297        info["openTypeOS2WidthClass"] = "abc"
298        self._writeInfoToPlist(info)
299        reader = UFOReader(self.dstDir, validate=True)
300        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
301        ## out or range
302        info = dict(fontInfoVersion2)
303        info["openTypeOS2WidthClass"] = 15
304        self._writeInfoToPlist(info)
305        reader = UFOReader(self.dstDir, validate=True)
306        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
307        # openTypeOS2WeightClass
308        info = dict(fontInfoVersion2)
309        ## not an int
310        info["openTypeOS2WeightClass"] = "abc"
311        self._writeInfoToPlist(info)
312        reader = UFOReader(self.dstDir, validate=True)
313        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
314        ## out of range
315        info["openTypeOS2WeightClass"] = -50
316        self._writeInfoToPlist(info)
317        reader = UFOReader(self.dstDir, validate=True)
318        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
319        # openTypeOS2Selection
320        info = dict(fontInfoVersion2)
321        info["openTypeOS2Selection"] = [-1]
322        self._writeInfoToPlist(info)
323        reader = UFOReader(self.dstDir, validate=True)
324        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
325        # openTypeOS2VendorID
326        info = dict(fontInfoVersion2)
327        info["openTypeOS2VendorID"] = 1234
328        self._writeInfoToPlist(info)
329        reader = UFOReader(self.dstDir, validate=True)
330        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
331        # openTypeOS2Panose
332        ## not an int
333        info = dict(fontInfoVersion2)
334        info["openTypeOS2Panose"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, str(9)]
335        self._writeInfoToPlist(info)
336        reader = UFOReader(self.dstDir, validate=True)
337        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
338        ## too few values
339        info = dict(fontInfoVersion2)
340        info["openTypeOS2Panose"] = [0, 1, 2, 3]
341        self._writeInfoToPlist(info)
342        reader = UFOReader(self.dstDir, validate=True)
343        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
344        ## too many values
345        info = dict(fontInfoVersion2)
346        info["openTypeOS2Panose"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
347        self._writeInfoToPlist(info)
348        reader = UFOReader(self.dstDir, validate=True)
349        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
350        # openTypeOS2FamilyClass
351        ## not an int
352        info = dict(fontInfoVersion2)
353        info["openTypeOS2FamilyClass"] = [1, str(1)]
354        self._writeInfoToPlist(info)
355        reader = UFOReader(self.dstDir, validate=True)
356        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
357        ## too few values
358        info = dict(fontInfoVersion2)
359        info["openTypeOS2FamilyClass"] = [1]
360        self._writeInfoToPlist(info)
361        reader = UFOReader(self.dstDir, validate=True)
362        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
363        ## too many values
364        info = dict(fontInfoVersion2)
365        info["openTypeOS2FamilyClass"] = [1, 1, 1]
366        self._writeInfoToPlist(info)
367        reader = UFOReader(self.dstDir, validate=True)
368        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
369        ## out of range
370        info = dict(fontInfoVersion2)
371        info["openTypeOS2FamilyClass"] = [1, 201]
372        self._writeInfoToPlist(info)
373        reader = UFOReader(self.dstDir, validate=True)
374        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
375        # openTypeOS2UnicodeRanges
376        ## not an int
377        info = dict(fontInfoVersion2)
378        info["openTypeOS2UnicodeRanges"] = ["0"]
379        self._writeInfoToPlist(info)
380        reader = UFOReader(self.dstDir, validate=True)
381        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
382        ## out of range
383        info = dict(fontInfoVersion2)
384        info["openTypeOS2UnicodeRanges"] = [-1]
385        self._writeInfoToPlist(info)
386        reader = UFOReader(self.dstDir, validate=True)
387        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
388        # openTypeOS2CodePageRanges
389        ## not an int
390        info = dict(fontInfoVersion2)
391        info["openTypeOS2CodePageRanges"] = ["0"]
392        self._writeInfoToPlist(info)
393        reader = UFOReader(self.dstDir, validate=True)
394        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
395        ## out of range
396        info = dict(fontInfoVersion2)
397        info["openTypeOS2CodePageRanges"] = [-1]
398        self._writeInfoToPlist(info)
399        reader = UFOReader(self.dstDir, validate=True)
400        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
401        # openTypeOS2TypoAscender
402        info = dict(fontInfoVersion2)
403        info["openTypeOS2TypoAscender"] = "abc"
404        self._writeInfoToPlist(info)
405        reader = UFOReader(self.dstDir, validate=True)
406        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
407        # openTypeOS2TypoDescender
408        info = dict(fontInfoVersion2)
409        info["openTypeOS2TypoDescender"] = "abc"
410        self._writeInfoToPlist(info)
411        reader = UFOReader(self.dstDir, validate=True)
412        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
413        # openTypeOS2TypoLineGap
414        info = dict(fontInfoVersion2)
415        info["openTypeOS2TypoLineGap"] = "abc"
416        self._writeInfoToPlist(info)
417        reader = UFOReader(self.dstDir, validate=True)
418        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
419        # openTypeOS2WinAscent
420        info = dict(fontInfoVersion2)
421        info["openTypeOS2WinAscent"] = "abc"
422        self._writeInfoToPlist(info)
423        reader = UFOReader(self.dstDir, validate=True)
424        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
425        # openTypeOS2WinDescent
426        info = dict(fontInfoVersion2)
427        info["openTypeOS2WinDescent"] = "abc"
428        self._writeInfoToPlist(info)
429        reader = UFOReader(self.dstDir, validate=True)
430        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
431        # openTypeOS2Type
432        ## not an int
433        info = dict(fontInfoVersion2)
434        info["openTypeOS2Type"] = ["1"]
435        self._writeInfoToPlist(info)
436        reader = UFOReader(self.dstDir, validate=True)
437        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
438        ## out of range
439        info = dict(fontInfoVersion2)
440        info["openTypeOS2Type"] = [-1]
441        self._writeInfoToPlist(info)
442        reader = UFOReader(self.dstDir, validate=True)
443        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
444        # openTypeOS2SubscriptXSize
445        info = dict(fontInfoVersion2)
446        info["openTypeOS2SubscriptXSize"] = "abc"
447        self._writeInfoToPlist(info)
448        reader = UFOReader(self.dstDir, validate=True)
449        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
450        # openTypeOS2SubscriptYSize
451        info = dict(fontInfoVersion2)
452        info["openTypeOS2SubscriptYSize"] = "abc"
453        self._writeInfoToPlist(info)
454        reader = UFOReader(self.dstDir, validate=True)
455        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
456        # openTypeOS2SubscriptXOffset
457        info = dict(fontInfoVersion2)
458        info["openTypeOS2SubscriptXOffset"] = "abc"
459        self._writeInfoToPlist(info)
460        reader = UFOReader(self.dstDir, validate=True)
461        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
462        # openTypeOS2SubscriptYOffset
463        info = dict(fontInfoVersion2)
464        info["openTypeOS2SubscriptYOffset"] = "abc"
465        self._writeInfoToPlist(info)
466        reader = UFOReader(self.dstDir, validate=True)
467        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
468        # openTypeOS2SuperscriptXSize
469        info = dict(fontInfoVersion2)
470        info["openTypeOS2SuperscriptXSize"] = "abc"
471        self._writeInfoToPlist(info)
472        reader = UFOReader(self.dstDir, validate=True)
473        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
474        # openTypeOS2SuperscriptYSize
475        info = dict(fontInfoVersion2)
476        info["openTypeOS2SuperscriptYSize"] = "abc"
477        self._writeInfoToPlist(info)
478        reader = UFOReader(self.dstDir, validate=True)
479        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
480        # openTypeOS2SuperscriptXOffset
481        info = dict(fontInfoVersion2)
482        info["openTypeOS2SuperscriptXOffset"] = "abc"
483        self._writeInfoToPlist(info)
484        reader = UFOReader(self.dstDir, validate=True)
485        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
486        # openTypeOS2SuperscriptYOffset
487        info = dict(fontInfoVersion2)
488        info["openTypeOS2SuperscriptYOffset"] = "abc"
489        self._writeInfoToPlist(info)
490        reader = UFOReader(self.dstDir, validate=True)
491        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
492        # openTypeOS2StrikeoutSize
493        info = dict(fontInfoVersion2)
494        info["openTypeOS2StrikeoutSize"] = "abc"
495        self._writeInfoToPlist(info)
496        reader = UFOReader(self.dstDir, validate=True)
497        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
498        # openTypeOS2StrikeoutPosition
499        info = dict(fontInfoVersion2)
500        info["openTypeOS2StrikeoutPosition"] = "abc"
501        self._writeInfoToPlist(info)
502        reader = UFOReader(self.dstDir, validate=True)
503        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
504
505    def testVheaRead(self):
506        # openTypeVheaVertTypoAscender
507        info = dict(fontInfoVersion2)
508        info["openTypeVheaVertTypoAscender"] = "abc"
509        self._writeInfoToPlist(info)
510        reader = UFOReader(self.dstDir, validate=True)
511        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
512        # openTypeVheaVertTypoDescender
513        info = dict(fontInfoVersion2)
514        info["openTypeVheaVertTypoDescender"] = "abc"
515        self._writeInfoToPlist(info)
516        reader = UFOReader(self.dstDir, validate=True)
517        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
518        # openTypeVheaVertTypoLineGap
519        info = dict(fontInfoVersion2)
520        info["openTypeVheaVertTypoLineGap"] = "abc"
521        self._writeInfoToPlist(info)
522        reader = UFOReader(self.dstDir, validate=True)
523        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
524        # openTypeVheaCaretSlopeRise
525        info = dict(fontInfoVersion2)
526        info["openTypeVheaCaretSlopeRise"] = "abc"
527        self._writeInfoToPlist(info)
528        reader = UFOReader(self.dstDir, validate=True)
529        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
530        # openTypeVheaCaretSlopeRun
531        info = dict(fontInfoVersion2)
532        info["openTypeVheaCaretSlopeRun"] = "abc"
533        self._writeInfoToPlist(info)
534        reader = UFOReader(self.dstDir, validate=True)
535        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
536        # openTypeVheaCaretOffset
537        info = dict(fontInfoVersion2)
538        info["openTypeVheaCaretOffset"] = "abc"
539        self._writeInfoToPlist(info)
540        reader = UFOReader(self.dstDir, validate=True)
541        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
542
543    def testFONDRead(self):
544        # macintoshFONDFamilyID
545        info = dict(fontInfoVersion2)
546        info["macintoshFONDFamilyID"] = "abc"
547        self._writeInfoToPlist(info)
548        reader = UFOReader(self.dstDir, validate=True)
549        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
550        # macintoshFONDName
551        info = dict(fontInfoVersion2)
552        info["macintoshFONDName"] = 123
553        self._writeInfoToPlist(info)
554        reader = UFOReader(self.dstDir, validate=True)
555        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
556
557    def testPostscriptRead(self):
558        # postscriptFontName
559        info = dict(fontInfoVersion2)
560        info["postscriptFontName"] = 123
561        self._writeInfoToPlist(info)
562        reader = UFOReader(self.dstDir, validate=True)
563        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
564        # postscriptFullName
565        info = dict(fontInfoVersion2)
566        info["postscriptFullName"] = 123
567        self._writeInfoToPlist(info)
568        reader = UFOReader(self.dstDir, validate=True)
569        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
570        # postscriptSlantAngle
571        info = dict(fontInfoVersion2)
572        info["postscriptSlantAngle"] = "abc"
573        self._writeInfoToPlist(info)
574        reader = UFOReader(self.dstDir, validate=True)
575        self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject())
576        # postscriptUniqueID
577        info = dict(fontInfoVersion2)
578        info["postscriptUniqueID"] = "abc"
579        self._writeInfoToPlist(info)
580        reader = UFOReader(self.dstDir, validate=True)
581        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
582        # postscriptUnderlineThickness
583        info = dict(fontInfoVersion2)
584        info["postscriptUnderlineThickness"] = "abc"
585        self._writeInfoToPlist(info)
586        reader = UFOReader(self.dstDir, validate=True)
587        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
588        # postscriptUnderlinePosition
589        info = dict(fontInfoVersion2)
590        info["postscriptUnderlinePosition"] = "abc"
591        self._writeInfoToPlist(info)
592        reader = UFOReader(self.dstDir, validate=True)
593        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
594        # postscriptIsFixedPitch
595        info = dict(fontInfoVersion2)
596        info["postscriptIsFixedPitch"] = 2
597        self._writeInfoToPlist(info)
598        reader = UFOReader(self.dstDir, validate=True)
599        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
600        # postscriptBlueValues
601        ## not a list
602        info = dict(fontInfoVersion2)
603        info["postscriptBlueValues"] = "abc"
604        self._writeInfoToPlist(info)
605        reader = UFOReader(self.dstDir, validate=True)
606        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
607        ## uneven value count
608        info = dict(fontInfoVersion2)
609        info["postscriptBlueValues"] = [500]
610        self._writeInfoToPlist(info)
611        reader = UFOReader(self.dstDir, validate=True)
612        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
613        ## too many values
614        info = dict(fontInfoVersion2)
615        info["postscriptBlueValues"] = [
616            10,
617            20,
618            30,
619            40,
620            50,
621            60,
622            70,
623            80,
624            90,
625            100,
626            110,
627            120,
628            130,
629            140,
630            150,
631            160,
632        ]
633        self._writeInfoToPlist(info)
634        reader = UFOReader(self.dstDir, validate=True)
635        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
636        # postscriptOtherBlues
637        ## not a list
638        info = dict(fontInfoVersion2)
639        info["postscriptOtherBlues"] = "abc"
640        self._writeInfoToPlist(info)
641        reader = UFOReader(self.dstDir, validate=True)
642        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
643        ## uneven value count
644        info = dict(fontInfoVersion2)
645        info["postscriptOtherBlues"] = [500]
646        self._writeInfoToPlist(info)
647        reader = UFOReader(self.dstDir, validate=True)
648        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
649        ## too many values
650        info = dict(fontInfoVersion2)
651        info["postscriptOtherBlues"] = [
652            10,
653            20,
654            30,
655            40,
656            50,
657            60,
658            70,
659            80,
660            90,
661            100,
662            110,
663            120,
664            130,
665            140,
666            150,
667            160,
668        ]
669        self._writeInfoToPlist(info)
670        reader = UFOReader(self.dstDir, validate=True)
671        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
672        # postscriptFamilyBlues
673        ## not a list
674        info = dict(fontInfoVersion2)
675        info["postscriptFamilyBlues"] = "abc"
676        self._writeInfoToPlist(info)
677        reader = UFOReader(self.dstDir, validate=True)
678        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
679        ## uneven value count
680        info = dict(fontInfoVersion2)
681        info["postscriptFamilyBlues"] = [500]
682        self._writeInfoToPlist(info)
683        reader = UFOReader(self.dstDir, validate=True)
684        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
685        ## too many values
686        info = dict(fontInfoVersion2)
687        info["postscriptFamilyBlues"] = [
688            10,
689            20,
690            30,
691            40,
692            50,
693            60,
694            70,
695            80,
696            90,
697            100,
698            110,
699            120,
700            130,
701            140,
702            150,
703            160,
704        ]
705        self._writeInfoToPlist(info)
706        reader = UFOReader(self.dstDir, validate=True)
707        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
708        # postscriptFamilyOtherBlues
709        ## not a list
710        info = dict(fontInfoVersion2)
711        info["postscriptFamilyOtherBlues"] = "abc"
712        self._writeInfoToPlist(info)
713        reader = UFOReader(self.dstDir, validate=True)
714        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
715        ## uneven value count
716        info = dict(fontInfoVersion2)
717        info["postscriptFamilyOtherBlues"] = [500]
718        self._writeInfoToPlist(info)
719        reader = UFOReader(self.dstDir, validate=True)
720        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
721        ## too many values
722        info = dict(fontInfoVersion2)
723        info["postscriptFamilyOtherBlues"] = [
724            10,
725            20,
726            30,
727            40,
728            50,
729            60,
730            70,
731            80,
732            90,
733            100,
734            110,
735            120,
736            130,
737            140,
738            150,
739            160,
740        ]
741        self._writeInfoToPlist(info)
742        reader = UFOReader(self.dstDir, validate=True)
743        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
744        # postscriptStemSnapH
745        ## not list
746        info = dict(fontInfoVersion2)
747        info["postscriptStemSnapH"] = "abc"
748        self._writeInfoToPlist(info)
749        reader = UFOReader(self.dstDir, validate=True)
750        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
751        ## too many values
752        info = dict(fontInfoVersion2)
753        info["postscriptStemSnapH"] = [
754            10,
755            20,
756            30,
757            40,
758            50,
759            60,
760            70,
761            80,
762            90,
763            100,
764            110,
765            120,
766            130,
767            140,
768            150,
769            160,
770        ]
771        self._writeInfoToPlist(info)
772        reader = UFOReader(self.dstDir, validate=True)
773        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
774        # postscriptStemSnapV
775        ## not list
776        info = dict(fontInfoVersion2)
777        info["postscriptStemSnapV"] = "abc"
778        self._writeInfoToPlist(info)
779        reader = UFOReader(self.dstDir, validate=True)
780        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
781        ## too many values
782        info = dict(fontInfoVersion2)
783        info["postscriptStemSnapV"] = [
784            10,
785            20,
786            30,
787            40,
788            50,
789            60,
790            70,
791            80,
792            90,
793            100,
794            110,
795            120,
796            130,
797            140,
798            150,
799            160,
800        ]
801        self._writeInfoToPlist(info)
802        reader = UFOReader(self.dstDir, validate=True)
803        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
804        # postscriptBlueFuzz
805        info = dict(fontInfoVersion2)
806        info["postscriptBlueFuzz"] = "abc"
807        self._writeInfoToPlist(info)
808        reader = UFOReader(self.dstDir, validate=True)
809        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
810        # postscriptBlueShift
811        info = dict(fontInfoVersion2)
812        info["postscriptBlueShift"] = "abc"
813        self._writeInfoToPlist(info)
814        reader = UFOReader(self.dstDir, validate=True)
815        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
816        # postscriptBlueScale
817        info = dict(fontInfoVersion2)
818        info["postscriptBlueScale"] = "abc"
819        self._writeInfoToPlist(info)
820        reader = UFOReader(self.dstDir, validate=True)
821        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
822        # postscriptForceBold
823        info = dict(fontInfoVersion2)
824        info["postscriptForceBold"] = "abc"
825        self._writeInfoToPlist(info)
826        reader = UFOReader(self.dstDir, validate=True)
827        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
828        # postscriptDefaultWidthX
829        info = dict(fontInfoVersion2)
830        info["postscriptDefaultWidthX"] = "abc"
831        self._writeInfoToPlist(info)
832        reader = UFOReader(self.dstDir, validate=True)
833        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
834        # postscriptNominalWidthX
835        info = dict(fontInfoVersion2)
836        info["postscriptNominalWidthX"] = "abc"
837        self._writeInfoToPlist(info)
838        reader = UFOReader(self.dstDir, validate=True)
839        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
840        # postscriptWeightName
841        info = dict(fontInfoVersion2)
842        info["postscriptWeightName"] = 123
843        self._writeInfoToPlist(info)
844        reader = UFOReader(self.dstDir, validate=True)
845        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
846        # postscriptDefaultCharacter
847        info = dict(fontInfoVersion2)
848        info["postscriptDefaultCharacter"] = 123
849        self._writeInfoToPlist(info)
850        reader = UFOReader(self.dstDir, validate=True)
851        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
852        # postscriptWindowsCharacterSet
853        info = dict(fontInfoVersion2)
854        info["postscriptWindowsCharacterSet"] = -1
855        self._writeInfoToPlist(info)
856        reader = UFOReader(self.dstDir, validate=True)
857        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
858        # macintoshFONDFamilyID
859        info = dict(fontInfoVersion2)
860        info["macintoshFONDFamilyID"] = "abc"
861        self._writeInfoToPlist(info)
862        reader = UFOReader(self.dstDir, validate=True)
863        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
864        # macintoshFONDName
865        info = dict(fontInfoVersion2)
866        info["macintoshFONDName"] = 123
867        self._writeInfoToPlist(info)
868        reader = UFOReader(self.dstDir, validate=True)
869        self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject())
870
871
872class WriteFontInfoVersion2TestCase(unittest.TestCase):
873    def setUp(self):
874        self.tempDir = tempfile.mktemp()
875        os.mkdir(self.tempDir)
876        self.dstDir = os.path.join(self.tempDir, "test.ufo")
877
878    def tearDown(self):
879        shutil.rmtree(self.tempDir)
880
881    def makeInfoObject(self):
882        infoObject = TestInfoObject()
883        for attr, value in list(fontInfoVersion2.items()):
884            setattr(infoObject, attr, value)
885        return infoObject
886
887    def readPlist(self):
888        path = os.path.join(self.dstDir, "fontinfo.plist")
889        with open(path, "rb") as f:
890            plist = plistlib.load(f)
891        return plist
892
893    def testWrite(self):
894        infoObject = self.makeInfoObject()
895        writer = UFOWriter(self.dstDir, formatVersion=2)
896        writer.writeInfo(infoObject)
897        writtenData = self.readPlist()
898        for attr, originalValue in list(fontInfoVersion2.items()):
899            newValue = writtenData[attr]
900            self.assertEqual(newValue, originalValue)
901
902    def testGenericWrite(self):
903        # familyName
904        infoObject = self.makeInfoObject()
905        infoObject.familyName = 123
906        writer = UFOWriter(self.dstDir, formatVersion=2)
907        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
908        # styleName
909        infoObject = self.makeInfoObject()
910        infoObject.styleName = 123
911        writer = UFOWriter(self.dstDir, formatVersion=2)
912        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
913        # styleMapFamilyName
914        infoObject = self.makeInfoObject()
915        infoObject.styleMapFamilyName = 123
916        writer = UFOWriter(self.dstDir, formatVersion=2)
917        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
918        # styleMapStyleName
919        ## not a string
920        infoObject = self.makeInfoObject()
921        infoObject.styleMapStyleName = 123
922        writer = UFOWriter(self.dstDir, formatVersion=2)
923        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
924        ## out of range
925        infoObject = self.makeInfoObject()
926        infoObject.styleMapStyleName = "REGULAR"
927        writer = UFOWriter(self.dstDir, formatVersion=2)
928        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
929        # versionMajor
930        infoObject = self.makeInfoObject()
931        infoObject.versionMajor = "1"
932        writer = UFOWriter(self.dstDir, formatVersion=2)
933        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
934        # versionMinor
935        infoObject = self.makeInfoObject()
936        infoObject.versionMinor = "0"
937        writer = UFOWriter(self.dstDir, formatVersion=2)
938        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
939        # copyright
940        infoObject = self.makeInfoObject()
941        infoObject.copyright = 123
942        writer = UFOWriter(self.dstDir, formatVersion=2)
943        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
944        # trademark
945        infoObject = self.makeInfoObject()
946        infoObject.trademark = 123
947        writer = UFOWriter(self.dstDir, formatVersion=2)
948        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
949        # unitsPerEm
950        infoObject = self.makeInfoObject()
951        infoObject.unitsPerEm = "abc"
952        writer = UFOWriter(self.dstDir, formatVersion=2)
953        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
954        # descender
955        infoObject = self.makeInfoObject()
956        infoObject.descender = "abc"
957        writer = UFOWriter(self.dstDir, formatVersion=2)
958        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
959        # xHeight
960        infoObject = self.makeInfoObject()
961        infoObject.xHeight = "abc"
962        writer = UFOWriter(self.dstDir, formatVersion=2)
963        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
964        # capHeight
965        infoObject = self.makeInfoObject()
966        infoObject.capHeight = "abc"
967        writer = UFOWriter(self.dstDir, formatVersion=2)
968        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
969        # ascender
970        infoObject = self.makeInfoObject()
971        infoObject.ascender = "abc"
972        writer = UFOWriter(self.dstDir, formatVersion=2)
973        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
974        # italicAngle
975        infoObject = self.makeInfoObject()
976        infoObject.italicAngle = "abc"
977        writer = UFOWriter(self.dstDir, formatVersion=2)
978        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
979
980    def testHeadWrite(self):
981        # openTypeHeadCreated
982        ## not a string
983        infoObject = self.makeInfoObject()
984        infoObject.openTypeHeadCreated = 123
985        writer = UFOWriter(self.dstDir, formatVersion=2)
986        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
987        ## invalid format
988        infoObject = self.makeInfoObject()
989        infoObject.openTypeHeadCreated = "2000-Jan-01 00:00:00"
990        writer = UFOWriter(self.dstDir, formatVersion=2)
991        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
992        # openTypeHeadLowestRecPPEM
993        infoObject = self.makeInfoObject()
994        infoObject.openTypeHeadLowestRecPPEM = "abc"
995        writer = UFOWriter(self.dstDir, formatVersion=2)
996        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
997        # openTypeHeadFlags
998        infoObject = self.makeInfoObject()
999        infoObject.openTypeHeadFlags = [-1]
1000        writer = UFOWriter(self.dstDir, formatVersion=2)
1001        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1002
1003    def testHheaWrite(self):
1004        # openTypeHheaAscender
1005        infoObject = self.makeInfoObject()
1006        infoObject.openTypeHheaAscender = "abc"
1007        writer = UFOWriter(self.dstDir, formatVersion=2)
1008        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1009        # openTypeHheaDescender
1010        infoObject = self.makeInfoObject()
1011        infoObject.openTypeHheaDescender = "abc"
1012        writer = UFOWriter(self.dstDir, formatVersion=2)
1013        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1014        # openTypeHheaLineGap
1015        infoObject = self.makeInfoObject()
1016        infoObject.openTypeHheaLineGap = "abc"
1017        writer = UFOWriter(self.dstDir, formatVersion=2)
1018        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1019        # openTypeHheaCaretSlopeRise
1020        infoObject = self.makeInfoObject()
1021        infoObject.openTypeHheaCaretSlopeRise = "abc"
1022        writer = UFOWriter(self.dstDir, formatVersion=2)
1023        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1024        # openTypeHheaCaretSlopeRun
1025        infoObject = self.makeInfoObject()
1026        infoObject.openTypeHheaCaretSlopeRun = "abc"
1027        writer = UFOWriter(self.dstDir, formatVersion=2)
1028        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1029        # openTypeHheaCaretOffset
1030        infoObject = self.makeInfoObject()
1031        infoObject.openTypeHheaCaretOffset = "abc"
1032        writer = UFOWriter(self.dstDir, formatVersion=2)
1033        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1034
1035    def testNameWrite(self):
1036        # openTypeNameDesigner
1037        infoObject = self.makeInfoObject()
1038        infoObject.openTypeNameDesigner = 123
1039        writer = UFOWriter(self.dstDir, formatVersion=2)
1040        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1041        # openTypeNameDesignerURL
1042        infoObject = self.makeInfoObject()
1043        infoObject.openTypeNameDesignerURL = 123
1044        writer = UFOWriter(self.dstDir, formatVersion=2)
1045        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1046        # openTypeNameManufacturer
1047        infoObject = self.makeInfoObject()
1048        infoObject.openTypeNameManufacturer = 123
1049        writer = UFOWriter(self.dstDir, formatVersion=2)
1050        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1051        # openTypeNameManufacturerURL
1052        infoObject = self.makeInfoObject()
1053        infoObject.openTypeNameManufacturerURL = 123
1054        writer = UFOWriter(self.dstDir, formatVersion=2)
1055        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1056        # openTypeNameLicense
1057        infoObject = self.makeInfoObject()
1058        infoObject.openTypeNameLicense = 123
1059        writer = UFOWriter(self.dstDir, formatVersion=2)
1060        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1061        # openTypeNameLicenseURL
1062        infoObject = self.makeInfoObject()
1063        infoObject.openTypeNameLicenseURL = 123
1064        writer = UFOWriter(self.dstDir, formatVersion=2)
1065        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1066        # openTypeNameVersion
1067        infoObject = self.makeInfoObject()
1068        infoObject.openTypeNameVersion = 123
1069        writer = UFOWriter(self.dstDir, formatVersion=2)
1070        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1071        # openTypeNameUniqueID
1072        infoObject = self.makeInfoObject()
1073        infoObject.openTypeNameUniqueID = 123
1074        writer = UFOWriter(self.dstDir, formatVersion=2)
1075        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1076        # openTypeNameDescription
1077        infoObject = self.makeInfoObject()
1078        infoObject.openTypeNameDescription = 123
1079        writer = UFOWriter(self.dstDir, formatVersion=2)
1080        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1081        # openTypeNamePreferredFamilyName
1082        infoObject = self.makeInfoObject()
1083        infoObject.openTypeNamePreferredFamilyName = 123
1084        writer = UFOWriter(self.dstDir, formatVersion=2)
1085        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1086        # openTypeNamePreferredSubfamilyName
1087        infoObject = self.makeInfoObject()
1088        infoObject.openTypeNamePreferredSubfamilyName = 123
1089        writer = UFOWriter(self.dstDir, formatVersion=2)
1090        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1091        # openTypeNameCompatibleFullName
1092        infoObject = self.makeInfoObject()
1093        infoObject.openTypeNameCompatibleFullName = 123
1094        writer = UFOWriter(self.dstDir, formatVersion=2)
1095        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1096        # openTypeNameSampleText
1097        infoObject = self.makeInfoObject()
1098        infoObject.openTypeNameSampleText = 123
1099        writer = UFOWriter(self.dstDir, formatVersion=2)
1100        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1101        # openTypeNameWWSFamilyName
1102        infoObject = self.makeInfoObject()
1103        infoObject.openTypeNameWWSFamilyName = 123
1104        writer = UFOWriter(self.dstDir, formatVersion=2)
1105        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1106        # openTypeNameWWSSubfamilyName
1107        infoObject = self.makeInfoObject()
1108        infoObject.openTypeNameWWSSubfamilyName = 123
1109        writer = UFOWriter(self.dstDir, formatVersion=2)
1110        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1111
1112    def testOS2Write(self):
1113        # openTypeOS2WidthClass
1114        ## not an int
1115        infoObject = self.makeInfoObject()
1116        infoObject.openTypeOS2WidthClass = "abc"
1117        writer = UFOWriter(self.dstDir, formatVersion=2)
1118        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1119        ## out or range
1120        infoObject = self.makeInfoObject()
1121        infoObject.openTypeOS2WidthClass = 15
1122        writer = UFOWriter(self.dstDir, formatVersion=2)
1123        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1124        # openTypeOS2WeightClass
1125        infoObject = self.makeInfoObject()
1126        ## not an int
1127        infoObject.openTypeOS2WeightClass = "abc"
1128        writer = UFOWriter(self.dstDir, formatVersion=2)
1129        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1130        ## out of range
1131        infoObject.openTypeOS2WeightClass = -50
1132        writer = UFOWriter(self.dstDir, formatVersion=2)
1133        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1134        # openTypeOS2Selection
1135        infoObject = self.makeInfoObject()
1136        infoObject.openTypeOS2Selection = [-1]
1137        writer = UFOWriter(self.dstDir, formatVersion=2)
1138        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1139        # openTypeOS2VendorID
1140        infoObject = self.makeInfoObject()
1141        infoObject.openTypeOS2VendorID = 1234
1142        writer = UFOWriter(self.dstDir, formatVersion=2)
1143        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1144        # openTypeOS2Panose
1145        ## not an int
1146        infoObject = self.makeInfoObject()
1147        infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, str(9)]
1148        writer = UFOWriter(self.dstDir, formatVersion=2)
1149        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1150        ## too few values
1151        infoObject = self.makeInfoObject()
1152        infoObject.openTypeOS2Panose = [0, 1, 2, 3]
1153        writer = UFOWriter(self.dstDir, formatVersion=2)
1154        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1155        ## too many values
1156        infoObject = self.makeInfoObject()
1157        infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1158        writer = UFOWriter(self.dstDir, formatVersion=2)
1159        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1160        # openTypeOS2FamilyClass
1161        ## not an int
1162        infoObject = self.makeInfoObject()
1163        infoObject.openTypeOS2FamilyClass = [0, str(1)]
1164        writer = UFOWriter(self.dstDir, formatVersion=2)
1165        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1166        ## too few values
1167        infoObject = self.makeInfoObject()
1168        infoObject.openTypeOS2FamilyClass = [1]
1169        writer = UFOWriter(self.dstDir, formatVersion=2)
1170        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1171        ## too many values
1172        infoObject = self.makeInfoObject()
1173        infoObject.openTypeOS2FamilyClass = [1, 1, 1]
1174        writer = UFOWriter(self.dstDir, formatVersion=2)
1175        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1176        ## out of range
1177        infoObject = self.makeInfoObject()
1178        infoObject.openTypeOS2FamilyClass = [1, 20]
1179        writer = UFOWriter(self.dstDir, formatVersion=2)
1180        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1181        # openTypeOS2UnicodeRanges
1182        ## not an int
1183        infoObject = self.makeInfoObject()
1184        infoObject.openTypeOS2UnicodeRanges = ["0"]
1185        writer = UFOWriter(self.dstDir, formatVersion=2)
1186        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1187        ## out of range
1188        infoObject = self.makeInfoObject()
1189        infoObject.openTypeOS2UnicodeRanges = [-1]
1190        writer = UFOWriter(self.dstDir, formatVersion=2)
1191        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1192        # openTypeOS2CodePageRanges
1193        ## not an int
1194        infoObject = self.makeInfoObject()
1195        infoObject.openTypeOS2CodePageRanges = ["0"]
1196        writer = UFOWriter(self.dstDir, formatVersion=2)
1197        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1198        ## out of range
1199        infoObject = self.makeInfoObject()
1200        infoObject.openTypeOS2CodePageRanges = [-1]
1201        writer = UFOWriter(self.dstDir, formatVersion=2)
1202        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1203        # openTypeOS2TypoAscender
1204        infoObject = self.makeInfoObject()
1205        infoObject.openTypeOS2TypoAscender = "abc"
1206        writer = UFOWriter(self.dstDir, formatVersion=2)
1207        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1208        # openTypeOS2TypoDescender
1209        infoObject = self.makeInfoObject()
1210        infoObject.openTypeOS2TypoDescender = "abc"
1211        writer = UFOWriter(self.dstDir, formatVersion=2)
1212        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1213        # openTypeOS2TypoLineGap
1214        infoObject = self.makeInfoObject()
1215        infoObject.openTypeOS2TypoLineGap = "abc"
1216        writer = UFOWriter(self.dstDir, formatVersion=2)
1217        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1218        # openTypeOS2WinAscent
1219        infoObject = self.makeInfoObject()
1220        infoObject.openTypeOS2WinAscent = "abc"
1221        writer = UFOWriter(self.dstDir, formatVersion=2)
1222        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1223        # openTypeOS2WinDescent
1224        infoObject = self.makeInfoObject()
1225        infoObject.openTypeOS2WinDescent = "abc"
1226        writer = UFOWriter(self.dstDir, formatVersion=2)
1227        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1228        # openTypeOS2Type
1229        ## not an int
1230        infoObject = self.makeInfoObject()
1231        infoObject.openTypeOS2Type = ["1"]
1232        writer = UFOWriter(self.dstDir, formatVersion=2)
1233        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1234        ## out of range
1235        infoObject = self.makeInfoObject()
1236        infoObject.openTypeOS2Type = [-1]
1237        writer = UFOWriter(self.dstDir, formatVersion=2)
1238        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1239        # openTypeOS2SubscriptXSize
1240        infoObject = self.makeInfoObject()
1241        infoObject.openTypeOS2SubscriptXSize = "abc"
1242        writer = UFOWriter(self.dstDir, formatVersion=2)
1243        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1244        # openTypeOS2SubscriptYSize
1245        infoObject = self.makeInfoObject()
1246        infoObject.openTypeOS2SubscriptYSize = "abc"
1247        writer = UFOWriter(self.dstDir, formatVersion=2)
1248        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1249        # openTypeOS2SubscriptXOffset
1250        infoObject = self.makeInfoObject()
1251        infoObject.openTypeOS2SubscriptXOffset = "abc"
1252        writer = UFOWriter(self.dstDir, formatVersion=2)
1253        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1254        # openTypeOS2SubscriptYOffset
1255        infoObject = self.makeInfoObject()
1256        infoObject.openTypeOS2SubscriptYOffset = "abc"
1257        writer = UFOWriter(self.dstDir, formatVersion=2)
1258        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1259        # openTypeOS2SuperscriptXSize
1260        infoObject = self.makeInfoObject()
1261        infoObject.openTypeOS2SuperscriptXSize = "abc"
1262        writer = UFOWriter(self.dstDir, formatVersion=2)
1263        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1264        # openTypeOS2SuperscriptYSize
1265        infoObject = self.makeInfoObject()
1266        infoObject.openTypeOS2SuperscriptYSize = "abc"
1267        writer = UFOWriter(self.dstDir, formatVersion=2)
1268        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1269        # openTypeOS2SuperscriptXOffset
1270        infoObject = self.makeInfoObject()
1271        infoObject.openTypeOS2SuperscriptXOffset = "abc"
1272        writer = UFOWriter(self.dstDir, formatVersion=2)
1273        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1274        # openTypeOS2SuperscriptYOffset
1275        infoObject = self.makeInfoObject()
1276        infoObject.openTypeOS2SuperscriptYOffset = "abc"
1277        writer = UFOWriter(self.dstDir, formatVersion=2)
1278        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1279        # openTypeOS2StrikeoutSize
1280        infoObject = self.makeInfoObject()
1281        infoObject.openTypeOS2StrikeoutSize = "abc"
1282        writer = UFOWriter(self.dstDir, formatVersion=2)
1283        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1284        # openTypeOS2StrikeoutPosition
1285        infoObject = self.makeInfoObject()
1286        infoObject.openTypeOS2StrikeoutPosition = "abc"
1287        writer = UFOWriter(self.dstDir, formatVersion=2)
1288        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1289
1290    def testVheaWrite(self):
1291        # openTypeVheaVertTypoAscender
1292        infoObject = self.makeInfoObject()
1293        infoObject.openTypeVheaVertTypoAscender = "abc"
1294        writer = UFOWriter(self.dstDir, formatVersion=2)
1295        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1296        # openTypeVheaVertTypoDescender
1297        infoObject = self.makeInfoObject()
1298        infoObject.openTypeVheaVertTypoDescender = "abc"
1299        writer = UFOWriter(self.dstDir, formatVersion=2)
1300        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1301        # openTypeVheaVertTypoLineGap
1302        infoObject = self.makeInfoObject()
1303        infoObject.openTypeVheaVertTypoLineGap = "abc"
1304        writer = UFOWriter(self.dstDir, formatVersion=2)
1305        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1306        # openTypeVheaCaretSlopeRise
1307        infoObject = self.makeInfoObject()
1308        infoObject.openTypeVheaCaretSlopeRise = "abc"
1309        writer = UFOWriter(self.dstDir, formatVersion=2)
1310        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1311        # openTypeVheaCaretSlopeRun
1312        infoObject = self.makeInfoObject()
1313        infoObject.openTypeVheaCaretSlopeRun = "abc"
1314        writer = UFOWriter(self.dstDir, formatVersion=2)
1315        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1316        # openTypeVheaCaretOffset
1317        infoObject = self.makeInfoObject()
1318        infoObject.openTypeVheaCaretOffset = "abc"
1319        writer = UFOWriter(self.dstDir, formatVersion=2)
1320        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1321
1322    def testFONDWrite(self):
1323        # macintoshFONDFamilyID
1324        infoObject = self.makeInfoObject()
1325        infoObject.macintoshFONDFamilyID = "abc"
1326        writer = UFOWriter(self.dstDir, formatVersion=2)
1327        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1328        # macintoshFONDName
1329        infoObject = self.makeInfoObject()
1330        infoObject.macintoshFONDName = 123
1331        writer = UFOWriter(self.dstDir, formatVersion=2)
1332        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1333
1334    def testPostscriptWrite(self):
1335        # postscriptFontName
1336        infoObject = self.makeInfoObject()
1337        infoObject.postscriptFontName = 123
1338        writer = UFOWriter(self.dstDir, formatVersion=2)
1339        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1340        # postscriptFullName
1341        infoObject = self.makeInfoObject()
1342        infoObject.postscriptFullName = 123
1343        writer = UFOWriter(self.dstDir, formatVersion=2)
1344        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1345        # postscriptSlantAngle
1346        infoObject = self.makeInfoObject()
1347        infoObject.postscriptSlantAngle = "abc"
1348        writer = UFOWriter(self.dstDir, formatVersion=2)
1349        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1350        # postscriptUniqueID
1351        infoObject = self.makeInfoObject()
1352        infoObject.postscriptUniqueID = "abc"
1353        writer = UFOWriter(self.dstDir, formatVersion=2)
1354        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1355        # postscriptUnderlineThickness
1356        infoObject = self.makeInfoObject()
1357        infoObject.postscriptUnderlineThickness = "abc"
1358        writer = UFOWriter(self.dstDir, formatVersion=2)
1359        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1360        # postscriptUnderlinePosition
1361        infoObject = self.makeInfoObject()
1362        infoObject.postscriptUnderlinePosition = "abc"
1363        writer = UFOWriter(self.dstDir, formatVersion=2)
1364        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1365        # postscriptIsFixedPitch
1366        infoObject = self.makeInfoObject()
1367        infoObject.postscriptIsFixedPitch = 2
1368        writer = UFOWriter(self.dstDir, formatVersion=2)
1369        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1370        # postscriptBlueValues
1371        ## not a list
1372        infoObject = self.makeInfoObject()
1373        infoObject.postscriptBlueValues = "abc"
1374        writer = UFOWriter(self.dstDir, formatVersion=2)
1375        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1376        ## uneven value count
1377        infoObject = self.makeInfoObject()
1378        infoObject.postscriptBlueValues = [500]
1379        writer = UFOWriter(self.dstDir, formatVersion=2)
1380        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1381        ## too many values
1382        infoObject = self.makeInfoObject()
1383        infoObject.postscriptBlueValues = [
1384            10,
1385            20,
1386            30,
1387            40,
1388            50,
1389            60,
1390            70,
1391            80,
1392            90,
1393            100,
1394            110,
1395            120,
1396            130,
1397            140,
1398            150,
1399            160,
1400        ]
1401        writer = UFOWriter(self.dstDir, formatVersion=2)
1402        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1403        # postscriptOtherBlues
1404        ## not a list
1405        infoObject = self.makeInfoObject()
1406        infoObject.postscriptOtherBlues = "abc"
1407        writer = UFOWriter(self.dstDir, formatVersion=2)
1408        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1409        ## uneven value count
1410        infoObject = self.makeInfoObject()
1411        infoObject.postscriptOtherBlues = [500]
1412        writer = UFOWriter(self.dstDir, formatVersion=2)
1413        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1414        ## too many values
1415        infoObject = self.makeInfoObject()
1416        infoObject.postscriptOtherBlues = [
1417            10,
1418            20,
1419            30,
1420            40,
1421            50,
1422            60,
1423            70,
1424            80,
1425            90,
1426            100,
1427            110,
1428            120,
1429            130,
1430            140,
1431            150,
1432            160,
1433        ]
1434        writer = UFOWriter(self.dstDir, formatVersion=2)
1435        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1436        # postscriptFamilyBlues
1437        ## not a list
1438        infoObject = self.makeInfoObject()
1439        infoObject.postscriptFamilyBlues = "abc"
1440        writer = UFOWriter(self.dstDir, formatVersion=2)
1441        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1442        ## uneven value count
1443        infoObject = self.makeInfoObject()
1444        infoObject.postscriptFamilyBlues = [500]
1445        writer = UFOWriter(self.dstDir, formatVersion=2)
1446        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1447        ## too many values
1448        infoObject = self.makeInfoObject()
1449        infoObject.postscriptFamilyBlues = [
1450            10,
1451            20,
1452            30,
1453            40,
1454            50,
1455            60,
1456            70,
1457            80,
1458            90,
1459            100,
1460            110,
1461            120,
1462            130,
1463            140,
1464            150,
1465            160,
1466        ]
1467        writer = UFOWriter(self.dstDir, formatVersion=2)
1468        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1469        # postscriptFamilyOtherBlues
1470        ## not a list
1471        infoObject = self.makeInfoObject()
1472        infoObject.postscriptFamilyOtherBlues = "abc"
1473        writer = UFOWriter(self.dstDir, formatVersion=2)
1474        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1475        ## uneven value count
1476        infoObject = self.makeInfoObject()
1477        infoObject.postscriptFamilyOtherBlues = [500]
1478        writer = UFOWriter(self.dstDir, formatVersion=2)
1479        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1480        ## too many values
1481        infoObject = self.makeInfoObject()
1482        infoObject.postscriptFamilyOtherBlues = [
1483            10,
1484            20,
1485            30,
1486            40,
1487            50,
1488            60,
1489            70,
1490            80,
1491            90,
1492            100,
1493            110,
1494            120,
1495            130,
1496            140,
1497            150,
1498            160,
1499        ]
1500        writer = UFOWriter(self.dstDir, formatVersion=2)
1501        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1502        # postscriptStemSnapH
1503        ## not list
1504        infoObject = self.makeInfoObject()
1505        infoObject.postscriptStemSnapH = "abc"
1506        writer = UFOWriter(self.dstDir, formatVersion=2)
1507        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1508        ## too many values
1509        infoObject = self.makeInfoObject()
1510        infoObject.postscriptStemSnapH = [
1511            10,
1512            20,
1513            30,
1514            40,
1515            50,
1516            60,
1517            70,
1518            80,
1519            90,
1520            100,
1521            110,
1522            120,
1523            130,
1524            140,
1525            150,
1526            160,
1527        ]
1528        writer = UFOWriter(self.dstDir, formatVersion=2)
1529        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1530        # postscriptStemSnapV
1531        ## not list
1532        infoObject = self.makeInfoObject()
1533        infoObject.postscriptStemSnapV = "abc"
1534        writer = UFOWriter(self.dstDir, formatVersion=2)
1535        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1536        ## too many values
1537        infoObject = self.makeInfoObject()
1538        infoObject.postscriptStemSnapV = [
1539            10,
1540            20,
1541            30,
1542            40,
1543            50,
1544            60,
1545            70,
1546            80,
1547            90,
1548            100,
1549            110,
1550            120,
1551            130,
1552            140,
1553            150,
1554            160,
1555        ]
1556        writer = UFOWriter(self.dstDir, formatVersion=2)
1557        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1558        # postscriptBlueFuzz
1559        infoObject = self.makeInfoObject()
1560        infoObject.postscriptBlueFuzz = "abc"
1561        writer = UFOWriter(self.dstDir, formatVersion=2)
1562        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1563        # postscriptBlueShift
1564        infoObject = self.makeInfoObject()
1565        infoObject.postscriptBlueShift = "abc"
1566        writer = UFOWriter(self.dstDir, formatVersion=2)
1567        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1568        # postscriptBlueScale
1569        infoObject = self.makeInfoObject()
1570        infoObject.postscriptBlueScale = "abc"
1571        writer = UFOWriter(self.dstDir, formatVersion=2)
1572        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1573        # postscriptForceBold
1574        infoObject = self.makeInfoObject()
1575        infoObject.postscriptForceBold = "abc"
1576        writer = UFOWriter(self.dstDir, formatVersion=2)
1577        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1578        # postscriptDefaultWidthX
1579        infoObject = self.makeInfoObject()
1580        infoObject.postscriptDefaultWidthX = "abc"
1581        writer = UFOWriter(self.dstDir, formatVersion=2)
1582        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1583        # postscriptNominalWidthX
1584        infoObject = self.makeInfoObject()
1585        infoObject.postscriptNominalWidthX = "abc"
1586        writer = UFOWriter(self.dstDir, formatVersion=2)
1587        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1588        # postscriptWeightName
1589        infoObject = self.makeInfoObject()
1590        infoObject.postscriptWeightName = 123
1591        writer = UFOWriter(self.dstDir, formatVersion=2)
1592        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1593        # postscriptDefaultCharacter
1594        infoObject = self.makeInfoObject()
1595        infoObject.postscriptDefaultCharacter = 123
1596        writer = UFOWriter(self.dstDir, formatVersion=2)
1597        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1598        # postscriptWindowsCharacterSet
1599        infoObject = self.makeInfoObject()
1600        infoObject.postscriptWindowsCharacterSet = -1
1601        writer = UFOWriter(self.dstDir, formatVersion=2)
1602        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1603        # macintoshFONDFamilyID
1604        infoObject = self.makeInfoObject()
1605        infoObject.macintoshFONDFamilyID = "abc"
1606        writer = UFOWriter(self.dstDir, formatVersion=2)
1607        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1608        # macintoshFONDName
1609        infoObject = self.makeInfoObject()
1610        infoObject.macintoshFONDName = 123
1611        writer = UFOWriter(self.dstDir, formatVersion=2)
1612        self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
1613