7b09aab713
CTFontGetGlyphsForChars puts the glyph id at the index of the lead surrogate as is documented in comments, but the code is looking at the index of the trail surrogate. BUG=skia:2960 R=mtklein@google.com Author: bungeman@google.com Review URL: https://codereview.chromium.org/596413002
313 lines
11 KiB
C++
313 lines
11 KiB
C++
/*
|
||
* Copyright 2012 Google Inc.
|
||
*
|
||
* Use of this source code is governed by a BSD-style license that can be
|
||
* found in the LICENSE file.
|
||
*/
|
||
|
||
#include "Resources.h"
|
||
#include "SkEndian.h"
|
||
#include "SkFontStream.h"
|
||
#include "SkOSFile.h"
|
||
#include "SkPaint.h"
|
||
#include "SkStream.h"
|
||
#include "SkTypeface.h"
|
||
#include "Test.h"
|
||
|
||
//#define DUMP_TABLES
|
||
//#define DUMP_TTC_TABLES
|
||
|
||
#define kFontTableTag_head SkSetFourByteTag('h', 'e', 'a', 'd')
|
||
#define kFontTableTag_hhea SkSetFourByteTag('h', 'h', 'e', 'a')
|
||
#define kFontTableTag_maxp SkSetFourByteTag('m', 'a', 'x', 'p')
|
||
|
||
static const struct TagSize {
|
||
SkFontTableTag fTag;
|
||
size_t fSize;
|
||
} gKnownTableSizes[] = {
|
||
{ kFontTableTag_head, 54 },
|
||
{ kFontTableTag_hhea, 36 },
|
||
};
|
||
|
||
// Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
|
||
// (if that table is available).
|
||
static void test_unitsPerEm(skiatest::Reporter* reporter, SkTypeface* face) {
|
||
int nativeUPEM = face->getUnitsPerEm();
|
||
|
||
int tableUPEM = -1;
|
||
size_t size = face->getTableSize(kFontTableTag_head);
|
||
if (size) {
|
||
// unitsPerEm is at offset 18 into the 'head' table.
|
||
uint16_t rawUPEM;
|
||
face->getTableData(kFontTableTag_head, 18, sizeof(rawUPEM), &rawUPEM);
|
||
tableUPEM = SkEndian_SwapBE16(rawUPEM);
|
||
}
|
||
|
||
if (tableUPEM >= 0) {
|
||
REPORTER_ASSERT(reporter, tableUPEM == nativeUPEM);
|
||
}
|
||
}
|
||
|
||
// Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
|
||
// (if that table is available).
|
||
static void test_countGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
|
||
int nativeGlyphs = face->countGlyphs();
|
||
|
||
int tableGlyphs = -1;
|
||
size_t size = face->getTableSize(kFontTableTag_maxp);
|
||
if (size) {
|
||
// glyphs is at offset 4 into the 'maxp' table.
|
||
uint16_t rawGlyphs;
|
||
face->getTableData(kFontTableTag_maxp, 4, sizeof(rawGlyphs), &rawGlyphs);
|
||
tableGlyphs = SkEndian_SwapBE16(rawGlyphs);
|
||
}
|
||
|
||
if (tableGlyphs >= 0) {
|
||
REPORTER_ASSERT(reporter, tableGlyphs == nativeGlyphs);
|
||
}
|
||
}
|
||
|
||
// The following three are all the same code points in various encodings.
|
||
// a中Яיו𝄞a𠮟
|
||
static uint8_t utf8Chars[] = { 0x61, 0xE4,0xB8,0xAD, 0xD0,0xAF, 0xD7,0x99, 0xD7,0x95, 0xF0,0x9D,0x84,0x9E, 0x61, 0xF0,0xA0,0xAE,0x9F };
|
||
static uint16_t utf16Chars[] = { 0x0061, 0x4E2D, 0x042F, 0x05D9, 0x05D5, 0xD834,0xDD1E, 0x0061, 0xD842,0xDF9F };
|
||
static uint32_t utf32Chars[] = { 0x00000061, 0x00004E2D, 0x0000042F, 0x000005D9, 0x000005D5, 0x0001D11E, 0x00000061, 0x00020B9F };
|
||
|
||
struct CharsToGlyphs_TestData {
|
||
const void* chars;
|
||
int charCount;
|
||
size_t charsByteLength;
|
||
SkTypeface::Encoding typefaceEncoding;
|
||
const char* name;
|
||
} static charsToGlyphs_TestData[] = {
|
||
{ utf8Chars, 8, sizeof(utf8Chars), SkTypeface::kUTF8_Encoding, "Simple UTF-8" },
|
||
{ utf16Chars, 8, sizeof(utf16Chars), SkTypeface::kUTF16_Encoding, "Simple UTF-16" },
|
||
{ utf32Chars, 8, sizeof(utf32Chars), SkTypeface::kUTF32_Encoding, "Simple UTF-32" },
|
||
};
|
||
|
||
// Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
|
||
static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
|
||
uint16_t paintGlyphIds[256];
|
||
uint16_t faceGlyphIds[256];
|
||
|
||
for (size_t testIndex = 0; testIndex < SK_ARRAY_COUNT(charsToGlyphs_TestData); ++testIndex) {
|
||
CharsToGlyphs_TestData& test = charsToGlyphs_TestData[testIndex];
|
||
|
||
SkPaint paint;
|
||
paint.setTypeface(face);
|
||
paint.setTextEncoding((SkPaint::TextEncoding)test.typefaceEncoding);
|
||
paint.textToGlyphs(test.chars, test.charsByteLength, paintGlyphIds);
|
||
|
||
face->charsToGlyphs(test.chars, test.typefaceEncoding, faceGlyphIds, test.charCount);
|
||
|
||
for (int i = 0; i < test.charCount; ++i) {
|
||
SkString name;
|
||
face->getFamilyName(&name);
|
||
SkString a;
|
||
a.appendf("%s, paintGlyphIds[%d] = %d, faceGlyphIds[%d] = %d, face = %s",
|
||
test.name, i, (int)paintGlyphIds[i], i, (int)faceGlyphIds[i], name.c_str());
|
||
REPORTER_ASSERT_MESSAGE(reporter, paintGlyphIds[i] == faceGlyphIds[i], a.c_str());
|
||
}
|
||
}
|
||
}
|
||
|
||
static void test_fontstream(skiatest::Reporter* reporter,
|
||
SkStream* stream, int ttcIndex) {
|
||
int n = SkFontStream::GetTableTags(stream, ttcIndex, NULL);
|
||
SkAutoTArray<SkFontTableTag> array(n);
|
||
|
||
int n2 = SkFontStream::GetTableTags(stream, ttcIndex, array.get());
|
||
REPORTER_ASSERT(reporter, n == n2);
|
||
|
||
for (int i = 0; i < n; ++i) {
|
||
#ifdef DUMP_TTC_TABLES
|
||
SkString str;
|
||
SkFontTableTag t = array[i];
|
||
str.appendUnichar((t >> 24) & 0xFF);
|
||
str.appendUnichar((t >> 16) & 0xFF);
|
||
str.appendUnichar((t >> 8) & 0xFF);
|
||
str.appendUnichar((t >> 0) & 0xFF);
|
||
SkDebugf("[%d:%d] '%s'\n", ttcIndex, i, str.c_str());
|
||
#endif
|
||
size_t size = SkFontStream::GetTableSize(stream, ttcIndex, array[i]);
|
||
for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
|
||
if (gKnownTableSizes[j].fTag == array[i]) {
|
||
REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void test_fontstream(skiatest::Reporter* reporter, SkStream* stream) {
|
||
int count = SkFontStream::CountTTCEntries(stream);
|
||
#ifdef DUMP_TTC_TABLES
|
||
SkDebugf("CountTTCEntries %d\n", count);
|
||
#endif
|
||
for (int i = 0; i < count; ++i) {
|
||
test_fontstream(reporter, stream, i);
|
||
}
|
||
}
|
||
|
||
static void test_fontstream(skiatest::Reporter* reporter) {
|
||
// This test cannot run if there is no resource path.
|
||
SkString resourcePath = GetResourcePath();
|
||
if (resourcePath.isEmpty()) {
|
||
SkDebugf("Could not run fontstream test because resourcePath not specified.");
|
||
return;
|
||
}
|
||
SkString filename = SkOSPath::Join(resourcePath.c_str(), "test.ttc");
|
||
|
||
SkFILEStream stream(filename.c_str());
|
||
if (stream.isValid()) {
|
||
test_fontstream(reporter, &stream);
|
||
} else {
|
||
SkDebugf("Could not run fontstream test because test.ttc not found.");
|
||
}
|
||
}
|
||
|
||
static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
|
||
if (false) { // avoid bit rot, suppress warning
|
||
SkFontID fontID = face->uniqueID();
|
||
REPORTER_ASSERT(reporter, fontID);
|
||
}
|
||
|
||
int count = face->countTables();
|
||
|
||
SkAutoTMalloc<SkFontTableTag> storage(count);
|
||
SkFontTableTag* tags = storage.get();
|
||
|
||
int count2 = face->getTableTags(tags);
|
||
REPORTER_ASSERT(reporter, count2 == count);
|
||
|
||
for (int i = 0; i < count; ++i) {
|
||
size_t size = face->getTableSize(tags[i]);
|
||
REPORTER_ASSERT(reporter, size > 0);
|
||
|
||
#ifdef DUMP_TABLES
|
||
char name[5];
|
||
name[0] = (tags[i] >> 24) & 0xFF;
|
||
name[1] = (tags[i] >> 16) & 0xFF;
|
||
name[2] = (tags[i] >> 8) & 0xFF;
|
||
name[3] = (tags[i] >> 0) & 0xFF;
|
||
name[4] = 0;
|
||
SkDebugf("%s %d\n", name, size);
|
||
#endif
|
||
|
||
for (size_t j = 0; j < SK_ARRAY_COUNT(gKnownTableSizes); ++j) {
|
||
if (gKnownTableSizes[j].fTag == tags[i]) {
|
||
REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
|
||
}
|
||
}
|
||
|
||
// do we get the same size from GetTableData and GetTableSize
|
||
{
|
||
SkAutoMalloc data(size);
|
||
size_t size2 = face->getTableData(tags[i], 0, size, data.get());
|
||
REPORTER_ASSERT(reporter, size2 == size);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void test_tables(skiatest::Reporter* reporter) {
|
||
static const char* const gNames[] = {
|
||
NULL, // default font
|
||
"Helvetica", "Arial",
|
||
"Times", "Times New Roman",
|
||
"Courier", "Courier New",
|
||
"Terminal", "MS Sans Serif",
|
||
"Hiragino Mincho ProN", "MS PGothic",
|
||
};
|
||
|
||
for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
|
||
SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
|
||
if (face) {
|
||
#ifdef DUMP_TABLES
|
||
SkDebugf("%s\n", gNames[i]);
|
||
#endif
|
||
test_tables(reporter, face);
|
||
test_unitsPerEm(reporter, face);
|
||
test_countGlyphs(reporter, face);
|
||
test_charsToGlyphs(reporter, face);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Verifies that the advance values returned by generateAdvance and
|
||
* generateMetrics match.
|
||
*/
|
||
static void test_advances(skiatest::Reporter* reporter) {
|
||
static const char* const faces[] = {
|
||
NULL, // default font
|
||
"Arial", "Times", "Times New Roman", "Helvetica", "Courier",
|
||
"Courier New", "Verdana", "monospace",
|
||
};
|
||
|
||
static const struct {
|
||
SkPaint::Hinting hinting;
|
||
unsigned flags;
|
||
} settings[] = {
|
||
{ SkPaint::kNo_Hinting, 0 },
|
||
{ SkPaint::kNo_Hinting, SkPaint::kLinearText_Flag },
|
||
{ SkPaint::kNo_Hinting, SkPaint::kSubpixelText_Flag },
|
||
{ SkPaint::kSlight_Hinting, 0 },
|
||
{ SkPaint::kSlight_Hinting, SkPaint::kLinearText_Flag },
|
||
{ SkPaint::kSlight_Hinting, SkPaint::kSubpixelText_Flag },
|
||
{ SkPaint::kNormal_Hinting, 0 },
|
||
{ SkPaint::kNormal_Hinting, SkPaint::kLinearText_Flag },
|
||
{ SkPaint::kNormal_Hinting, SkPaint::kSubpixelText_Flag },
|
||
};
|
||
|
||
static const struct {
|
||
SkScalar fScaleX;
|
||
SkScalar fSkewX;
|
||
} gScaleRec[] = {
|
||
{ SK_Scalar1, 0 },
|
||
{ SK_Scalar1/2, 0 },
|
||
// these two exercise obliquing (skew)
|
||
{ SK_Scalar1, -SK_Scalar1/4 },
|
||
{ SK_Scalar1/2, -SK_Scalar1/4 },
|
||
};
|
||
|
||
SkPaint paint;
|
||
char txt[] = "long.text.with.lots.of.dots.";
|
||
|
||
for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
|
||
SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
|
||
paint.setTypeface(face);
|
||
|
||
for (size_t j = 0; j < SK_ARRAY_COUNT(settings); j++) {
|
||
paint.setHinting(settings[j].hinting);
|
||
paint.setLinearText((settings[j].flags & SkPaint::kLinearText_Flag) != 0);
|
||
paint.setSubpixelText((settings[j].flags & SkPaint::kSubpixelText_Flag) != 0);
|
||
|
||
for (size_t k = 0; k < SK_ARRAY_COUNT(gScaleRec); ++k) {
|
||
paint.setTextScaleX(gScaleRec[k].fScaleX);
|
||
paint.setTextSkewX(gScaleRec[k].fSkewX);
|
||
|
||
SkRect bounds;
|
||
|
||
// For no hinting and light hinting this should take the
|
||
// optimized generateAdvance path.
|
||
SkScalar width1 = paint.measureText(txt, strlen(txt));
|
||
|
||
// Requesting the bounds forces a generateMetrics call.
|
||
SkScalar width2 = paint.measureText(txt, strlen(txt), &bounds);
|
||
|
||
// SkDebugf("Font: %s, generateAdvance: %f, generateMetrics: %f\n",
|
||
// faces[i], SkScalarToFloat(width1), SkScalarToFloat(width2));
|
||
|
||
REPORTER_ASSERT(reporter, width1 == width2);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
DEF_TEST(FontHost, reporter) {
|
||
test_tables(reporter);
|
||
test_fontstream(reporter);
|
||
test_advances(reporter);
|
||
}
|
||
|
||
// need tests for SkStrSearch
|