| # -*- coding: utf-8 -*- |
| from __future__ import absolute_import, unicode_literals |
| import os |
| import shutil |
| import unittest |
| import tempfile |
| from io import open |
| from fontTools.misc.py23 import unicode |
| from fontTools.ufoLib import UFOReader, UFOWriter, UFOLibError |
| from fontTools.ufoLib.glifLib import GlifLibError |
| from fontTools.misc import plistlib |
| from .testSupport import fontInfoVersion3 |
| |
| |
| class TestInfoObject(object): pass |
| |
| |
| # -------------- |
| # fontinfo.plist |
| # -------------- |
| |
| class ReadFontInfoVersion3TestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.dstDir = tempfile.mktemp() |
| os.mkdir(self.dstDir) |
| metaInfo = { |
| "creator": "test", |
| "formatVersion": 3 |
| } |
| path = os.path.join(self.dstDir, "metainfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(metaInfo, f) |
| |
| def tearDown(self): |
| shutil.rmtree(self.dstDir) |
| |
| def _writeInfoToPlist(self, info): |
| path = os.path.join(self.dstDir, "fontinfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(info, f) |
| |
| def testRead(self): |
| originalData = dict(fontInfoVersion3) |
| self._writeInfoToPlist(originalData) |
| infoObject = TestInfoObject() |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(infoObject) |
| readData = {} |
| for attr in list(fontInfoVersion3.keys()): |
| readData[attr] = getattr(infoObject, attr) |
| self.assertEqual(originalData, readData) |
| |
| def testGenericRead(self): |
| # familyName |
| info = dict(fontInfoVersion3) |
| info["familyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # styleName |
| info = dict(fontInfoVersion3) |
| info["styleName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # styleMapFamilyName |
| info = dict(fontInfoVersion3) |
| info["styleMapFamilyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # styleMapStyleName |
| ## not a string |
| info = dict(fontInfoVersion3) |
| info["styleMapStyleName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info = dict(fontInfoVersion3) |
| info["styleMapStyleName"] = "REGULAR" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # versionMajor |
| info = dict(fontInfoVersion3) |
| info["versionMajor"] = "1" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # versionMinor |
| info = dict(fontInfoVersion3) |
| info["versionMinor"] = "0" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["versionMinor"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # copyright |
| info = dict(fontInfoVersion3) |
| info["copyright"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # trademark |
| info = dict(fontInfoVersion3) |
| info["trademark"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # unitsPerEm |
| info = dict(fontInfoVersion3) |
| info["unitsPerEm"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["unitsPerEm"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["unitsPerEm"] = -1.0 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # descender |
| info = dict(fontInfoVersion3) |
| info["descender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # xHeight |
| info = dict(fontInfoVersion3) |
| info["xHeight"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # capHeight |
| info = dict(fontInfoVersion3) |
| info["capHeight"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # ascender |
| info = dict(fontInfoVersion3) |
| info["ascender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # italicAngle |
| info = dict(fontInfoVersion3) |
| info["italicAngle"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testGaspRead(self): |
| # not a list |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # empty list |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| # not a dict |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = ["abc"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # dict not properly formatted |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM=0xFFFF, notTheRightKey=1)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(notTheRightKey=1, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # not an int for ppem |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM="abc", rangeGaspBehavior=[0]), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # not a list for behavior |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM=10, rangeGaspBehavior="abc"), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # invalid behavior value |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[-1]), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # not sorted |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=10, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # no 0xFFFF |
| info = dict(fontInfoVersion3) |
| info["openTypeGaspRangeRecords"] = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=20, rangeGaspBehavior=[0])] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| |
| def testHeadRead(self): |
| # openTypeHeadCreated |
| ## not a string |
| info = dict(fontInfoVersion3) |
| info["openTypeHeadCreated"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## invalid format |
| info = dict(fontInfoVersion3) |
| info["openTypeHeadCreated"] = "2000-Jan-01 00:00:00" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHeadLowestRecPPEM |
| info = dict(fontInfoVersion3) |
| info["openTypeHeadLowestRecPPEM"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeHeadLowestRecPPEM"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHeadFlags |
| info = dict(fontInfoVersion3) |
| info["openTypeHeadFlags"] = [-1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testHheaRead(self): |
| # openTypeHheaAscender |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaAscender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHheaDescender |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaDescender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHheaLineGap |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaLineGap"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHheaCaretSlopeRise |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaCaretSlopeRise"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHheaCaretSlopeRun |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaCaretSlopeRun"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeHheaCaretOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeHheaCaretOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testNameRead(self): |
| # openTypeNameDesigner |
| info = dict(fontInfoVersion3) |
| info["openTypeNameDesigner"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameDesignerURL |
| info = dict(fontInfoVersion3) |
| info["openTypeNameDesignerURL"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameManufacturer |
| info = dict(fontInfoVersion3) |
| info["openTypeNameManufacturer"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameManufacturerURL |
| info = dict(fontInfoVersion3) |
| info["openTypeNameManufacturerURL"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameLicense |
| info = dict(fontInfoVersion3) |
| info["openTypeNameLicense"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameLicenseURL |
| info = dict(fontInfoVersion3) |
| info["openTypeNameLicenseURL"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameVersion |
| info = dict(fontInfoVersion3) |
| info["openTypeNameVersion"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameUniqueID |
| info = dict(fontInfoVersion3) |
| info["openTypeNameUniqueID"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameDescription |
| info = dict(fontInfoVersion3) |
| info["openTypeNameDescription"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNamePreferredFamilyName |
| info = dict(fontInfoVersion3) |
| info["openTypeNamePreferredFamilyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNamePreferredSubfamilyName |
| info = dict(fontInfoVersion3) |
| info["openTypeNamePreferredSubfamilyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameCompatibleFullName |
| info = dict(fontInfoVersion3) |
| info["openTypeNameCompatibleFullName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameSampleText |
| info = dict(fontInfoVersion3) |
| info["openTypeNameSampleText"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameWWSFamilyName |
| info = dict(fontInfoVersion3) |
| info["openTypeNameWWSFamilyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameWWSSubfamilyName |
| info = dict(fontInfoVersion3) |
| info["openTypeNameWWSSubfamilyName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeNameRecords |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## not a dict |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = ["abc"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## invalid dict structure |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [dict(foo="bar")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## incorrect keys |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record.", foo="bar") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1) |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## invalid values |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID="1", platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID="1", encodingID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID="1", languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID="1", string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string=1) |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## duplicate |
| info = dict(fontInfoVersion3) |
| info["openTypeNameRecords"] = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record."), |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| |
| def testOS2Read(self): |
| # openTypeOS2WidthClass |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WidthClass"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out or range |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WidthClass"] = 15 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2WeightClass |
| info = dict(fontInfoVersion3) |
| ## not an int |
| info["openTypeOS2WeightClass"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info["openTypeOS2WeightClass"] = -50 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2Selection |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Selection"] = [-1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2VendorID |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2VendorID"] = 1234 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2Panose |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Panose"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, str(9)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## negative |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Panose"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, -9] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## too few values |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Panose"] = [0, 1, 2, 3] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Panose"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2FamilyClass |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2FamilyClass"] = [1, str(1)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## too few values |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2FamilyClass"] = [1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2FamilyClass"] = [1, 1, 1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2FamilyClass"] = [1, 201] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2UnicodeRanges |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2UnicodeRanges"] = ["0"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2UnicodeRanges"] = [-1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2CodePageRanges |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2CodePageRanges"] = ["0"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2CodePageRanges"] = [-1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2TypoAscender |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2TypoAscender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2TypoDescender |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2TypoDescender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2TypoLineGap |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2TypoLineGap"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2WinAscent |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WinAscent"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WinAscent"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2WinDescent |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WinDescent"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2WinDescent"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2Type |
| ## not an int |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Type"] = ["1"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| ## out of range |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2Type"] = [-1] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SubscriptXSize |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SubscriptXSize"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SubscriptYSize |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SubscriptYSize"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SubscriptXOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SubscriptXOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SubscriptYOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SubscriptYOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SuperscriptXSize |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SuperscriptXSize"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SuperscriptYSize |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SuperscriptYSize"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SuperscriptXOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SuperscriptXOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2SuperscriptYOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2SuperscriptYOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2StrikeoutSize |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2StrikeoutSize"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeOS2StrikeoutPosition |
| info = dict(fontInfoVersion3) |
| info["openTypeOS2StrikeoutPosition"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testVheaRead(self): |
| # openTypeVheaVertTypoAscender |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaVertTypoAscender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeVheaVertTypoDescender |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaVertTypoDescender"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeVheaVertTypoLineGap |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaVertTypoLineGap"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeVheaCaretSlopeRise |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaCaretSlopeRise"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeVheaCaretSlopeRun |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaCaretSlopeRun"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # openTypeVheaCaretOffset |
| info = dict(fontInfoVersion3) |
| info["openTypeVheaCaretOffset"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testFONDRead(self): |
| # macintoshFONDFamilyID |
| info = dict(fontInfoVersion3) |
| info["macintoshFONDFamilyID"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # macintoshFONDName |
| info = dict(fontInfoVersion3) |
| info["macintoshFONDName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| |
| def testPostscriptRead(self): |
| # postscriptFontName |
| info = dict(fontInfoVersion3) |
| info["postscriptFontName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # postscriptFullName |
| info = dict(fontInfoVersion3) |
| info["postscriptFullName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # postscriptSlantAngle |
| info = dict(fontInfoVersion3) |
| info["postscriptSlantAngle"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, info=TestInfoObject()) |
| # postscriptUniqueID |
| info = dict(fontInfoVersion3) |
| info["postscriptUniqueID"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptUnderlineThickness |
| info = dict(fontInfoVersion3) |
| info["postscriptUnderlineThickness"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptUnderlinePosition |
| info = dict(fontInfoVersion3) |
| info["postscriptUnderlinePosition"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptIsFixedPitch |
| info = dict(fontInfoVersion3) |
| info["postscriptIsFixedPitch"] = 2 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptBlueValues |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueValues"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## uneven value count |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueValues"] = [500] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueValues"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptOtherBlues |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["postscriptOtherBlues"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## uneven value count |
| info = dict(fontInfoVersion3) |
| info["postscriptOtherBlues"] = [500] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptOtherBlues"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptFamilyBlues |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyBlues"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## uneven value count |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyBlues"] = [500] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyBlues"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptFamilyOtherBlues |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyOtherBlues"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## uneven value count |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyOtherBlues"] = [500] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptFamilyOtherBlues"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptStemSnapH |
| ## not list |
| info = dict(fontInfoVersion3) |
| info["postscriptStemSnapH"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptStemSnapH"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptStemSnapV |
| ## not list |
| info = dict(fontInfoVersion3) |
| info["postscriptStemSnapV"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many values |
| info = dict(fontInfoVersion3) |
| info["postscriptStemSnapV"] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptBlueFuzz |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueFuzz"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptBlueShift |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueShift"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptBlueScale |
| info = dict(fontInfoVersion3) |
| info["postscriptBlueScale"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptForceBold |
| info = dict(fontInfoVersion3) |
| info["postscriptForceBold"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptDefaultWidthX |
| info = dict(fontInfoVersion3) |
| info["postscriptDefaultWidthX"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptNominalWidthX |
| info = dict(fontInfoVersion3) |
| info["postscriptNominalWidthX"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptWeightName |
| info = dict(fontInfoVersion3) |
| info["postscriptWeightName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptDefaultCharacter |
| info = dict(fontInfoVersion3) |
| info["postscriptDefaultCharacter"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # postscriptWindowsCharacterSet |
| info = dict(fontInfoVersion3) |
| info["postscriptWindowsCharacterSet"] = -1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # macintoshFONDFamilyID |
| info = dict(fontInfoVersion3) |
| info["macintoshFONDFamilyID"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # macintoshFONDName |
| info = dict(fontInfoVersion3) |
| info["macintoshFONDName"] = 123 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| |
| def testWOFFRead(self): |
| # woffMajorVersion |
| info = dict(fontInfoVersion3) |
| info["woffMajorVersion"] = 1.0 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["woffMajorVersion"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMinorVersion |
| info = dict(fontInfoVersion3) |
| info["woffMinorVersion"] = 1.0 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["woffMinorVersion"] = "abc" |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataUniqueID |
| ## none |
| info = dict(fontInfoVersion3) |
| del info["woffMetadataUniqueID"] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataUniqueID"] = 1 |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataUniqueID"] = dict(id="foo", notTheRightKey=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no id |
| info = dict(fontInfoVersion3) |
| info["woffMetadataUniqueID"] = dict() |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## not a string for id |
| info = dict(fontInfoVersion3) |
| info["woffMetadataUniqueID"] = dict(id=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## empty string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataUniqueID"] = dict(id="") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| # woffMetadataVendor |
| ## no name |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(url="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## name not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name=1, url="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## name an empty string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="", url="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## no URL |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url empty string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url="") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## have dir |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url="bar", dir="ltr") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url="bar", dir="rtl") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## dir not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url="bar", dir=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = dict(name="foo", url="bar", dir="utd") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## have class |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = {"name" : "foo", "url" : "bar", "class" : "hello"} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = {"name" : "foo", "url" : "bar", "class" : 1} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class empty string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataVendor"] = {"name" : "foo", "url" : "bar", "class" : ""} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| # woffMetadataCredits |
| ## no credits attribute |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = {} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## unknown attribute |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo")], notTheRightKey=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## not a list |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits="abc") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no elements in credits |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## credit not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=["abc"]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo", notTheRightKey=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no name |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(url="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## name not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo", url=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## role not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo", role=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo", dir=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[dict(name="foo", dir="utd")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCredits"] = dict(credits=[{"name" : "foo", "class" : 1}]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataDescription |
| ## no url |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo")], url=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(url="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a list |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text="abc") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=["abc"]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item missing text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(language="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo", url=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## language not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo", language=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[dict(text="foo", dir="utd")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataDescription"] = dict(text=[{"text" : "foo", "class" : 1}]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataLicense |
| ## no url |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo")], url=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## id not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo")], id=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(url="foo") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## text not a list |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text="abc") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=["abc"]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item missing text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(language="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo", url=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## language not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo", language=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[dict(text="foo", dir="utd")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicense"] = dict(text=[{"text" : "foo", "class" : 1}]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataCopyright |
| ## unknown attribute |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text="foo")], notTheRightKey=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict() |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a list |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text="abc") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=["abc"]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item missing text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(language="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text="foo", url=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## language not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text="foo", language=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[dict(text="foo", dir="utd")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataCopyright"] = dict(text=[{"text" : "foo", "class" : 1}]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataTrademark |
| ## unknown attribute |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text="foo")], notTheRightKey=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## no text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict() |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a list |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text="abc") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item not a dict |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=["abc"]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item unknown key |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text item missing text |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(language="foo")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## text not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## url not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text="foo", url=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## language not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text="foo", language=1)]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[dict(text="foo", dir="utd")]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataTrademark"] = dict(text=[{"text" : "foo", "class" : 1}]) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # woffMetadataLicensee |
| ## no name |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict() |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## unknown attribute |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict(name="foo", notTheRightKey=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## name not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict(name=1) |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## dir options |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict(name="foo", dir="ltr") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict(name="foo", dir="rtl") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## dir not ltr or rtl |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = dict(name="foo", dir="utd") |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## have class |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = {"name" : "foo", "class" : "hello"} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| reader.readInfo(TestInfoObject()) |
| ## class not a string |
| info = dict(fontInfoVersion3) |
| info["woffMetadataLicensee"] = {"name" : "foo", "class" : 1} |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| |
| def testGuidelinesRead(self): |
| # x |
| ## not an int or float |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x="1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # y |
| ## not an int or float |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(y="1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # angle |
| ## < 0 |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, y=0, angle=-1)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## > 360 |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, y=0, angle=361)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # name |
| ## not a string |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, name=1)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # color |
| ## not a string |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color=1)] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## not enough commas |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1 0, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1 0 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1 0 0 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## not enough parts |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color=", 0, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, , 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, 0, , 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, 0, 0, ")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color=", , , ")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## not a number in all positions |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="r, 1, 1, 1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, g, 1, 1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, 1, b, 1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, 1, 1, a")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## too many parts |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="1, 0, 0, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## < 0 in each position |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="-1, 0, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, -1, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, 0, -1, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, 0, 0, -1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| ## > 1 in each position |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="2, 0, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, 2, 0, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, 0, 2, 0")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, color="0, 0, 0, 2")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| # identifier |
| ## duplicate |
| info = dict(fontInfoVersion3) |
| info["guidelines"] = [dict(x=0, identifier="guide1"), dict(y=0, identifier="guide1")] |
| self._writeInfoToPlist(info) |
| reader = UFOReader(self.dstDir, validate=True) |
| self.assertRaises(UFOLibError, reader.readInfo, TestInfoObject()) |
| |
| |
| class WriteFontInfoVersion3TestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.dstDir = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def tearDownUFO(self): |
| if os.path.exists(self.dstDir): |
| shutil.rmtree(self.dstDir) |
| |
| def makeInfoObject(self): |
| infoObject = TestInfoObject() |
| for attr, value in list(fontInfoVersion3.items()): |
| setattr(infoObject, attr, value) |
| return infoObject |
| |
| def readPlist(self): |
| path = os.path.join(self.dstDir, "fontinfo.plist") |
| with open(path, "rb") as f: |
| plist = plistlib.load(f) |
| return plist |
| |
| def testWrite(self): |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| writtenData = self.readPlist() |
| for attr, originalValue in list(fontInfoVersion3.items()): |
| newValue = writtenData[attr] |
| self.assertEqual(newValue, originalValue) |
| self.tearDownUFO() |
| |
| def testGenericWrite(self): |
| # familyName |
| infoObject = self.makeInfoObject() |
| infoObject.familyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # styleName |
| infoObject = self.makeInfoObject() |
| infoObject.styleName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # styleMapFamilyName |
| infoObject = self.makeInfoObject() |
| infoObject.styleMapFamilyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # styleMapStyleName |
| ## not a string |
| infoObject = self.makeInfoObject() |
| infoObject.styleMapStyleName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.styleMapStyleName = "REGULAR" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # versionMajor |
| infoObject = self.makeInfoObject() |
| infoObject.versionMajor = "1" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # versionMinor |
| infoObject = self.makeInfoObject() |
| infoObject.versionMinor = "0" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # copyright |
| infoObject = self.makeInfoObject() |
| infoObject.copyright = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # trademark |
| infoObject = self.makeInfoObject() |
| infoObject.trademark = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # unitsPerEm |
| infoObject = self.makeInfoObject() |
| infoObject.unitsPerEm = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # descender |
| infoObject = self.makeInfoObject() |
| infoObject.descender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # xHeight |
| infoObject = self.makeInfoObject() |
| infoObject.xHeight = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # capHeight |
| infoObject = self.makeInfoObject() |
| infoObject.capHeight = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # ascender |
| infoObject = self.makeInfoObject() |
| infoObject.ascender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # italicAngle |
| infoObject = self.makeInfoObject() |
| infoObject.italicAngle = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testGaspWrite(self): |
| # not a list |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # empty list |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| # not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = ["abc"] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # dict not properly formatted |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=0xFFFF, notTheRightKey=1)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(notTheRightKey=1, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # not an int for ppem |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM="abc", rangeGaspBehavior=[0]), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # not a list for behavior |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior="abc"), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # invalid behavior value |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[-1]), dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # not sorted |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=0xFFFF, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=10, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # no 0xFFFF |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=20, rangeGaspBehavior=[0])] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| |
| def testHeadWrite(self): |
| # openTypeHeadCreated |
| ## not a string |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHeadCreated = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## invalid format |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHeadCreated = "2000-Jan-01 00:00:00" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHeadLowestRecPPEM |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHeadLowestRecPPEM = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHeadFlags |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHeadFlags = [-1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testHheaWrite(self): |
| # openTypeHheaAscender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaAscender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHheaDescender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaDescender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHheaLineGap |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaLineGap = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHheaCaretSlopeRise |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaCaretSlopeRise = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHheaCaretSlopeRun |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaCaretSlopeRun = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeHheaCaretOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeHheaCaretOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testNameWrite(self): |
| # openTypeNameDesigner |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameDesigner = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameDesignerURL |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameDesignerURL = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameManufacturer |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameManufacturer = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameManufacturerURL |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameManufacturerURL = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameLicense |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameLicense = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameLicenseURL |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameLicenseURL = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameVersion |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameVersion = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameUniqueID |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameUniqueID = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameDescription |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameDescription = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNamePreferredFamilyName |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNamePreferredFamilyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNamePreferredSubfamilyName |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNamePreferredSubfamilyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameCompatibleFullName |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameCompatibleFullName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameSampleText |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameSampleText = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameWWSFamilyName |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameWWSFamilyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameWWSSubfamilyName |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameWWSSubfamilyName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeNameRecords |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = ["abc"] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## invalid dict structure |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [dict(foo="bar")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## incorrect keys |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record.", foo="bar") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1) |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## invalid values |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID="1", platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID="1", encodingID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID="1", languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID="1", string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string=1) |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## duplicate |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeNameRecords = [ |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record."), |
| dict(nameID=1, platformID=1, encodingID=1, languageID=1, string="Name Record.") |
| ] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| |
| def testOS2Write(self): |
| # openTypeOS2WidthClass |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WidthClass = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out or range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WidthClass = 15 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2WeightClass |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WeightClass = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WeightClass = -50 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2Selection |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Selection = [-1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2VendorID |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2VendorID = 1234 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2Panose |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, str(9)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too few values |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Panose = [0, 1, 2, 3] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2FamilyClass |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2FamilyClass = [0, str(1)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too few values |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2FamilyClass = [1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2FamilyClass = [1, 1, 1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2FamilyClass = [1, 20] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2UnicodeRanges |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2UnicodeRanges = ["0"] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2UnicodeRanges = [-1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2CodePageRanges |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2CodePageRanges = ["0"] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2CodePageRanges = [-1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2TypoAscender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2TypoAscender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2TypoDescender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2TypoDescender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2TypoLineGap |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2TypoLineGap = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2WinAscent |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WinAscent = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WinAscent = -1 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2WinDescent |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WinDescent = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2WinDescent = -1 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2Type |
| ## not an int |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Type = ["1"] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## out of range |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2Type = [-1] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SubscriptXSize |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SubscriptXSize = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SubscriptYSize |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SubscriptYSize = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SubscriptXOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SubscriptXOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SubscriptYOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SubscriptYOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SuperscriptXSize |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SuperscriptXSize = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SuperscriptYSize |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SuperscriptYSize = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SuperscriptXOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SuperscriptXOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2SuperscriptYOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2SuperscriptYOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2StrikeoutSize |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2StrikeoutSize = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeOS2StrikeoutPosition |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeOS2StrikeoutPosition = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testVheaWrite(self): |
| # openTypeVheaVertTypoAscender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaVertTypoAscender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeVheaVertTypoDescender |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaVertTypoDescender = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeVheaVertTypoLineGap |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaVertTypoLineGap = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeVheaCaretSlopeRise |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaCaretSlopeRise = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeVheaCaretSlopeRun |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaCaretSlopeRun = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # openTypeVheaCaretOffset |
| infoObject = self.makeInfoObject() |
| infoObject.openTypeVheaCaretOffset = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testFONDWrite(self): |
| # macintoshFONDFamilyID |
| infoObject = self.makeInfoObject() |
| infoObject.macintoshFONDFamilyID = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # macintoshFONDName |
| infoObject = self.makeInfoObject() |
| infoObject.macintoshFONDName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testPostscriptWrite(self): |
| # postscriptFontName |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFontName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptFullName |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFullName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptSlantAngle |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptSlantAngle = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptUniqueID |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptUniqueID = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptUnderlineThickness |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptUnderlineThickness = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptUnderlinePosition |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptUnderlinePosition = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptIsFixedPitch |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptIsFixedPitch = 2 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptBlueValues |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueValues = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## uneven value count |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueValues = [500] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueValues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptOtherBlues |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptOtherBlues = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## uneven value count |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptOtherBlues = [500] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptOtherBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptFamilyBlues |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyBlues = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## uneven value count |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyBlues = [500] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptFamilyOtherBlues |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyOtherBlues = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## uneven value count |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyOtherBlues = [500] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptFamilyOtherBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptStemSnapH |
| ## not list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptStemSnapH = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptStemSnapH = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptStemSnapV |
| ## not list |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptStemSnapV = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many values |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptStemSnapV = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptBlueFuzz |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueFuzz = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptBlueShift |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueShift = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptBlueScale |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptBlueScale = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptForceBold |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptForceBold = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptDefaultWidthX |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptDefaultWidthX = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptNominalWidthX |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptNominalWidthX = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptWeightName |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptWeightName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptDefaultCharacter |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptDefaultCharacter = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # postscriptWindowsCharacterSet |
| infoObject = self.makeInfoObject() |
| infoObject.postscriptWindowsCharacterSet = -1 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # macintoshFONDFamilyID |
| infoObject = self.makeInfoObject() |
| infoObject.macintoshFONDFamilyID = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # macintoshFONDName |
| infoObject = self.makeInfoObject() |
| infoObject.macintoshFONDName = 123 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testWOFFWrite(self): |
| # woffMajorVersion |
| infoObject = self.makeInfoObject() |
| infoObject.woffMajorVersion = 1.0 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.woffMajorVersion = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMinorVersion |
| infoObject = self.makeInfoObject() |
| infoObject.woffMinorVersion = 1.0 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.woffMinorVersion = "abc" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataUniqueID |
| ## none |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = None |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = 1 |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## unknown key |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = dict(id="foo", notTheRightKey=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no id |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = dict() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not a string for id |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = dict(id=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## empty string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataUniqueID = dict(id="") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| # woffMetadataVendor |
| ## no name |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(url="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## name not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name=1, url="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## name an empty string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="", url="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## no URL |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url empty string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url="") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## have dir |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url="bar", dir="ltr") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url="bar", dir="rtl") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## dir not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url="bar", dir=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = dict(name="foo", url="bar", dir="utd") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## have class |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = {"name" : "foo", "url" : "bar", "class" : "hello"} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = {"name" : "foo", "url" : "bar", "class" : 1} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class empty string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataVendor = {"name" : "foo", "url" : "bar", "class" : ""} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| # woffMetadataCredits |
| ## no credits attribute |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = {} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## unknown attribute |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo")], notTheRightKey=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not a list |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits="abc") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no elements in credits |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## credit not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=["abc"]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## unknown key |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo", notTheRightKey=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no name |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(url="foo")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## name not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo", url=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## role not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo", role=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo", dir=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[dict(name="foo", dir="utd")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCredits = dict(credits=[{"name" : "foo", "class" : 1}]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataDescription |
| ## no url |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo")], url=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no text |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(url="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a list |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text="abc") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=["abc"]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item unknown key |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item missing text |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(language="foo")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo", url=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## language not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo", language=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[dict(text="foo", dir="utd")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataDescription = dict(text=[{"text" : "foo", "class" : 1}]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataLicense |
| ## no url |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo")]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo")], url=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## id not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo")], id=1) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no text |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(url="foo") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## text not a list |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text="abc") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item not a dict |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text=["abc"]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item unknown key |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item missing text |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[dict(language="foo")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[dict(text=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo", url=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## language not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo", language=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[dict(text="foo", dir="utd")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicense = dict(text=[{"text" : "foo", "class" : 1}]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataCopyright |
| ## unknown attribute |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text="foo")], notTheRightKey=1) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no text |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict() |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a list |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text="abc") |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item not a dict |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=["abc"]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item unknown key |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item missing text |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataCopyright = dict(text=[dict(language="foo")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text="foo", url=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## language not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text="foo", language=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[dict(text="foo", dir="utd")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataCopyright = dict(text=[{"text" : "foo", "class" : 1}]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataTrademark |
| ## unknown attribute |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text="foo")], notTheRightKey=1) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## no text |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict() |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a list |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text="abc") |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item not a dict |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=["abc"]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item unknown key |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text="foo", notTheRightKey=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text item missing text |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(language="foo")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## text not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## url not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text="foo", url=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## language not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text="foo", language=1)]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[dict(text="foo", dir="utd")]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataTrademark = dict(text=[{"text" : "foo", "class" : 1}]) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # woffMetadataLicensee |
| ## no name |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicensee = dict() |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## unknown attribute |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicensee = dict(name="foo", notTheRightKey=1) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## name not a string |
| infoObject = self.makeInfoObject() |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| infoObject.woffMetadataLicensee = dict(name=1) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## dir options |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicensee = dict(name="foo", dir="ltr") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicensee = dict(name="foo", dir="rtl") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## dir not ltr or rtl |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicensee = dict(name="foo", dir="utd") |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## have class |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicensee = {"name" : "foo", "class" : "hello"} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeInfo(infoObject) |
| self.tearDownUFO() |
| ## class not a string |
| infoObject = self.makeInfoObject() |
| infoObject.woffMetadataLicensee = {"name" : "foo", "class" : 1} |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| def testGuidelinesWrite(self): |
| # x |
| ## not an int or float |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x="1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # y |
| ## not an int or float |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(y="1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # angle |
| ## < 0 |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, y=0, angle=-1)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## > 360 |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, y=0, angle=361)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # name |
| ## not a string |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, name=1)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # color |
| ## not a string |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color=1)] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not enough commas |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1 0, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1 0 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1 0 0 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not enough parts |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color=", 0, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, , 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, 0, , 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, 0, 0, ")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color=", , , ")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## not a number in all positions |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="r, 1, 1, 1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, g, 1, 1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, 1, b, 1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, 1, 1, a")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## too many parts |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="1, 0, 0, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## < 0 in each position |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="-1, 0, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, -1, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, 0, -1, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, 0, 0, -1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## > 1 in each position |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="2, 0, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, 2, 0, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, 0, 2, 0")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, color="0, 0, 0, 2")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| # identifier |
| ## duplicate |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, identifier="guide1"), dict(y=0, identifier="guide1")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## below min |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, identifier="\0x1F")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| ## above max |
| infoObject = self.makeInfoObject() |
| infoObject.guidelines = [dict(x=0, identifier="\0x7F")] |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject) |
| self.tearDownUFO() |
| |
| |
| # ------ |
| # layers |
| # ------ |
| |
| class UFO3ReadLayersTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.ufoPath = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def makeUFO(self, metaInfo=None, layerContents=None): |
| self.clearUFO() |
| if not os.path.exists(self.ufoPath): |
| os.mkdir(self.ufoPath) |
| # metainfo.plist |
| if metaInfo is None: |
| metaInfo = dict(creator="test", formatVersion=3) |
| path = os.path.join(self.ufoPath, "metainfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(metaInfo, f) |
| # layers |
| if layerContents is None: |
| layerContents = [ |
| ("public.default", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2"), |
| ] |
| if layerContents: |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| else: |
| layerContents = [("", "glyphs")] |
| for name, directory in layerContents: |
| glyphsPath = os.path.join(self.ufoPath, directory) |
| os.mkdir(glyphsPath) |
| contents = dict(a="a.glif") |
| path = os.path.join(glyphsPath, "contents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(contents, f) |
| path = os.path.join(glyphsPath, "a.glif") |
| with open(path, "w") as f: |
| f.write(" ") |
| |
| def clearUFO(self): |
| if os.path.exists(self.ufoPath): |
| shutil.rmtree(self.ufoPath) |
| |
| # valid |
| |
| def testValidRead(self): |
| # UFO 1 |
| self.makeUFO( |
| metaInfo=dict(creator="test", formatVersion=1), |
| layerContents=dict() |
| ) |
| reader = UFOReader(self.ufoPath, validate=True) |
| reader.getGlyphSet() |
| # UFO 2 |
| self.makeUFO( |
| metaInfo=dict(creator="test", formatVersion=2), |
| layerContents=dict() |
| ) |
| reader = UFOReader(self.ufoPath, validate=True) |
| reader.getGlyphSet() |
| # UFO 3 |
| self.makeUFO() |
| reader = UFOReader(self.ufoPath, validate=True) |
| reader.getGlyphSet() |
| |
| # missing layer contents |
| |
| def testMissingLayerContents(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # layer contents invalid format |
| |
| def testInvalidLayerContentsFormat(self): |
| # bogus |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| with open(path, "w") as f: |
| f.write("test") |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| # dict |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = { |
| "public.default" : "glyphs", |
| "layer 1" : "glyphs.layer 1", |
| "layer 2" : "glyphs.layer 2", |
| } |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # layer contents invalid name format |
| |
| def testInvalidLayerContentsNameFormat(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| (1, "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # layer contents invalid directory format |
| |
| def testInvalidLayerContentsDirectoryFormat(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", 1), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # directory listed in contents not on disk |
| |
| def testLayerContentsHasMissingDirectory(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.doesnotexist"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # # directory on disk not listed in contents |
| # XXX should this raise an error? |
| # |
| # def testLayerContentsHasMissingDirectory(self): |
| # self.makeUFO() |
| # path = os.path.join(self.ufoPath, "layercontents.plist") |
| # os.remove(path) |
| # layerContents = [ |
| # ("public.foregound", "glyphs"), |
| # ("layer 1", "glyphs.layer 2") |
| # ] |
| # with open(path, "wb") as f: |
| # plistlib.dump(layerContents, f) |
| # reader = UFOReader(self.ufoPath, validate=True) |
| # with self.assertRaises(UFOLibError): |
| # reader.getGlyphSet() |
| |
| # no default layer on disk |
| |
| def testMissingDefaultLayer(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # duplicate layer name |
| |
| def testDuplicateLayerName(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 1", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # directory referenced by two layer names |
| |
| def testDuplicateLayerDirectory(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 1") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| self.assertRaises(UFOLibError, reader.getGlyphSet) |
| |
| # default without a name |
| |
| def testDefaultLayerNoName(self): |
| # get the glyph set |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| reader.getGlyphSet() |
| |
| # default with a name |
| |
| def testDefaultLayerName(self): |
| # get the name |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("custom name", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| expected = layerContents[0][0] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| result = reader.getDefaultLayerName() |
| self.assertEqual(expected, result) |
| # get the glyph set |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("custom name", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| reader.getGlyphSet(expected) |
| |
| # layer order |
| |
| def testLayerOrder(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| expected = [name for (name, directory) in layerContents] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| result = reader.getLayerNames() |
| self.assertEqual(expected, result) |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("layer 1", "glyphs.layer 1"), |
| ("public.foregound", "glyphs"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| expected = [name for (name, directory) in layerContents] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| result = reader.getLayerNames() |
| self.assertEqual(expected, result) |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("layer 2", "glyphs.layer 2"), |
| ("layer 1", "glyphs.layer 1"), |
| ("public.foregound", "glyphs") |
| ] |
| expected = [name for (name, directory) in layerContents] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| reader = UFOReader(self.ufoPath, validate=True) |
| result = reader.getLayerNames() |
| self.assertEqual(expected, result) |
| |
| |
| class UFO3WriteLayersTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.ufoPath = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def makeUFO(self, metaInfo=None, layerContents=None): |
| self.clearUFO() |
| if not os.path.exists(self.ufoPath): |
| os.mkdir(self.ufoPath) |
| # metainfo.plist |
| if metaInfo is None: |
| metaInfo = dict(creator="test", formatVersion=3) |
| path = os.path.join(self.ufoPath, "metainfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(metaInfo, f) |
| # layers |
| if layerContents is None: |
| layerContents = [ |
| ("public.default", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2"), |
| ] |
| if layerContents: |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| else: |
| layerContents = [("", "glyphs")] |
| for name, directory in layerContents: |
| glyphsPath = os.path.join(self.ufoPath, directory) |
| os.mkdir(glyphsPath) |
| contents = dict(a="a.glif") |
| path = os.path.join(glyphsPath, "contents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(contents, f) |
| path = os.path.join(glyphsPath, "a.glif") |
| with open(path, "w") as f: |
| f.write(" ") |
| |
| def clearUFO(self): |
| if os.path.exists(self.ufoPath): |
| shutil.rmtree(self.ufoPath) |
| |
| # __init__: missing layer contents |
| |
| def testMissingLayerContents(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: layer contents invalid format |
| |
| def testInvalidLayerContentsFormat(self): |
| # bogus |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| with open(path, "w") as f: |
| f.write("test") |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| # dict |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = { |
| "public.default" : "glyphs", |
| "layer 1" : "glyphs.layer 1", |
| "layer 2" : "glyphs.layer 2", |
| } |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: layer contents invalid name format |
| |
| def testInvalidLayerContentsNameFormat(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| (1, "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: layer contents invalid directory format |
| |
| def testInvalidLayerContentsDirectoryFormat(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", 1), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: directory listed in contents not on disk |
| |
| def testLayerContentsHasMissingDirectory(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.doesnotexist"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: no default layer on disk |
| |
| def testMissingDefaultLayer(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: duplicate layer name |
| |
| def testDuplicateLayerName(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 1", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: directory referenced by two layer names |
| |
| def testDuplicateLayerDirectory(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 1") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath) |
| |
| # __init__: default without a name |
| |
| def testDefaultLayerNoName(self): |
| # get the glyph set |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("public.foregound", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| writer = UFOWriter(self.ufoPath) |
| |
| # __init__: default with a name |
| |
| def testDefaultLayerName(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| os.remove(path) |
| layerContents = [ |
| ("custom name", "glyphs"), |
| ("layer 1", "glyphs.layer 1"), |
| ("layer 2", "glyphs.layer 2") |
| ] |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| writer = UFOWriter(self.ufoPath) |
| |
| # __init__: up convert 1 > 3 |
| |
| def testUpConvert1To3(self): |
| self.makeUFO( |
| metaInfo=dict(creator="test", formatVersion=1), |
| layerContents=dict() |
| ) |
| writer = UFOWriter(self.ufoPath) |
| writer.writeLayerContents(["public.default"]) |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["public.default", "glyphs"]] |
| self.assertEqual(expected, result) |
| |
| # __init__: up convert 2 > 3 |
| |
| def testUpConvert2To3(self): |
| self.makeUFO( |
| metaInfo=dict(creator="test", formatVersion=2), |
| layerContents=dict() |
| ) |
| writer = UFOWriter(self.ufoPath) |
| writer.writeLayerContents(["public.default"]) |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["public.default", "glyphs"]] |
| self.assertEqual(expected, result) |
| |
| # __init__: down convert 3 > 1 |
| |
| def testDownConvert3To1(self): |
| self.makeUFO() |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath, formatVersion=1) |
| |
| # __init__: down convert 3 > 2 |
| |
| def testDownConvert3To2(self): |
| self.makeUFO() |
| self.assertRaises(UFOLibError, UFOWriter, self.ufoPath, formatVersion=2) |
| |
| # get glyph sets |
| |
| def testGetGlyphSets(self): |
| self.makeUFO() |
| # hack contents.plist |
| path = os.path.join(self.ufoPath, "glyphs.layer 1", "contents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(dict(b="a.glif"), f) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2", "contents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(dict(c="a.glif"), f) |
| # now test |
| writer = UFOWriter(self.ufoPath) |
| # default |
| expected = ["a"] |
| result = list(writer.getGlyphSet().keys()) |
| self.assertEqual(expected, result) |
| # layer 1 |
| expected = ["b"] |
| result = list(writer.getGlyphSet("layer 1", defaultLayer=False).keys()) |
| self.assertEqual(expected, result) |
| # layer 2 |
| expected = ["c"] |
| result = list(writer.getGlyphSet("layer 2", defaultLayer=False).keys()) |
| self.assertEqual(expected, result) |
| |
| # make a new font with two layers |
| |
| def testNewFontOneLayer(self): |
| self.clearUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.getGlyphSet() |
| writer.writeLayerContents(["public.default"]) |
| # directory |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["public.default", "glyphs"]] |
| self.assertEqual(expected, result) |
| |
| def testNewFontThreeLayers(self): |
| self.clearUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.getGlyphSet("layer 1", defaultLayer=False) |
| writer.getGlyphSet() |
| writer.getGlyphSet("layer 2", defaultLayer=False) |
| writer.writeLayerContents(["layer 1", "public.default", "layer 2"]) |
| # directories |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["layer 1", "glyphs.layer 1"], ["public.default", "glyphs"], ["layer 2", "glyphs.layer 2"]] |
| self.assertEqual(expected, result) |
| |
| # add a layer to an existing font |
| |
| def testAddLayerToExistingFont(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.getGlyphSet("layer 3", defaultLayer=False) |
| writer.writeLayerContents(["public.default", "layer 1", "layer 2", "layer 3"]) |
| # directories |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 3") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [['public.default', 'glyphs'], ['layer 1', 'glyphs.layer 1'], ['layer 2', 'glyphs.layer 2'], ["layer 3", "glyphs.layer 3"]] |
| self.assertEqual(expected, result) |
| |
| # rename valid name |
| |
| def testRenameLayer(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.renameGlyphSet("layer 1", "layer 3") |
| writer.writeLayerContents(["public.default", "layer 3", "layer 2"]) |
| # directories |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(False, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 3") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [['public.default', 'glyphs'], ['layer 3', 'glyphs.layer 3'], ['layer 2', 'glyphs.layer 2']] |
| self.assertEqual(expected, result) |
| |
| def testRenameLayerDefault(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.renameGlyphSet("public.default", "layer xxx") |
| writer.renameGlyphSet("layer 1", "layer 1", defaultLayer=True) |
| writer.writeLayerContents(["layer xxx", "layer 1", "layer 2"]) |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(False, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer xxx") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [['layer xxx', 'glyphs.layer xxx'], ['layer 1', 'glyphs'], ['layer 2', 'glyphs.layer 2']] |
| self.assertEqual(expected, result) |
| |
| # rename duplicate name |
| |
| def testRenameLayerDuplicateName(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| self.assertRaises(UFOLibError, writer.renameGlyphSet, "layer 1", "layer 2") |
| |
| # rename unknown layer |
| |
| def testRenameLayerUnknownName(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| self.assertRaises(UFOLibError, writer.renameGlyphSet, "does not exist", "layer 2") |
| |
| # remove valid layer |
| |
| def testRemoveLayer(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.deleteGlyphSet("layer 1") |
| writer.writeLayerContents(["public.default", "layer 2"]) |
| # directories |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(False, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["public.default", "glyphs"], ["layer 2", "glyphs.layer 2"]] |
| self.assertEqual(expected, result) |
| |
| # remove default layer |
| |
| def testRemoveDefaultLayer(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| writer.deleteGlyphSet("public.default") |
| # directories |
| path = os.path.join(self.ufoPath, "glyphs") |
| exists = os.path.exists(path) |
| self.assertEqual(False, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 1") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| path = os.path.join(self.ufoPath, "glyphs.layer 2") |
| exists = os.path.exists(path) |
| self.assertEqual(True, exists) |
| # layer contents |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [["layer 1", "glyphs.layer 1"], ["layer 2", "glyphs.layer 2"]] |
| self.assertEqual(expected, result) |
| |
| # remove unknown layer |
| |
| def testRemoveDefaultLayer(self): |
| self.makeUFO() |
| writer = UFOWriter(self.ufoPath) |
| self.assertRaises(UFOLibError, writer.deleteGlyphSet, "does not exist") |
| |
| def testWriteAsciiLayerOrder(self): |
| self.makeUFO( |
| layerContents=[ |
| ["public.default", "glyphs"], |
| ["layer 1", "glyphs.layer 1"], |
| ["layer 2", "glyphs.layer 2"], |
| ] |
| ) |
| writer = UFOWriter(self.ufoPath) |
| # if passed bytes string, it'll be decoded to ASCII unicode string |
| writer.writeLayerContents(["public.default", "layer 2", b"layer 1"]) |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| expected = [ |
| ["public.default", "glyphs"], |
| ["layer 2", "glyphs.layer 2"], |
| ["layer 1", "glyphs.layer 1"], |
| ] |
| self.assertEqual(expected, result) |
| for layerName, directory in result: |
| assert isinstance(layerName, unicode) |
| |
| # ----- |
| # /data |
| # ----- |
| |
| |
| class UFO3ReadDataTestCase(unittest.TestCase): |
| |
| def getFontPath(self): |
| testdata = os.path.join(os.path.dirname(__file__), "testdata") |
| return os.path.join(testdata, "UFO3-Read Data.ufo") |
| |
| def testUFOReaderDataDirectoryListing(self): |
| reader = UFOReader(self.getFontPath()) |
| found = reader.getDataDirectoryListing() |
| expected = [ |
| 'org.unifiedfontobject.directory/bar/lol.txt', |
| 'org.unifiedfontobject.directory/foo.txt', |
| 'org.unifiedfontobject.file.txt' |
| ] |
| self.assertEqual(set(found), set(expected)) |
| |
| def testUFOReaderBytesFromPath(self): |
| reader = UFOReader(self.getFontPath()) |
| found = reader.readBytesFromPath("data/org.unifiedfontobject.file.txt") |
| expected = b"file.txt" |
| self.assertEqual(found, expected) |
| found = reader.readBytesFromPath("data/org.unifiedfontobject.directory/bar/lol.txt") |
| expected = b"lol.txt" |
| self.assertEqual(found, expected) |
| found = reader.readBytesFromPath("data/org.unifiedfontobject.doesNotExist") |
| expected = None |
| self.assertEqual(found, expected) |
| |
| def testUFOReaderReadFileFromPath(self): |
| reader = UFOReader(self.getFontPath()) |
| fileObject = reader.getReadFileForPath("data/org.unifiedfontobject.file.txt") |
| self.assertNotEqual(fileObject, None) |
| hasRead = hasattr(fileObject, "read") |
| self.assertEqual(hasRead, True) |
| fileObject.close() |
| fileObject = reader.getReadFileForPath("data/org.unifiedfontobject.doesNotExist") |
| self.assertEqual(fileObject, None) |
| |
| |
| class UFO3WriteDataTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.dstDir = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def tearDownUFO(self): |
| if os.path.exists(self.dstDir): |
| shutil.rmtree(self.dstDir) |
| |
| def testUFOWriterWriteBytesToPath(self): |
| # basic file |
| path = "data/org.unifiedfontobject.writebytesbasicfile.txt" |
| testBytes = b"test" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeBytesToPath(path, testBytes) |
| path = os.path.join(self.dstDir, path) |
| self.assertEqual(os.path.exists(path), True) |
| with open(path, "rb") as f: |
| written = f.read() |
| self.assertEqual(testBytes, written) |
| self.tearDownUFO() |
| # basic file with unicode text |
| path = "data/org.unifiedfontobject.writebytesbasicunicodefile.txt" |
| text = b"t\xeb\xdft" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeBytesToPath(path, text) |
| path = os.path.join(self.dstDir, path) |
| self.assertEqual(os.path.exists(path), True) |
| with open(path, "rb") as f: |
| written = f.read() |
| self.assertEqual(text, written) |
| self.tearDownUFO() |
| # basic directory |
| path = "data/org.unifiedfontobject.writebytesdirectory/level1/level2/file.txt" |
| testBytes = b"test" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeBytesToPath(path, testBytes) |
| path = os.path.join(self.dstDir, path) |
| self.assertEqual(os.path.exists(path), True) |
| with open(path, "rb") as f: |
| written = f.read() |
| self.assertEqual(testBytes, written) |
| self.tearDownUFO() |
| |
| def testUFOWriterWriteFileToPath(self): |
| # basic file |
| path = "data/org.unifiedfontobject.getwritefile.txt" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| fileObject = writer.getFileObjectForPath(path) |
| self.assertNotEqual(fileObject, None) |
| hasRead = hasattr(fileObject, "read") |
| self.assertEqual(hasRead, True) |
| fileObject.close() |
| self.tearDownUFO() |
| |
| def testUFOWriterRemoveFile(self): |
| path1 = "data/org.unifiedfontobject.removefile/level1/level2/file1.txt" |
| path2 = "data/org.unifiedfontobject.removefile/level1/level2/file2.txt" |
| path3 = "data/org.unifiedfontobject.removefile/level1/file3.txt" |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.writeBytesToPath(path1, b"test") |
| writer.writeBytesToPath(path2, b"test") |
| writer.writeBytesToPath(path3, b"test") |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path1)), True) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path2)), True) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path3)), True) |
| writer.removeFileForPath(path1) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path1)), False) |
| self.assertEqual(os.path.exists(os.path.dirname(os.path.join(self.dstDir, path1))), True) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path2)), True) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path3)), True) |
| writer.removeFileForPath(path2) |
| self.assertEqual(os.path.exists(os.path.dirname(os.path.join(self.dstDir, path1))), False) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path2)), False) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path3)), True) |
| writer.removeFileForPath(path3) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, path3)), False) |
| self.assertEqual(os.path.exists(os.path.dirname(os.path.join(self.dstDir, path2))), False) |
| self.assertEqual(os.path.exists(os.path.join(self.dstDir, "data/org.unifiedfontobject.removefile")), False) |
| self.assertRaises(UFOLibError, writer.removeFileForPath, path="data/org.unifiedfontobject.doesNotExist.txt") |
| self.tearDownUFO() |
| |
| def testUFOWriterCopy(self): |
| sourceDir = self.dstDir.replace(".ufo", "") + "-copy source" + ".ufo" |
| dataPath = "data/org.unifiedfontobject.copy/level1/level2/file1.txt" |
| writer = UFOWriter(sourceDir, formatVersion=3) |
| writer.writeBytesToPath(dataPath, b"test") |
| # copy a file |
| reader = UFOReader(sourceDir) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| writer.copyFromReader(reader, dataPath, dataPath) |
| path = os.path.join(self.dstDir, dataPath) |
| self.assertEqual(os.path.exists(path), True) |
| self.tearDownUFO() |
| # copy a directory |
| reader = UFOReader(sourceDir) |
| writer = UFOWriter(self.dstDir, formatVersion=3) |
| p = "data/org.unifiedfontobject.copy" |
| writer.copyFromReader(reader, p, p) |
| path = os.path.join(self.dstDir, dataPath) |
| self.assertEqual(os.path.exists(path), True) |
| self.tearDownUFO() |
| |
| # --------------- |
| # layerinfo.plist |
| # --------------- |
| |
| class TestLayerInfoObject(object): |
| |
| color = guidelines = lib = None |
| |
| |
| class UFO3ReadLayerInfoTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.ufoPath = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def makeUFO(self, formatVersion=3, layerInfo=None): |
| self.clearUFO() |
| if not os.path.exists(self.ufoPath): |
| os.mkdir(self.ufoPath) |
| # metainfo.plist |
| metaInfo = dict(creator="test", formatVersion=formatVersion) |
| path = os.path.join(self.ufoPath, "metainfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(metaInfo, f) |
| # layercontents.plist |
| layerContents = [("public.default", "glyphs")] |
| path = os.path.join(self.ufoPath, "layercontents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(layerContents, f) |
| # glyphs |
| glyphsPath = os.path.join(self.ufoPath, "glyphs") |
| os.mkdir(glyphsPath) |
| contents = dict(a="a.glif") |
| path = os.path.join(glyphsPath, "contents.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(contents, f) |
| path = os.path.join(glyphsPath, "a.glif") |
| with open(path, "w") as f: |
| f.write(" ") |
| # layerinfo.plist |
| if layerInfo is None: |
| layerInfo = dict( |
| color="0,0,0,1", |
| lib={"foo" : "bar"} |
| ) |
| path = os.path.join(glyphsPath, "layerinfo.plist") |
| with open(path, "wb") as f: |
| plistlib.dump(layerInfo, f) |
| |
| def clearUFO(self): |
| if os.path.exists(self.ufoPath): |
| shutil.rmtree(self.ufoPath) |
| |
| def testValidLayerInfo(self): |
| self.makeUFO() |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| info = TestLayerInfoObject() |
| glyphSet.readLayerInfo(info) |
| expectedColor = "0,0,0,1" |
| self.assertEqual(expectedColor, info.color) |
| expectedLib = {"foo": "bar"} |
| self.assertEqual(expectedLib, info.lib) |
| |
| def testMissingLayerInfo(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "glyphs", "layerinfo.plist") |
| os.remove(path) |
| # read |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| info = TestLayerInfoObject() |
| glyphSet.readLayerInfo(info) |
| self.assertEqual(None, info.color) |
| self.assertEqual(None, info.guidelines) |
| self.assertEqual(None, info.lib) |
| |
| def testBogusLayerInfo(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "glyphs", "layerinfo.plist") |
| os.remove(path) |
| with open(path, "w") as f: |
| f.write("test") |
| # read |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| info = TestLayerInfoObject() |
| self.assertRaises(UFOLibError, glyphSet.readLayerInfo, info) |
| |
| def testInvalidFormatLayerInfo(self): |
| self.makeUFO() |
| path = os.path.join(self.ufoPath, "glyphs", "layerinfo.plist") |
| info = [("color", "0,0,0,0")] |
| with open(path, "wb") as f: |
| plistlib.dump(info, f) |
| # read |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| info = TestLayerInfoObject() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, info) |
| |
| def testColor(self): |
| ## not a string |
| info = {} |
| info["color"] = 1 |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## not enough commas |
| info = {} |
| info["color"] = "1 0, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1 0 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1 0 0 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## not enough parts |
| info = {} |
| info["color"] = ", 0, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, , 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, 0, , 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, 0, 0, " |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = ", , , " |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## not a number in all positions |
| info = {} |
| info["color"] = "r, 1, 1, 1" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, g, 1, 1" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, 1, b, 1" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "1, 1, 1, a" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## too many parts |
| info = {} |
| info["color"] = "1, 0, 0, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## < 0 in each position |
| info = {} |
| info["color"] = "-1, 0, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, -1, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, 0, -1, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, 0, 0, -1" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| ## > 1 in each position |
| info = {} |
| info["color"] = "2, 0, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, 2, 0, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, 0, 2, 0" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| info = {} |
| info["color"] = "0, 0, 0, 2" |
| self.makeUFO(layerInfo=info) |
| reader = UFOReader(self.ufoPath, validate=True) |
| glyphSet = reader.getGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.readLayerInfo, TestLayerInfoObject()) |
| |
| |
| class UFO3WriteLayerInfoTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| self.tempDir = tempfile.mktemp() |
| os.mkdir(self.tempDir) |
| self.ufoPath = os.path.join(self.tempDir, "test.ufo") |
| |
| def tearDown(self): |
| shutil.rmtree(self.tempDir) |
| |
| def makeGlyphSet(self): |
| self.clearUFO() |
| writer = UFOWriter(self.ufoPath) |
| return writer.getGlyphSet() |
| |
| def clearUFO(self): |
| if os.path.exists(self.ufoPath): |
| shutil.rmtree(self.ufoPath) |
| |
| def testValidWrite(self): |
| expected = dict( |
| color="0,0,0,1", |
| lib={"foo" : "bar"} |
| ) |
| info = TestLayerInfoObject() |
| info.color = expected["color"] |
| info.lib = expected["lib"] |
| glyphSet = self.makeGlyphSet() |
| glyphSet.writeLayerInfo(info) |
| path = os.path.join(self.ufoPath, "glyphs", "layerinfo.plist") |
| with open(path, "rb") as f: |
| result = plistlib.load(f) |
| self.assertEqual(expected, result) |
| |
| def testColor(self): |
| ## not a string |
| info = TestLayerInfoObject() |
| info.color = 1 |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## not enough commas |
| info = TestLayerInfoObject() |
| info.color = "1 0, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1 0 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1 0 0 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## not enough parts |
| info = TestLayerInfoObject() |
| info.color = ", 0, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, , 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, 0, , 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, 0, 0, " |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = ", , , " |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## not a number in all positions |
| info = TestLayerInfoObject() |
| info.color = "r, 1, 1, 1" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, g, 1, 1" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, 1, b, 1" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "1, 1, 1, a" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## too many parts |
| info = TestLayerInfoObject() |
| info.color = "1, 0, 0, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## < 0 in each position |
| info = TestLayerInfoObject() |
| info.color = "-1, 0, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, -1, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, 0, -1, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, 0, 0, -1" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| ## > 1 in each position |
| info = TestLayerInfoObject() |
| info.color = "2, 0, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, 2, 0, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, 0, 2, 0" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |
| info = TestLayerInfoObject() |
| info.color = "0, 0, 0, 2" |
| glyphSet = self.makeGlyphSet() |
| self.assertRaises(GlifLibError, glyphSet.writeLayerInfo, info) |