From 1f8ddaddfdce30c3b1dfd2a5ab2a80fb2a0c2eee Mon Sep 17 00:00:00 2001 From: James Godfrey-Kittle Date: Tue, 29 Sep 2015 18:09:59 -0700 Subject: Move exhaustive tests to common_tests --- scripts/common_tests.py | 74 ++++++++++++++++++++++++++++++++ scripts/run_android_tests.py | 56 +----------------------- scripts/run_exhaustive_tests.py | 94 ++++------------------------------------- 3 files changed, 85 insertions(+), 139 deletions(-) diff --git a/scripts/common_tests.py b/scripts/common_tests.py index e92e1c8..9c9eef5 100644 --- a/scripts/common_tests.py +++ b/scripts/common_tests.py @@ -24,6 +24,7 @@ from fontTools import ttLib from nototools import coverage from nototools import font_data from nototools import noto_fonts +from nototools import unicode_data import freetype @@ -505,3 +506,76 @@ class TestGlyphAreas(unittest.TestCase): else: msg = name + " has changed, but should not have." self.assertEqual(unchanged, name in self.unchanged, msg) + + +class TestSpacingMarks(FontTest): + """Tests that spacing marks are indeed spacing.""" + + def setUp(self): + self.font_files, _ = self.loaded_fonts + charset = coverage.character_set(self.font_files[0]) + self.marks_to_test = [char for char in charset + if unicode_data.category(char) in ['Lm', 'Sk']] + self.advance_cache = {} + + def test_individual_spacing_marks(self): + """Tests that spacing marks are spacing by themselves.""" + for font in self.font_files: + print 'Testing %s for stand-alone spacing marks...' % font + for mark in self.marks_to_test: + mark = unichr(mark) + advances = layout.get_advances(mark, font) + assert len(advances) == 1 + self.assertNotEqual(advances[0], 0) + + def test_spacing_marks_in_combination(self): + """Tests that spacing marks do not combine with base letters.""" + for font in self.font_files: + print 'Testing %s for spacing marks in combination...' % font + for base_letter in (u'A\u00C6BCDEFGHIJKLMNO\u00D8\u01A0PRST' + u'U\u01AFVWXYZ' + u'a\u00E6bcdefghi\u0131j\u0237klmn' + u'o\u00F8\u01A1prs\u017Ftu\u01B0vwxyz' + u'\u03D2'): + print 'Testing %s combinations' % base_letter + for mark in self.marks_to_test: + if mark == 0x02DE: + # Skip rhotic hook, as it's perhaps OK for it to form + # ligatures + continue + mark = unichr(mark) + advances = layout.get_advances(base_letter + mark, font) + self.assertEqual(len(advances), 2, + 'The sequence <%04X, %04X> combines, ' + 'but it should not' % (ord(base_letter), ord(mark))) + + +class TestSoftDottedChars(FontTest): + """Tests that soft-dotted characters lose their dots.""" + + def setUp(self): + self.font_files, _ = self.loaded_fonts + charset = coverage.character_set(self.font_files[0]) + self.marks_to_test = [char for char in charset + if unicode_data.combining(char) == 230] + self.advance_cache = {} + + def test_combinations(self): + """Tests that soft-dotted characters lose their dots when combined.""" + + for font in self.font_files: + print 'Testing %s for soft-dotted combinations...' % font + + # TODO: replace the following list with actual derivation based on + # Unicode's soft-dotted property + for base_letter in (u'ij\u012F\u0249\u0268\u029D\u02B2\u03F3\u0456' + u'\u0458\u1D62\u1D96\u1DA4\u1DA8\u1E2D\u1ECB' + u'\u2071\u2C7C'): + print 'Testing %s combinations' % base_letter.encode('UTF-8') + for mark in self.marks_to_test: + mark = unichr(mark) + letter_only = layout.get_glyphs(base_letter, font) + combination = layout.get_glyphs(base_letter + mark, font) + self.assertNotEqual(combination[0], letter_only[0], + "The sequence <%04X, %04X> doesn't lose its dot, " + "but it should" % (ord(base_letter), ord(mark))) diff --git a/scripts/run_android_tests.py b/scripts/run_android_tests.py index 6c69f30..f10c7fd 100755 --- a/scripts/run_android_tests.py +++ b/scripts/run_android_tests.py @@ -16,15 +16,8 @@ """Test assumptions that Android relies on.""" -import glob -import json import unittest -from fontTools import ttLib -from nototools import coverage -from nototools import font_data -from nototools import render -from nototools import unicode_data import common_tests @@ -64,53 +57,8 @@ class TestCharacterCoverage(common_tests.TestCharacterCoverage): ) - include # don't exclude legacy PUA -class TestSpacingMarks(unittest.TestCase): - """Tests that spacing marks are indeed spacing.""" - - def setUp(self): - self.font_files, _ = load_fonts() - charset = coverage.character_set(self.font_files[0]) - self.marks_to_test = [char for char in charset - if unicode_data.category(char) in ['Lm', 'Sk']] - self.advance_cache = {} - - def get_advances(self, text, font): - """Get a list of horizontal advances for text rendered in a font.""" - try: - return self.advance_cache[(text, font)] - except KeyError: - hb_output = render.run_harfbuzz_on_text(text, font, '') - hb_output = json.loads(hb_output) - advances = [glyph['ax'] for glyph in hb_output] - self.advance_cache[(text, font)] = advances - return advances - - def test_individual_spacing_marks(self): - """Tests that spacing marks are spacing by themselves.""" - for font in self.font_files: - print 'Testing %s for stand-alone spacing marks...' % font - for mark in self.marks_to_test: - mark = unichr(mark) - advances = self.get_advances(mark, font) - assert len(advances) == 1 - self.assertNotEqual(advances[0], 0) - - def test_spacing_marks_in_combination(self): - """Tests that spacing marks do not combine with base letters.""" - for font in self.font_files: - print 'Testing %s for spacing marks in combination...' % font - for base_letter in (u'A\u00C6BCDEFGHIJKLMNO\u00D8\u01A0PRST' - u'U\u01AFVWXYZ' - u'a\u00E6bcdefghi\u0131j\u0237klmn' - u'o\u00F8\u01A1prs\u017Ftu\u01B0vwxyz' - u'\u03D2'): - print 'Testing %s combinations' % base_letter - for mark in self.marks_to_test: - mark = unichr(mark) - advances = self.get_advances(base_letter + mark, font) - self.assertEqual(len(advances), 2, - 'The sequence <%04X, %04X> combines, ' - 'but it should not' % (ord(base_letter), ord(mark))) +class TestSpacingMarks(common_tests.TestSpacingMarks): + loaded_fonts = FONTS if __name__ == '__main__': diff --git a/scripts/run_exhaustive_tests.py b/scripts/run_exhaustive_tests.py index e7425ad..19eb960 100755 --- a/scripts/run_exhaustive_tests.py +++ b/scripts/run_exhaustive_tests.py @@ -16,97 +16,21 @@ """Time-consuming tests for general health of the fonts.""" -import glob import unittest -from fontTools import ttLib -from nototools import coverage -from nototools import unicode_data +FONTS = common_tests.load_fonts( + ['out/RobotoTTF/*.ttf', 'out/RobotoCondensedTTF/*.ttf'], + expected_count=18) -import layout -def load_fonts(): - """Load all major fonts.""" - all_font_files = (glob.glob('out/RobotoTTF/*.ttf') - + glob.glob('out/RobotoCondensedTTF/*.ttf')) - all_fonts = [ttLib.TTFont(font) for font in all_font_files] - assert len(all_font_files) == 18 - return all_font_files, all_fonts +class TestSpacingMarks(common_tests.TestSpacingMarks): + loaded_fonts = FONTS -class TestSpacingMarks(unittest.TestCase): - """Tests that spacing marks are indeed spacing.""" - - def setUp(self): - self.font_files, _ = load_fonts() - charset = coverage.character_set(self.font_files[0]) - self.marks_to_test = [char for char in charset - if unicode_data.category(char) in ['Lm', 'Sk']] - self.advance_cache = {} - - def test_individual_spacing_marks(self): - """Tests that spacing marks are spacing by themselves.""" - for font in self.font_files: - print 'Testing %s for stand-alone spacing marks...' % font - for mark in self.marks_to_test: - mark = unichr(mark) - advances = layout.get_advances(mark, font) - assert len(advances) == 1 - self.assertNotEqual(advances[0], 0) - - def test_spacing_marks_in_combination(self): - """Tests that spacing marks do not combine with base letters.""" - for font in self.font_files: - print 'Testing %s for spacing marks in combination...' % font - for base_letter in (u'A\u00C6BCDEFGHIJKLMNO\u00D8\u01A0PRST' - u'U\u01AFVWXYZ' - u'a\u00E6bcdefghi\u0131j\u0237klmn' - u'o\u00F8\u01A1prs\u017Ftu\u01B0vwxyz' - u'\u03D2'): - print 'Testing %s combinations' % base_letter - for mark in self.marks_to_test: - if mark == 0x02DE: - # Skip rhotic hook, as it's perhaps OK for it to form - # ligatures - continue - mark = unichr(mark) - advances = layout.get_advances(base_letter + mark, font) - self.assertEqual(len(advances), 2, - 'The sequence <%04X, %04X> combines, ' - 'but it should not' % (ord(base_letter), ord(mark))) - - -class TestSoftDottedChars(unittest.TestCase): - """Tests that soft-dotted characters lose their dots.""" - - def setUp(self): - self.font_files, _ = load_fonts() - charset = coverage.character_set(self.font_files[0]) - self.marks_to_test = [char for char in charset - if unicode_data.combining(char) == 230] - self.advance_cache = {} - - def test_combinations(self): - """Tests that soft-dotted characters lose their dots when combined.""" - - return # FIXME: Test is currently disabled, since the fonts fail it - - for font in self.font_files: - print 'Testing %s for soft-dotted combinations...' % font - - # TODO: replace the following list with actual derivation based on - # Unicode's soft-dotted property - for base_letter in (u'ij\u012F\u0249\u0268\u029D\u02B2\u03F3\u0456' - u'\u0458\u1D62\u1D96\u1DA4\u1DA8\u1E2D\u1ECB' - u'\u2071\u2C7C'): - print 'Testing %s combinations' % base_letter.encode('UTF-8') - for mark in self.marks_to_test: - mark = unichr(mark) - letter_only = layout.get_glyphs(base_letter, font) - combination = layout.get_glyphs(base_letter + mark, font) - self.assertNotEqual(combination[0], letter_only[0], - "The sequence <%04X, %04X> doesn't lose its dot, " - "but it should" % (ord(base_letter), ord(mark))) +class TestSoftDottedChars(common_tests.TestSoftDottedChars): + loaded_fonts = FONTS + # FIXME: Test is currently disabled, since the fonts fail it + test_combinations = None if __name__ == '__main__': -- cgit v1.2.3