from __future__ import print_function, division, absolute_import
from fontTools.misc.py23 import *
from fontTools.misc.testTools import parseXML
from fontTools.misc.timeTools import timestampSinceEpoch
from fontTools.ttLib import TTFont, TTLibError
from fontTools import ttx
import getopt
import logging
import os
import shutil
import sys
import tempfile
import unittest
import pytest
try:
import zopfli
except ImportError:
zopfli = None
try:
import brotli
except ImportError:
brotli = None
class TTXTest(unittest.TestCase):
def __init__(self, methodName):
unittest.TestCase.__init__(self, methodName)
# Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
# and fires deprecation warnings if a program uses the old name.
if not hasattr(self, "assertRaisesRegex"):
self.assertRaisesRegex = self.assertRaisesRegexp
def setUp(self):
self.tempdir = None
self.num_tempfiles = 0
def tearDown(self):
if self.tempdir:
shutil.rmtree(self.tempdir)
@staticmethod
def getpath(testfile):
path, _ = os.path.split(__file__)
return os.path.join(path, "data", testfile)
def temp_dir(self):
if not self.tempdir:
self.tempdir = tempfile.mkdtemp()
def temp_font(self, font_path, file_name):
self.temp_dir()
temppath = os.path.join(self.tempdir, file_name)
shutil.copy2(font_path, temppath)
return temppath
@staticmethod
def read_file(file_path):
with open(file_path, "r", encoding="utf-8") as f:
return f.readlines()
# -----
# Tests
# -----
def test_parseOptions_no_args(self):
with self.assertRaises(getopt.GetoptError) as cm:
ttx.parseOptions([])
self.assertTrue(
"Must specify at least one input file" in str(cm.exception)
)
def test_parseOptions_invalid_path(self):
file_path = "invalid_font_path"
with self.assertRaises(getopt.GetoptError) as cm:
ttx.parseOptions([file_path])
self.assertTrue('File not found: "%s"' % file_path in str(cm.exception))
def test_parseOptions_font2ttx_1st_time(self):
file_name = "TestOTF.otf"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
jobs, _ = ttx.parseOptions([temp_path])
self.assertEqual(jobs[0][0].__name__, "ttDump")
self.assertEqual(
jobs[0][1:],
(
os.path.join(self.tempdir, file_name),
os.path.join(self.tempdir, file_name.split(".")[0] + ".ttx"),
),
)
def test_parseOptions_font2ttx_2nd_time(self):
file_name = "TestTTF.ttf"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
_, _ = ttx.parseOptions([temp_path]) # this is NOT a mistake
jobs, _ = ttx.parseOptions([temp_path])
self.assertEqual(jobs[0][0].__name__, "ttDump")
self.assertEqual(
jobs[0][1:],
(
os.path.join(self.tempdir, file_name),
os.path.join(self.tempdir, file_name.split(".")[0] + "#1.ttx"),
),
)
def test_parseOptions_ttx2font_1st_time(self):
file_name = "TestTTF.ttx"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
jobs, _ = ttx.parseOptions([temp_path])
self.assertEqual(jobs[0][0].__name__, "ttCompile")
self.assertEqual(
jobs[0][1:],
(
os.path.join(self.tempdir, file_name),
os.path.join(self.tempdir, file_name.split(".")[0] + ".ttf"),
),
)
def test_parseOptions_ttx2font_2nd_time(self):
file_name = "TestOTF.ttx"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
_, _ = ttx.parseOptions([temp_path]) # this is NOT a mistake
jobs, _ = ttx.parseOptions([temp_path])
self.assertEqual(jobs[0][0].__name__, "ttCompile")
self.assertEqual(
jobs[0][1:],
(
os.path.join(self.tempdir, file_name),
os.path.join(self.tempdir, file_name.split(".")[0] + "#1.otf"),
),
)
def test_parseOptions_multiple_fonts(self):
file_names = ["TestOTF.otf", "TestTTF.ttf"]
font_paths = [self.getpath(file_name) for file_name in file_names]
temp_paths = [
self.temp_font(font_path, file_name)
for font_path, file_name in zip(font_paths, file_names)
]
jobs, _ = ttx.parseOptions(temp_paths)
for i in range(len(jobs)):
self.assertEqual(jobs[i][0].__name__, "ttDump")
self.assertEqual(
jobs[i][1:],
(
os.path.join(self.tempdir, file_names[i]),
os.path.join(
self.tempdir, file_names[i].split(".")[0] + ".ttx"
),
),
)
def test_parseOptions_mixed_files(self):
operations = ["ttDump", "ttCompile"]
extensions = [".ttx", ".ttf"]
file_names = ["TestOTF.otf", "TestTTF.ttx"]
font_paths = [self.getpath(file_name) for file_name in file_names]
temp_paths = [
self.temp_font(font_path, file_name)
for font_path, file_name in zip(font_paths, file_names)
]
jobs, _ = ttx.parseOptions(temp_paths)
for i in range(len(jobs)):
self.assertEqual(jobs[i][0].__name__, operations[i])
self.assertEqual(
jobs[i][1:],
(
os.path.join(self.tempdir, file_names[i]),
os.path.join(
self.tempdir,
file_names[i].split(".")[0] + extensions[i],
),
),
)
def test_parseOptions_splitTables(self):
file_name = "TestTTF.ttf"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
args = ["-s", temp_path]
jobs, options = ttx.parseOptions(args)
ttx_file_path = jobs[0][2]
temp_folder = os.path.dirname(ttx_file_path)
self.assertTrue(options.splitTables)
self.assertTrue(os.path.exists(ttx_file_path))
ttx.process(jobs, options)
# Read the TTX file but strip the first two and the last lines:
# <?xml version="1.0" encoding="UTF-8"?>
# <ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.22">
# ...
# </ttFont>
parsed_xml = parseXML(self.read_file(ttx_file_path)[2:-1])
for item in parsed_xml:
if not isinstance(item, tuple):
continue
# the tuple looks like this:
# (u'head', {u'src': u'TestTTF._h_e_a_d.ttx'}, [])
table_file_name = item[1].get("src")
table_file_path = os.path.join(temp_folder, table_file_name)
self.assertTrue(os.path.exists(table_file_path))
def test_parseOptions_splitGlyphs(self):
file_name = "TestTTF.ttf"
font_path = self.getpath(file_name)
temp_path = self.temp_font(font_path, file_name)
args = ["-g", temp_path]
jobs, options = ttx.parseOptions(args)
ttx_file_path = jobs[0][2]
temp_folder = os.path.dirname(ttx_file_path)
self.assertTrue(options.splitGlyphs)
# splitGlyphs also forces splitTables
self.assertTrue(options.splitTables)
self.assertTrue(os.path.exists(ttx_file_path))
ttx.process(jobs, options)
# Read the TTX file but strip the first two and the last lines:
# <?xml version="1.0" encoding="UTF-8"?>
# <ttFont sfntVersion="\x00\x01\x00\x00" ttLibVersion="3.22">
# ...
# </ttFont>
for item in parseXML(self.read_file(ttx_file_path)[2:-1]):
if not isinstance(item, tuple):
continue
# the tuple looks like this:
# (u'head', {u'src': u'TestTTF._h_e_a_d.ttx'}, [])
table_tag = item[0]
table_file_name = item[1].get("src")
table_file_path = os.path.join(temp_folder, table_file_name)
self.assertTrue(os.path.exists(table_file_path))
if table_tag != "glyf":
continue
# also strip the enclosing 'glyf' element
for item in parseXML(self.read_file(table_file_path)[4:-3]):
if not isinstance(item, tuple):
continue
# glyphs without outline data only have 'name' attribute
glyph_file_name = item[1].get("src")
if glyph_file_name is not None:
glyph_file_path = os.path.join(temp_folder, glyph_file_name)
self.assertTrue(os.path.exists(glyph_file_path))
def test_guessFileType_ttf(self):
file_name = "TestTTF.ttf"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTF")
def test_guessFileType_otf(self):
file_name = "TestOTF.otf"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "OTF")
def test_guessFileType_woff(self):
file_name = "TestWOFF.woff"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "WOFF")
def test_guessFileType_woff2(self):
file_name = "TestWOFF2.woff2"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "WOFF2")
def test_guessFileType_ttc(self):
file_name = "TestTTC.ttc"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTC")
def test_guessFileType_dfont(self):
file_name = "TestDFONT.dfont"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTF")
def test_guessFileType_ttx_ttf(self):
file_name = "TestTTF.ttx"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTX")
def test_guessFileType_ttx_otf(self):
file_name = "TestOTF.ttx"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "OTX")
def test_guessFileType_ttx_bom(self):
file_name = "TestBOM.ttx"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTX")
def test_guessFileType_ttx_no_sfntVersion(self):
file_name = "TestNoSFNT.ttx"
font_path = self.getpath(file_name)
self.assertEqual(ttx.guessFileType(font_path), "TTX")
def test_guessFileType_ttx_no_xml(self):
file_name = "TestNoXML.ttx"
font_path = self.getpath(file_name)
self.assertIsNone(ttx.guessFileType(font_path))
def test_guessFileType_invalid_path(self):
font_path = "invalid_font_path"
self.assertIsNone(ttx.guessFileType(font_path))
# -----------------------
# ttx.Options class tests
# -----------------------
def test_options_flag_h(capsys):
with pytest.raises(SystemExit):
ttx.Options([("-h", None)], 1)
out, err = capsys.readouterr()
assert "TTX -- From OpenType To XML And Back" in out
def test_options_flag_version(capsys):
with pytest.raises(SystemExit):
ttx.Options([("--version", None)], 1)
out, err = capsys.readouterr()
version_list = out.split(".")
assert len(version_list) >= 3
assert version_list[0].isdigit()
assert version_list[1].isdigit()
assert version_list[2].strip().isdigit()
def test_options_d_goodpath(tmpdir):
temp_dir_path = str(tmpdir)
tto = ttx.Options([("-d", temp_dir_path)], 1)
assert tto.outputDir == temp_dir_path
def test_options_d_badpath():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-d", "bogusdir")], 1)
def test_options_o():
tto = ttx.Options([("-o", "testfile.ttx")], 1)
assert tto.outputFile == "testfile.ttx"
def test_options_f():
tto = ttx.Options([("-f", "")], 1)
assert tto.overWrite is True
def test_options_v():
tto = ttx.Options([("-v", "")], 1)
assert tto.verbose is True
assert tto.logLevel == logging.DEBUG
def test_options_q():
tto = ttx.Options([("-q", "")], 1)
assert tto.quiet is True
assert tto.logLevel == logging.WARNING
def test_options_l():
tto = ttx.Options([("-l", "")], 1)
assert tto.listTables is True
def test_options_t_nopadding():
tto = ttx.Options([("-t", "CFF2")], 1)
assert len(tto.onlyTables) == 1
assert tto.onlyTables[0] == "CFF2"
def test_options_t_withpadding():
tto = ttx.Options([("-t", "CFF")], 1)
assert len(tto.onlyTables) == 1
assert tto.onlyTables[0] == "CFF "
def test_options_s():
tto = ttx.Options([("-s", "")], 1)
assert tto.splitTables is True
assert tto.splitGlyphs is False
def test_options_g():
tto = ttx.Options([("-g", "")], 1)
assert tto.splitGlyphs is True
assert tto.splitTables is True
def test_options_i():
tto = ttx.Options([("-i", "")], 1)
assert tto.disassembleInstructions is False
def test_options_z_validoptions():
valid_options = ("raw", "row", "bitwise", "extfile")
for option in valid_options:
tto = ttx.Options([("-z", option)], 1)
assert tto.bitmapGlyphDataFormat == option
def test_options_z_invalidoption():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-z", "bogus")], 1)
def test_options_y_validvalue():
tto = ttx.Options([("-y", "1")], 1)
assert tto.fontNumber == 1
def test_options_y_invalidvalue():
with pytest.raises(ValueError):
ttx.Options([("-y", "A")], 1)
def test_options_m():
tto = ttx.Options([("-m", "testfont.ttf")], 1)
assert tto.mergeFile == "testfont.ttf"
def test_options_b():
tto = ttx.Options([("-b", "")], 1)
assert tto.recalcBBoxes is False
def test_options_a():
tto = ttx.Options([("-a", "")], 1)
assert tto.allowVID is True
def test_options_e():
tto = ttx.Options([("-e", "")], 1)
assert tto.ignoreDecompileErrors is False
def test_options_unicodedata():
tto = ttx.Options([("--unicodedata", "UnicodeData.txt")], 1)
assert tto.unicodedata == "UnicodeData.txt"
def test_options_newline_lf():
tto = ttx.Options([("--newline", "LF")], 1)
assert tto.newlinestr == "\n"
def test_options_newline_cr():
tto = ttx.Options([("--newline", "CR")], 1)
assert tto.newlinestr == "\r"
def test_options_newline_crlf():
tto = ttx.Options([("--newline", "CRLF")], 1)
assert tto.newlinestr == "\r\n"
def test_options_newline_invalid():
with pytest.raises(getopt.GetoptError):
ttx.Options([("--newline", "BOGUS")], 1)
def test_options_recalc_timestamp():
tto = ttx.Options([("--recalc-timestamp", "")], 1)
assert tto.recalcTimestamp is True
def test_options_recalc_timestamp():
tto = ttx.Options([("--no-recalc-timestamp", "")], 1)
assert tto.recalcTimestamp is False
def test_options_flavor():
tto = ttx.Options([("--flavor", "woff")], 1)
assert tto.flavor == "woff"
def test_options_with_zopfli():
tto = ttx.Options([("--with-zopfli", ""), ("--flavor", "woff")], 1)
assert tto.useZopfli is True
def test_options_with_zopfli_fails_without_woff_flavor():
with pytest.raises(getopt.GetoptError):
ttx.Options([("--with-zopfli", "")], 1)
def test_options_quiet_and_verbose_shouldfail():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-q", ""), ("-v", "")], 1)
def test_options_mergefile_and_flavor_shouldfail():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-m", "testfont.ttf"), ("--flavor", "woff")], 1)
def test_options_onlytables_and_skiptables_shouldfail():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-t", "CFF"), ("-x", "CFF2")], 1)
def test_options_mergefile_and_multiplefiles_shouldfail():
with pytest.raises(getopt.GetoptError):
ttx.Options([("-m", "testfont.ttf")], 2)
def test_options_woff2_and_zopfli_shouldfail():
with pytest.raises(getopt.GetoptError):
ttx.Options([("--with-zopfli", ""), ("--flavor", "woff2")], 1)
# ----------------------------
# ttx.ttCompile function tests
# ----------------------------
def test_ttcompile_otf_compile_default(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestOTF.ttx")
# outotf = os.path.join(str(tmpdir), "TestOTF.otf")
outotf = tmpdir.join("TestOTF.ttx")
default_options = ttx.Options([], 1)
ttx.ttCompile(inttx, str(outotf), default_options)
# confirm that font was built
assert outotf.check(file=True)
# confirm that it is valid OTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outotf))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
"DSIG",
)
for table in expected_tables:
assert table in ttf
def test_ttcompile_otf_to_woff_without_zopfli(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestOTF.ttx")
outwoff = tmpdir.join("TestOTF.woff")
options = ttx.Options([], 1)
options.flavor = "woff"
ttx.ttCompile(inttx, str(outwoff), options)
# confirm that font was built
assert outwoff.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
"DSIG",
)
for table in expected_tables:
assert table in ttf
@pytest.mark.skipif(zopfli is None, reason="zopfli not installed")
def test_ttcompile_otf_to_woff_with_zopfli(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestOTF.ttx")
outwoff = tmpdir.join("TestOTF.woff")
options = ttx.Options([], 1)
options.flavor = "woff"
options.useZopfli = True
ttx.ttCompile(inttx, str(outwoff), options)
# confirm that font was built
assert outwoff.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
"DSIG",
)
for table in expected_tables:
assert table in ttf
@pytest.mark.skipif(brotli is None, reason="brotli not installed")
def test_ttcompile_otf_to_woff2(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestOTF.ttx")
outwoff2 = tmpdir.join("TestTTF.woff2")
options = ttx.Options([], 1)
options.flavor = "woff2"
ttx.ttCompile(inttx, str(outwoff2), options)
# confirm that font was built
assert outwoff2.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff2))
# DSIG should not be included from original ttx as per woff2 spec (https://dev.w3.org/webfonts/WOFF2/spec/)
assert "DSIG" not in ttf
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
)
for table in expected_tables:
assert table in ttf
def test_ttcompile_ttf_compile_default(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outttf = tmpdir.join("TestTTF.ttf")
default_options = ttx.Options([], 1)
ttx.ttCompile(inttx, str(outttf), default_options)
# confirm that font was built
assert outttf.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outttf))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
"DSIG",
)
for table in expected_tables:
assert table in ttf
def test_ttcompile_ttf_to_woff_without_zopfli(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outwoff = tmpdir.join("TestTTF.woff")
options = ttx.Options([], 1)
options.flavor = "woff"
ttx.ttCompile(inttx, str(outwoff), options)
# confirm that font was built
assert outwoff.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
"DSIG",
)
for table in expected_tables:
assert table in ttf
@pytest.mark.skipif(zopfli is None, reason="zopfli not installed")
def test_ttcompile_ttf_to_woff_with_zopfli(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outwoff = tmpdir.join("TestTTF.woff")
options = ttx.Options([], 1)
options.flavor = "woff"
options.useZopfli = True
ttx.ttCompile(inttx, str(outwoff), options)
# confirm that font was built
assert outwoff.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff))
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
"DSIG",
)
for table in expected_tables:
assert table in ttf
@pytest.mark.skipif(brotli is None, reason="brotli not installed")
def test_ttcompile_ttf_to_woff2(tmpdir):
inttx = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outwoff2 = tmpdir.join("TestTTF.woff2")
options = ttx.Options([], 1)
options.flavor = "woff2"
ttx.ttCompile(inttx, str(outwoff2), options)
# confirm that font was built
assert outwoff2.check(file=True)
# confirm that it is valid TTF file, can instantiate a TTFont, has expected OpenType tables
ttf = TTFont(str(outwoff2))
# DSIG should not be included from original ttx as per woff2 spec (https://dev.w3.org/webfonts/WOFF2/spec/)
assert "DSIG" not in ttf
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
)
for table in expected_tables:
assert table in ttf
@pytest.mark.parametrize(
"inpath, outpath1, outpath2",
[
("TestTTF.ttx", "TestTTF1.ttf", "TestTTF2.ttf"),
("TestOTF.ttx", "TestOTF1.otf", "TestOTF2.otf"),
],
)
def test_ttcompile_timestamp_calcs(inpath, outpath1, outpath2, tmpdir):
inttx = os.path.join("Tests", "ttx", "data", inpath)
outttf1 = tmpdir.join(outpath1)
outttf2 = tmpdir.join(outpath2)
options = ttx.Options([], 1)
# build with default options = do not recalculate timestamp
ttx.ttCompile(inttx, str(outttf1), options)
# confirm that font was built
assert outttf1.check(file=True)
# confirm that timestamp is same as modified time on ttx file
mtime = os.path.getmtime(inttx)
epochtime = timestampSinceEpoch(mtime)
ttf = TTFont(str(outttf1))
assert ttf["head"].modified == epochtime
# reset options to recalculate the timestamp and compile new font
options.recalcTimestamp = True
ttx.ttCompile(inttx, str(outttf2), options)
# confirm that font was built
assert outttf2.check(file=True)
# confirm that timestamp is more recent than modified time on ttx file
mtime = os.path.getmtime(inttx)
epochtime = timestampSinceEpoch(mtime)
ttf = TTFont(str(outttf2))
assert ttf["head"].modified > epochtime
# --no-recalc-timestamp will keep original timestamp
options.recalcTimestamp = False
ttx.ttCompile(inttx, str(outttf2), options)
assert outttf2.check(file=True)
inttf = TTFont()
inttf.importXML(inttx)
assert inttf["head"].modified == TTFont(str(outttf2))["head"].modified
# -------------------------
# ttx.ttList function tests
# -------------------------
def test_ttlist_ttf(capsys, tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttf")
fakeoutpath = tmpdir.join("TestTTF.ttx")
options = ttx.Options([], 1)
options.listTables = True
ttx.ttList(inpath, str(fakeoutpath), options)
out, err = capsys.readouterr()
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
"DSIG",
)
# confirm that expected tables are printed to stdout
for table in expected_tables:
assert table in out
# test for one of the expected tag/checksum/length/offset strings
assert "OS/2 0x67230FF8 96 376" in out
def test_ttlist_otf(capsys, tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestOTF.otf")
fakeoutpath = tmpdir.join("TestOTF.ttx")
options = ttx.Options([], 1)
options.listTables = True
ttx.ttList(inpath, str(fakeoutpath), options)
out, err = capsys.readouterr()
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
"DSIG",
)
# confirm that expected tables are printed to stdout
for table in expected_tables:
assert table in out
# test for one of the expected tag/checksum/length/offset strings
assert "OS/2 0x67230FF8 96 272" in out
def test_ttlist_woff(capsys, tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestWOFF.woff")
fakeoutpath = tmpdir.join("TestWOFF.ttx")
options = ttx.Options([], 1)
options.listTables = True
options.flavor = "woff"
ttx.ttList(inpath, str(fakeoutpath), options)
out, err = capsys.readouterr()
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"post",
"CFF ",
"hmtx",
"DSIG",
)
# confirm that expected tables are printed to stdout
for table in expected_tables:
assert table in out
# test for one of the expected tag/checksum/length/offset strings
assert "OS/2 0x67230FF8 84 340" in out
@pytest.mark.skipif(brotli is None, reason="brotli not installed")
def test_ttlist_woff2(capsys, tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestWOFF2.woff2")
fakeoutpath = tmpdir.join("TestWOFF2.ttx")
options = ttx.Options([], 1)
options.listTables = True
options.flavor = "woff2"
ttx.ttList(inpath, str(fakeoutpath), options)
out, err = capsys.readouterr()
expected_tables = (
"head",
"hhea",
"maxp",
"OS/2",
"name",
"cmap",
"hmtx",
"fpgm",
"prep",
"cvt ",
"loca",
"glyf",
"post",
"gasp",
)
# confirm that expected tables are printed to stdout
for table in expected_tables:
assert table in out
# test for one of the expected tag/checksum/length/offset strings
assert "OS/2 0x67230FF8 96 0" in out
# -------------------
# main function tests
# -------------------
def test_main_default_ttf_dump_to_ttx(tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttf")
outpath = tmpdir.join("TestTTF.ttx")
args = ["-o", str(outpath), inpath]
ttx.main(args)
assert outpath.check(file=True)
def test_main_default_ttx_compile_to_ttf(tmpdir):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outpath = tmpdir.join("TestTTF.ttf")
args = ["-o", str(outpath), inpath]
ttx.main(args)
assert outpath.check(file=True)
def test_main_getopterror_missing_directory():
with pytest.raises(SystemExit):
with pytest.raises(getopt.GetoptError):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttf")
args = ["-d", "bogusdir", inpath]
ttx.main(args)
def test_main_keyboard_interrupt(tmpdir, monkeypatch, capsys):
with pytest.raises(SystemExit):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outpath = tmpdir.join("TestTTF.ttf")
args = ["-o", str(outpath), inpath]
monkeypatch.setattr(
ttx, "process", (lambda x, y: raise_exception(KeyboardInterrupt))
)
ttx.main(args)
out, err = capsys.readouterr()
assert "(Cancelled.)" in err
@pytest.mark.skipif(
sys.platform == "win32",
reason="waitForKeyPress function causes test to hang on Windows platform",
)
def test_main_system_exit(tmpdir, monkeypatch):
with pytest.raises(SystemExit):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outpath = tmpdir.join("TestTTF.ttf")
args = ["-o", str(outpath), inpath]
monkeypatch.setattr(
ttx, "process", (lambda x, y: raise_exception(SystemExit))
)
ttx.main(args)
def test_main_ttlib_error(tmpdir, monkeypatch, capsys):
with pytest.raises(SystemExit):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outpath = tmpdir.join("TestTTF.ttf")
args = ["-o", str(outpath), inpath]
monkeypatch.setattr(
ttx,
"process",
(lambda x, y: raise_exception(TTLibError("Test error"))),
)
ttx.main(args)
out, err = capsys.readouterr()
assert "Test error" in err
@pytest.mark.skipif(
sys.platform == "win32",
reason="waitForKeyPress function causes test to hang on Windows platform",
)
def test_main_base_exception(tmpdir, monkeypatch, capsys):
with pytest.raises(SystemExit):
inpath = os.path.join("Tests", "ttx", "data", "TestTTF.ttx")
outpath = tmpdir.join("TestTTF.ttf")
args = ["-o", str(outpath), inpath]
monkeypatch.setattr(
ttx,
"process",
(lambda x, y: raise_exception(Exception("Test error"))),
)
ttx.main(args)
out, err = capsys.readouterr()
assert "Unhandled exception has occurred" in err
# ---------------------------
# support functions for tests
# ---------------------------
def raise_exception(exception):
raise exception