src/third_party/skia/tests/FontHostTest.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "Resources.h"
   9 #include "SkEndian.h"
  10 #include "SkFontStream.h"
  11 #include "SkOSFile.h"
  12 #include "SkPaint.h"
  13 #include "SkStream.h"
  14 #include "SkTypeface.h"
  15 #include "Test.h"
  16
  17 //#define DUMP_TABLES
  18 //#define DUMP_TTC_TABLES
  19
  20 #define kFontTableTag_head          SkSetFourByteTag('h', 'e', 'a', 'd')
  21 #define kFontTableTag_hhea          SkSetFourByteTag('h', 'h', 'e', 'a')
  22 #define kFontTableTag_maxp          SkSetFourByteTag('m', 'a', 'x', 'p')
  23
  24 static const struct TagSize {
  25     SkFontTableTag  fTag;
  26     size_t          fSize;
  27 } gKnownTableSizes[] = {
  28     {   kFontTableTag_head,         54 },
  29     {   kFontTableTag_hhea,         36 },
  30 };
  31
  32 // Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
  33 // (if that table is available).
  34 static void test_unitsPerEm(skiatest::Reporter* reporter, SkTypeface* face) {
  35     int nativeUPEM = face->getUnitsPerEm();
  36
  37     int tableUPEM = -1;
  38     size_t size = face->getTableSize(kFontTableTag_head);
  39     if (size) {
  40         // unitsPerEm is at offset 18 into the 'head' table.
  41         uint16_t rawUPEM;
  42         face->getTableData(kFontTableTag_head, 18, sizeof(rawUPEM), &rawUPEM);
  43         tableUPEM = SkEndian_SwapBE16(rawUPEM);
  44     }
  45
  46     if (tableUPEM >= 0) {
  47         REPORTER_ASSERT(reporter, tableUPEM == nativeUPEM);
  48     }
  49 }
  50
  51 // Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
  52 // (if that table is available).
  53 static void test_countGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
  54     int nativeGlyphs = face->countGlyphs();
  55
  56     int tableGlyphs = -1;
  57     size_t size = face->getTableSize(kFontTableTag_maxp);
  58     if (size) {
  59         // glyphs is at offset 4 into the 'maxp' table.
  60         uint16_t rawGlyphs;
  61         face->getTableData(kFontTableTag_maxp, 4, sizeof(rawGlyphs), &rawGlyphs);
  62         tableGlyphs = SkEndian_SwapBE16(rawGlyphs);
  63     }
  64
  65     if (tableGlyphs >= 0) {
  66         REPORTER_ASSERT(reporter, tableGlyphs == nativeGlyphs);
  67     }
  68 }
  69
  70 // The following three are all the same code points in various encodings.
  71 // a中Яיו𝄞a𠮟
  72 static uint8_t utf8Chars[] = { 0x61, 0xE4,0xB8,0xAD, 0xD0,0xAF, 0xD7,0x99, 0xD7,0x95, 0xF0,0x9D,0x84,0x9E, 0x61, 0xF0,0xA0,0xAE,0x9F };
  73 static uint16_t utf16Chars[] = { 0x0061, 0x4E2D, 0x042F, 0x05D9, 0x05D5, 0xD834,0xDD1E, 0x0061, 0xD842,0xDF9F };
  74 static uint32_t utf32Chars[] = { 0x00000061, 0x00004E2D, 0x0000042F, 0x000005D9, 0x000005D5, 0x0001D11E, 0x00000061, 0x00020B9F };
  75
  76 struct CharsToGlyphs_TestData {
  77     const void* chars;
  78     int charCount;
  79     size_t charsByteLength;
  80     SkTypeface::Encoding typefaceEncoding;
  81     const char* name;
  82 } static charsToGlyphs_TestData[] = {
  83     { utf8Chars, 8, sizeof(utf8Chars), SkTypeface::kUTF8_Encoding, "Simple UTF-8" },
  84     { utf16Chars, 8, sizeof(utf16Chars), SkTypeface::kUTF16_Encoding, "Simple UTF-16" },
  85     { utf32Chars, 8, sizeof(utf32Chars), SkTypeface::kUTF32_Encoding, "Simple UTF-32" },
  86 };
  87
  88 // Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
  89 static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
  90     uint16_t paintGlyphIds[256];
  91     uint16_t faceGlyphIds[256];
  92
  93     for (size_t testIndex = 0; testIndex < SK_ARRAY_COUNT(charsToGlyphs_TestData); ++testIndex) {
  94         CharsToGlyphs_TestData& test = charsToGlyphs_TestData[testIndex];
  95
  96         SkPaint paint;
  97         paint.setTypeface(face);
  98         paint.setTextEncoding((SkPaint::TextEncoding)test.typefaceEncoding);
  99         paint.textToGlyphs(test.chars, test.charsByteLength, paintGlyphIds);
 100
 101         face->charsToGlyphs(test.chars, test.typefaceEncoding, faceGlyphIds, test.charCount);
 102
 103         for (int i = 0; i < test.charCount; ++i) {
 104             SkString name;
 105             face->getFamilyName(&name);
 106             SkString a;
 107             a.appendf("%s, paintGlyphIds[%d] = %d, faceGlyphIds[%d] = %d, face = %s",
 108                       test.name, i, (int)paintGlyphIds[i], i, (int)faceGlyphIds[i], name.c_str());
 109             REPORTER_ASSERT_MESSAGE(reporter, paintGlyphIds[i] == faceGlyphIds[i], a.c_str());
 110         }
 111     }
 112 }
 113
 114 static void test_fontstream(skiatest::Reporter* reporter,
 115                             SkStream* stream, int ttcIndex) {
 116     int n = SkFontStream::GetTableTags(stream, ttcIndex, NULL);
 117     SkAutoTArray<SkFontTableTag> array(n);
 118
 119     int n2 = SkFontStream::GetTableTags(stream, ttcIndex, array.get());
 120     REPORTER_ASSERT(reporter, n == n2);
 121
 122     for (int i = 0; i < n; ++i) {
 123 #ifdef DUMP_TTC_TABLES
 124         SkString str;
 125         SkFontTableTag t = array[i];
 126         str.appendUnichar((t >> 24) & 0xFF);
 127         str.appendUnichar((t >> 16) & 0xFF);
 128         str.appendUnichar((t >>  8) & 0xFF);
 129         str.appendUnichar((t >>  0) & 0xFF);
 130         SkDebugf("[%d:%d] '%s'\n", ttcIndex, i, str.c_str());
 131 #endif
 132         size_t size = SkFontStream::GetTableSize(stream, ttcIndex, array[i]);
 133         for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
 134             if (gKnownTableSizes[j].fTag == array[i]) {
 135                 REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
 136             }
 137         }
 138     }
 139 }
 140
 141 static void test_fontstream(skiatest::Reporter* reporter, SkStream* stream) {
 142     int count = SkFontStream::CountTTCEntries(stream);
 143 #ifdef DUMP_TTC_TABLES
 144     SkDebugf("CountTTCEntries %d\n", count);
 145 #endif
 146     for (int i = 0; i < count; ++i) {
 147         test_fontstream(reporter, stream, i);
 148     }
 149 }
 150
 151 static void test_fontstream(skiatest::Reporter* reporter) {
 152     // This test cannot run if there is no resource path.
 153     SkString resourcePath = GetResourcePath();
 154     if (resourcePath.isEmpty()) {
 155         SkDebugf("Could not run fontstream test because resourcePath not specified.");
 156         return;
 157     }
 158     SkString filename = SkOSPath::Join(resourcePath.c_str(), "test.ttc");
 159
 160     SkFILEStream stream(filename.c_str());
 161     if (stream.isValid()) {
 162         test_fontstream(reporter, &stream);
 163     } else {
 164         SkDebugf("Could not run fontstream test because test.ttc not found.");
 165     }
 166 }
 167
 168 static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
 169     if (false) { // avoid bit rot, suppress warning
 170         SkFontID fontID = face->uniqueID();
 171         REPORTER_ASSERT(reporter, fontID);
 172     }
 173
 174     int count = face->countTables();
 175
 176     SkAutoTMalloc<SkFontTableTag> storage(count);
 177     SkFontTableTag* tags = storage.get();
 178
 179     int count2 = face->getTableTags(tags);
 180     REPORTER_ASSERT(reporter, count2 == count);
 181
 182     for (int i = 0; i < count; ++i) {
 183         size_t size = face->getTableSize(tags[i]);
 184         REPORTER_ASSERT(reporter, size > 0);
 185
 186 #ifdef DUMP_TABLES
 187         char name[5];
 188         name[0] = (tags[i] >> 24) & 0xFF;
 189         name[1] = (tags[i] >> 16) & 0xFF;
 190         name[2] = (tags[i] >>  8) & 0xFF;
 191         name[3] = (tags[i] >>  0) & 0xFF;
 192         name[4] = 0;
 193         SkDebugf("%s %d\n", name, size);
 194 #endif
 195
 196         for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
 197             if (gKnownTableSizes[j].fTag == tags[i]) {
 198                 REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
 199             }
 200         }
 201
 202         // do we get the same size from GetTableData and GetTableSize
 203         {
 204             SkAutoMalloc data(size);
 205             size_t size2 = face->getTableData(tags[i], 0, size, data.get());
 206             REPORTER_ASSERT(reporter, size2 == size);
 207         }
 208     }
 209 }
 210
 211 static void test_tables(skiatest::Reporter* reporter) {
 212     static const char* const gNames[] = {
 213         NULL,   // default font
 214         "Helvetica", "Arial",
 215         "Times", "Times New Roman",
 216         "Courier", "Courier New",
 217         "Terminal", "MS Sans Serif",
 218         "Hiragino Mincho ProN", "MS PGothic",
 219     };
 220
 221     for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
 222         SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
 223         if (face) {
 224 #ifdef DUMP_TABLES
 225             SkDebugf("%s\n", gNames[i]);
 226 #endif
 227             test_tables(reporter, face);
 228             test_unitsPerEm(reporter, face);
 229             test_countGlyphs(reporter, face);
 230             test_charsToGlyphs(reporter, face);
 231         }
 232     }
 233 }
 234
 235 /*
 236  * Verifies that the advance values returned by generateAdvance and
 237  * generateMetrics match.
 238  */
 239 static void test_advances(skiatest::Reporter* reporter) {
 240     static const char* const faces[] = {
 241         NULL,   // default font
 242         "Arial", "Times", "Times New Roman", "Helvetica", "Courier",
 243         "Courier New", "Verdana", "monospace",
 244     };
 245
 246     static const struct {
 247         SkPaint::Hinting    hinting;
 248         unsigned            flags;
 249     } settings[] = {
 250         { SkPaint::kNo_Hinting,     0                               },
 251         { SkPaint::kNo_Hinting,     SkPaint::kLinearText_Flag       },
 252         { SkPaint::kNo_Hinting,     SkPaint::kSubpixelText_Flag     },
 253         { SkPaint::kSlight_Hinting, 0                               },
 254         { SkPaint::kSlight_Hinting, SkPaint::kLinearText_Flag       },
 255         { SkPaint::kSlight_Hinting, SkPaint::kSubpixelText_Flag     },
 256         { SkPaint::kNormal_Hinting, 0                               },
 257         { SkPaint::kNormal_Hinting, SkPaint::kLinearText_Flag       },
 258         { SkPaint::kNormal_Hinting, SkPaint::kSubpixelText_Flag     },
 259     };
 260
 261     static const struct {
 262         SkScalar    fScaleX;
 263         SkScalar    fSkewX;
 264     } gScaleRec[] = {
 265         { SK_Scalar1, 0 },
 266         { SK_Scalar1/2, 0 },
 267         // these two exercise obliquing (skew)
 268         { SK_Scalar1, -SK_Scalar1/4 },
 269         { SK_Scalar1/2, -SK_Scalar1/4 },
 270     };
 271
 272     SkPaint paint;
 273     char txt[] = "long.text.with.lots.of.dots.";
 274
 275     for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
 276         SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
 277         paint.setTypeface(face);
 278
 279         for (size_t j = 0; j  < SK_ARRAY_COUNT(settings); j++) {
 280             paint.setHinting(settings[j].hinting);
 281             paint.setLinearText((settings[j].flags & SkPaint::kLinearText_Flag) != 0);
 282             paint.setSubpixelText((settings[j].flags & SkPaint::kSubpixelText_Flag) != 0);
 283
 284             for (size_t k = 0; k < SK_ARRAY_COUNT(gScaleRec); ++k) {
 285                 paint.setTextScaleX(gScaleRec[k].fScaleX);
 286                 paint.setTextSkewX(gScaleRec[k].fSkewX);
 287
 288                 SkRect bounds;
 289
 290                 // For no hinting and light hinting this should take the
 291                 // optimized generateAdvance path.
 292                 SkScalar width1 = paint.measureText(txt, strlen(txt));
 293
 294                 // Requesting the bounds forces a generateMetrics call.
 295                 SkScalar width2 = paint.measureText(txt, strlen(txt), &bounds);
 296
 297                 // SkDebugf("Font: %s, generateAdvance: %f, generateMetrics: %f\n",
 298                 //    faces[i], SkScalarToFloat(width1), SkScalarToFloat(width2));
 299
 300                 REPORTER_ASSERT(reporter, width1 == width2);
 301             }
 302         }
 303     }
 304 }
 305
 306 DEF_TEST(FontHost, reporter) {
 307     test_tables(reporter);
 308     test_fontstream(reporter);
 309     test_advances(reporter);
 310 }
 311
 312 // need tests for SkStrSearch