Merge pull request #116 from jamesgk/testing

Test consolidation

5 files changed, 239 insertions, 322 deletions

diff --git a/scripts/common_tests.py b/scripts/common_tests.py
index 952e794..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
 
@@ -238,6 +239,24 @@ class TestNames(FontTest):
                 self.assertIn(17, records)
                 self.assertEqual(records[17], self.build_style(weight, slope))
 
+    def test_unique_identifier_and_full_name(self):
+        """Tests the unique identifier and full name."""
+        for font_file, records in zip(self.font_files, self.names):
+            family, weight, slope = self.parse_filename(font_file)
+            style = self.build_style(weight, slope)
+            expected_name = family + ' ' + style
+            self.assertEqual(records[3], expected_name)
+            self.assertEqual(records[4], expected_name)
+            self.assertFalse(records.has_key(18))
+
+    def test_postscript_name(self):
+        """Tests the postscript name."""
+        for font_file, records in zip(self.font_files, self.names):
+            family, weight, slope = self.parse_filename(font_file)
+            style = self.build_style(weight, slope)
+            expected_name = (family + '-' + style).replace(' ', '')
+            self.assertEqual(records[6], expected_name)
+
     def test_postscript_name_for_spaces(self):
         """Tests that there are no spaces in PostScript names."""
         for records in self.names:
@@ -277,39 +296,22 @@ class TestCharacterCoverage(FontTest):
 
     def setUp(self):
         _, self.fonts = self.loaded_fonts
-        self.LEGACY_PUA = frozenset({0xEE01, 0xEE02, 0xF6C3})
 
-    def test_inclusion_of_legacy_pua(self):
-        """Tests that legacy PUA characters remain in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            for char in self.LEGACY_PUA:
-                self.assertIn(char, charset)
+    def test_inclusion(self):
+        """Tests for characters which should be included."""
 
-    def test_non_inclusion_of_other_pua(self):
-        """Tests that there are not other PUA characters except legacy ones."""
         for font in self.fonts:
             charset = coverage.character_set(font)
-            pua_chars = {
-                char for char in charset
-                if 0xE000 <= char <= 0xF8FF or 0xF0000 <= char <= 0x10FFFF}
-            self.assertTrue(pua_chars <= self.LEGACY_PUA)
+            for char in self.include:
+                self.assertIn(char, charset)
 
-    def test_lack_of_unassigned_chars(self):
-        """Tests that unassigned characters are not in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            self.assertNotIn(0x2072, charset)
-            self.assertNotIn(0x2073, charset)
-            self.assertNotIn(0x208F, charset)
+    def test_exclusion(self):
+        """Tests that characters which should be excluded are absent."""
 
-    def test_inclusion_of_sound_recording_copyright(self):
-        """Tests that sound recording copyright symbol is in the fonts."""
         for font in self.fonts:
             charset = coverage.character_set(font)
-            self.assertIn(
-                0x2117, charset,  # SOUND RECORDING COPYRIGHT
-                'U+2117 not found in %s.' % font_data.font_name(font))
+            for char in self.exclude:
+                self.assertNotIn(char, charset)
 
 
 class TestLigatures(FontTest):
@@ -361,9 +363,6 @@ class TestFeatures(FontTest):
                     u''.join(chars_with_no_smcp).encode('UTF-8')))
 
 
-EXPECTED_YMIN = -555
-EXPECTED_YMAX = 2163
-
 class TestVerticalMetrics(FontTest):
     """Test the vertical metrics of fonts."""
 
@@ -377,8 +376,8 @@ class TestVerticalMetrics(FontTest):
         """
         for font in self.fonts:
             head_table = font['head']
-            self.assertEqual(head_table.yMin, EXPECTED_YMIN)
-            self.assertEqual(head_table.yMax, EXPECTED_YMAX)
+            self.assertEqual(head_table.yMin, self.expected_head_yMin)
+            self.assertEqual(head_table.yMax, self.expected_head_yMax)
 
     def test_glyphs_ymin_ymax(self):
         """Tests yMin and yMax of all glyphs to not go outside the range."""
@@ -392,7 +391,8 @@ class TestVerticalMetrics(FontTest):
                     continue
 
                 self.assertTrue(
-                    EXPECTED_YMIN <= y_min and y_max <= EXPECTED_YMAX,
+                    self.expected_head_yMin <= y_min and
+                    y_max <= self.expected_head_yMax,
                     ('The vertical metrics for glyph %s in %s exceed the '
                      'acceptable range: yMin=%d, yMax=%d' % (
                          glyph_name, font_file, y_min, y_max)))
@@ -402,9 +402,56 @@ class TestVerticalMetrics(FontTest):
         """
         for font in self.fonts:
             hhea_table = font['hhea']
-            self.assertEqual(hhea_table.descent, -500)
-            self.assertEqual(hhea_table.ascent, 1900)
-            self.assertEqual(hhea_table.lineGap, 0)
+            self.assertEqual(hhea_table.descent, self.expected_hhea_descent)
+            self.assertEqual(hhea_table.ascent, self.expected_hhea_ascent)
+            self.assertEqual(hhea_table.lineGap, self.expected_hhea_lineGap)
+
+    def test_os2_metrics(self):
+        """Tests OS/2 vertical metrics to be equal to the old values."""
+        for font in self.fonts:
+            os2_table = font['OS/2']
+            self.assertEqual(os2_table.sTypoDescender,
+                             self.expected_os2_sTypoDescender)
+            self.assertEqual(os2_table.sTypoAscender,
+                             self.expected_os2_sTypoAscender)
+            self.assertEqual(os2_table.sTypoLineGap,
+                             self.expected_os2_sTypoLineGap)
+            self.assertEqual(os2_table.usWinDescent,
+                             self.expected_os2_usWinDescent)
+            self.assertEqual(os2_table.usWinAscent,
+                             self.expected_os2_usWinAscent)
+
+
+class TestHints(FontTest):
+    """Tests hints."""
+
+    def setUp(self):
+        self.fontfiles, self.fonts = self.loaded_fonts
+
+    def test_existance_of_hints(self):
+        """Tests all glyphs and makes sure non-composite ones have hints."""
+        missing_hints = []
+        for font in self.fonts:
+            glyf_table = font['glyf']
+            for glyph_name in font.getGlyphOrder():
+                glyph = glyf_table[glyph_name]
+                if glyph.numberOfContours <= 0:  # composite or empty glyph
+                    continue
+                if len(glyph.program.bytecode) <= 0:
+                    missing_hints.append(
+                        (glyph_name, font_data.font_name(font)))
+
+        self.assertTrue(missing_hints == [])
+
+    def test_height_of_lowercase_o(self):
+        """Tests the height of the lowercase o in low resolutions."""
+        for fontfile in self.fontfiles:
+            for size in range(8, 30):  # Kind of arbitrary
+                o_height = get_rendered_char_height(
+                    fontfile, size, 'o')
+                n_height = get_rendered_char_height(
+                    fontfile, size, 'n')
+                self.assertEqual(o_height, n_height)
 
 
 class TestGlyphAreas(unittest.TestCase):
@@ -459,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 e978343..f10c7fd 100755
--- a/scripts/run_android_tests.py
+++ b/scripts/run_android_tests.py
@@ -16,151 +16,49 @@
 
 """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
-
-
-def load_fonts():
-    """Load all fonts built for Android."""
-    all_font_files = glob.glob('out/android/*.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 TestVerticalMetrics(unittest.TestCase):
-    """Test the vertical metrics of fonts."""
-
-    def setUp(self):
-        _, self.fonts = load_fonts()
-
-    def test_ymin_ymax(self):
-        """Tests yMin and yMax to be equal to what Android expects."""
-        for font in self.fonts:
-            head_table = font['head']
-            self.assertEqual(head_table.yMin, -555)
-            self.assertEqual(head_table.yMax, 2163)
-
-
-class TestDigitWidths(unittest.TestCase):
-    """Tests the width of digits."""
-
-    def setUp(self):
-        _, self.fonts = load_fonts()
-        self.digits = [
-            'zero', 'one', 'two', 'three', 'four',
-            'five', 'six', 'seven', 'eight', 'nine']
-
-    def test_digit_widths(self):
-        """Tests all decimal digits to make sure they have the same width."""
-        for font in self.fonts:
-            hmtx_table = font['hmtx']
-            widths = [hmtx_table[digit][0] for digit in self.digits]
-            self.assertEqual(len(set(widths)), 1)
-
-
-class TestCharacterCoverage(unittest.TestCase):
-    """Tests character coverage."""
-
-    def setUp(self):
-        _, self.fonts = load_fonts()
-        self.LEGACY_PUA = frozenset({0xEE01, 0xEE02, 0xF6C3})
-
-    def test_lack_of_arrows_and_combining_keycap(self):
-        """Tests that arrows and combining keycap are not in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            self.assertNotIn(0x20E3, charset)  # COMBINING ENCLOSING KEYCAP
-            self.assertNotIn(0x2191, charset)  # UPWARDS ARROW
-            self.assertNotIn(0x2193, charset)  # DOWNWARDS ARROW
-
-    def test_lack_of_unassigned_chars(self):
-        """Tests that unassigned characters are not in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            self.assertNotIn(0x2072, charset)
-            self.assertNotIn(0x2073, charset)
-            self.assertNotIn(0x208F, charset)
-
-    def test_inclusion_of_sound_recording_copyright(self):
-        """Tests that sound recording copyright symbol is in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            self.assertIn(
-                0x2117, charset,  # SOUND RECORDING COPYRIGHT
-                'U+2117 not found in %s.' % font_data.font_name(font))
-
-    def test_inclusion_of_legacy_pua(self):
-        """Tests that legacy PUA characters remain in the fonts."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            for char in self.LEGACY_PUA:
-                self.assertIn(char, charset)
-
-    def test_non_inclusion_of_other_pua(self):
-        """Tests that there are not other PUA characters except legacy ones."""
-        for font in self.fonts:
-            charset = coverage.character_set(font)
-            pua_chars = {
-                char for char in charset
-                if 0xE000 <= char <= 0xF8FF or 0xF0000 <= char <= 0x10FFFF}
-            self.assertTrue(pua_chars <= self.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)))
+import common_tests
+
+
+FONTS = common_tests.load_fonts(
+    ['out/android/*.ttf'],
+    expected_count=18)
+
+
+class TestVerticalMetrics(common_tests.TestVerticalMetrics):
+    loaded_fonts = FONTS
+    test_glyphs_ymin_ymax = None
+    test_hhea_table_metrics = None
+    test_os2_metrics = None
+
+    expected_head_yMin = -555
+    expected_head_yMax = 2163
+
+
+class TestDigitWidths(common_tests.TestDigitWidths):
+    loaded_fonts = FONTS
+    test_superscript_digits = None
+
+
+class TestCharacterCoverage(common_tests.TestCharacterCoverage):
+    loaded_fonts = FONTS
+
+    include = frozenset([
+        0x2117,  # SOUND RECORDING COPYRIGHT
+        0xEE01, 0xEE02, 0xF6C3])  # legacy PUA
+
+    exclude = frozenset([
+        0x20E3,  # COMBINING ENCLOSING KEYCAP
+        0x2191,  # UPWARDS ARROW
+        0x2193,  # DOWNWARDS ARROW
+        0x2072, 0x2073, 0x208F] +  # unassigned characters
+        range(0xE000, 0xF8FF + 1) + range(0xF0000, 0x10FFFF + 1)  # other PUA
+        ) - include  # don't exclude legacy PUA
+
+
+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__':
diff --git a/scripts/run_general_tests.py b/scripts/run_general_tests.py
index 7ec8fcc..30445cd 100755
--- a/scripts/run_general_tests.py
+++ b/scripts/run_general_tests.py
@@ -54,6 +54,15 @@ class TestDigitWidths(common_tests.TestDigitWidths):
 class TestCharacterCoverage(common_tests.TestCharacterCoverage):
     loaded_fonts = FONTS
 
+    include = frozenset([
+        0x2117,  # SOUND RECORDING COPYRIGHT
+        0xEE01, 0xEE02, 0xF6C3])  # legacy PUA
+
+    exclude = frozenset([
+        0x2072, 0x2073, 0x208F] +  # unassigned characters
+        range(0xE000, 0xF8FF + 1) + range(0xF0000, 0x10FFFF + 1)  # other PUA
+        ) - include  # don't exclude legacy PUA
+
 
 class TestLigatures(common_tests.TestLigatures):
     loaded_fonts = FONTS
@@ -67,6 +76,10 @@ class TestVerticalMetrics(common_tests.TestVerticalMetrics):
     loaded_fonts = FONTS
     test_ymin_ymax = None
     test_hhea_table_metrics = None
+    test_os2_metrics = None
+
+    expected_head_yMin = -555
+    expected_head_yMax = 2163
 
 
 class TestGlyphAreas(common_tests.TestGlyphAreas):
@@ -76,4 +89,3 @@ class TestGlyphAreas(common_tests.TestGlyphAreas):
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/scripts/run_web_tests.py b/scripts/run_web_tests.py
index 7687989..a6acc82 100755
--- a/scripts/run_web_tests.py
+++ b/scripts/run_web_tests.py
@@ -43,24 +43,6 @@ class TestNames(common_tests.TestNames):
     family_name = 'Roboto'
     mark_heavier_as_bold = True
 
-    def test_unique_identifier_and_full_name(self):
-        """Tests the unique identifier and full name."""
-        for font_file, records in zip(self.font_files, self.names):
-            family, weight, slope = self.parse_filename(font_file)
-            style = self.build_style(weight, slope)
-            expected_name = family + ' ' + style
-            self.assertEqual(records[3], expected_name)
-            self.assertEqual(records[4], expected_name)
-            self.assertFalse(records.has_key(18))
-
-    def test_postscript_name(self):
-        """Tests the postscript name."""
-        for font_file, records in zip(self.font_files, self.names):
-            family, weight, slope = self.parse_filename(font_file)
-            style = self.build_style(weight, slope)
-            expected_name = (family + '-' + style).replace(' ', '')
-            self.assertEqual(records[6], expected_name)
-
 
 class TestDigitWidths(common_tests.TestDigitWidths):
     loaded_fonts = FONTS
@@ -71,59 +53,40 @@ class TestDigitWidths(common_tests.TestDigitWidths):
 
 class TestCharacterCoverage(common_tests.TestCharacterCoverage):
     loaded_fonts = FONTS
-    test_inclusion_of_sound_recording_copyright = None
-
 
-class TestVerticalMetrics(common_tests.TestVerticalMetrics):
-    loaded_fonts = FONTS
+    include = frozenset([
+        0xEE01, 0xEE02, 0xF6C3])  # legacy PUA
 
-    def test_os2_metrics(self):
-        """Tests OS/2 vertical metrics to be equal to the old values."""
-        for font in self.fonts:
-            os2_table = font['OS/2']
-            self.assertEqual(os2_table.sTypoDescender, -512)
-            self.assertEqual(os2_table.sTypoAscender, 1536)
-            self.assertEqual(os2_table.sTypoLineGap, 102)
-            self.assertEqual(os2_table.usWinDescent, 512)
-            self.assertEqual(os2_table.usWinAscent, 1946)
+    exclude = frozenset([
+        0x2072, 0x2073, 0x208F] +  # unassigned characters
+        range(0xE000, 0xF8FF + 1) + range(0xF0000, 0x10FFFF + 1)  # other PUA
+        ) - include  # don't exclude legacy PUA
 
 
-class TestLigatures(common_tests.TestLigatures):
+class TestVerticalMetrics(common_tests.TestVerticalMetrics):
     loaded_fonts = FONTS
 
+    expected_head_yMin = -555
+    expected_head_yMax = 2163
 
-class TestHints(unittest.TestCase):
-    """Tests hints."""
+    expected_hhea_descent = -500
+    expected_hhea_ascent = 1900
+    expected_hhea_lineGap = 0
 
-    def setUp(self):
-        self.fontfiles, self.fonts = FONTS
+    expected_os2_sTypoDescender = -512
+    expected_os2_sTypoAscender = 1536
+    expected_os2_sTypoLineGap = 102
+    expected_os2_usWinDescent = 512
+    expected_os2_usWinAscent = 1946
 
-    def test_existance_of_hints(self):
-        """Tests all glyphs and makes sure non-composite ones have hints."""
-        missing_hints = []
-        for font in self.fonts:
-            glyf_table = font['glyf']
-            for glyph_name in font.getGlyphOrder():
-                glyph = glyf_table[glyph_name]
-                if glyph.numberOfContours <= 0:  # composite or empty glyph
-                    continue
-                if len(glyph.program.bytecode) <= 0:
-                    missing_hints.append(
-                        (glyph_name, font_data.font_name(font)))
 
-        self.assertTrue(missing_hints == [])
+class TestLigatures(common_tests.TestLigatures):
+    loaded_fonts = FONTS
 
-    def test_height_of_lowercase_o(self):
-        """Tests the height of the lowercase o in low resolutions."""
-        for fontfile in self.fontfiles:
-            for size in range(8, 30):  # Kind of arbitrary
-                o_height = common_tests.get_rendered_char_height(
-                    fontfile, size, 'o')
-                n_height = common_tests.get_rendered_char_height(
-                    fontfile, size, 'n')
-                self.assertEqual(o_height, n_height)
+
+class TestHints(common_tests.TestHints):
+    loaded_fonts = FONTS
 
 
 if __name__ == '__main__':
     unittest.main()
-