TextBlobTest.cpp File Reference

#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTextBlob.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkFontPriv.h"
#include "src/core/SkTextBlobPriv.h"
#include "tests/Test.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <string>

Go to the source code of this file.

Classes
class	TextBlobTester

Functions
	DEF_TEST (TextBlob_builder, reporter)
	DEF_TEST (TextBlob_paint, reporter)
	DEF_TEST (TextBlob_extended, reporter)
static void	add_run (SkTextBlobBuilder *builder, const char text[], SkScalar x, SkScalar y, sk_sp< SkTypeface > tf)
static sk_sp< SkImage >	render (const SkTextBlob *blob)
static sk_sp< SkData >	SerializeTypeface (SkTypeface *tf, void *ctx)
static sk_sp< SkTypeface >	DeserializeTypeface (const void *data, size_t length, void *ctx)
	DEF_TEST (TextBlob_serialize, reporter)
	DEF_TEST (TextBlob_MakeAsDrawText, reporter)
	DEF_TEST (TextBlob_iter, reporter)
	DEF_TEST (TextBlob_getIntercepts, reporter)

Function Documentation

add_run()

static void add_run ( SkTextBlobBuilder *  builder, const char  text[], SkScalar  x, SkScalar  y, sk_sp< SkTypeface >  tf  )

static

Definition at line 370 of file TextBlobTest.cpp.

                                          {
    SkFont font;
    font.setEdging(SkFont::Edging::kAntiAlias);
    font.setSubpixel(true);
    font.setSize(16);
    font.setTypeface(tf);
 
    int glyphCount = font.countText(text, strlen(text), SkTextEncoding::kUTF8);
 
    SkTextBlobBuilder::RunBuffer buffer = builder->allocRun(font, glyphCount, x, y);
 
    (void)font.textToGlyphs(text, strlen(text), SkTextEncoding::kUTF8, buffer.glyphs, glyphCount);
}

DEF_TEST() [1/7]

DEF_TEST	(	TextBlob_builder	,
		reporter
	)

Definition at line 325 of file TextBlobTest.cpp.

                                     {
    TextBlobTester::TestBuilder(reporter);
    TextBlobTester::TestBounds(reporter);
}

DEF_TEST() [2/7]

DEF_TEST	(	TextBlob_extended	,
		reporter
	)

Definition at line 334 of file TextBlobTest.cpp.

                                      {
    SkTextBlobBuilder textBlobBuilder;
    SkFont font = ToolUtils::DefaultFont();
    const char text1[] = "Foo";
    const char text2[] = "Bar";
 
    int glyphCount = font.countText(text1, strlen(text1), SkTextEncoding::kUTF8);
    AutoTMalloc<uint16_t> glyphs(glyphCount);
    (void)font.textToGlyphs(text1, strlen(text1), SkTextEncoding::kUTF8, glyphs.get(), glyphCount);
 
    auto run = textBlobBuilder.allocRunText(font, glyphCount, 0, 0, SkToInt(strlen(text2)));
    memcpy(run.glyphs, glyphs.get(), sizeof(uint16_t) * glyphCount);
    memcpy(run.utf8text, text2, strlen(text2));
    for (int i = 0; i < glyphCount; ++i) {
        run.clusters[i] = std::min(SkToU32(i), SkToU32(strlen(text2)));
    }
    sk_sp<SkTextBlob> blob(textBlobBuilder.make());
    REPORTER_ASSERT(reporter, blob);
 
    for (SkTextBlobRunIterator it(blob.get()); !it.done(); it.next()) {
        REPORTER_ASSERT(reporter, it.glyphCount() == (uint32_t)glyphCount);
        for (uint32_t i = 0; i < it.glyphCount(); ++i) {
            REPORTER_ASSERT(reporter, it.glyphs()[i] == glyphs[i]);
        }
        REPORTER_ASSERT(reporter, SkTextBlobRunIterator::kDefault_Positioning == it.positioning());
        REPORTER_ASSERT(reporter, (SkPoint{0.0f, 0.0f}) == it.offset());
        REPORTER_ASSERT(reporter, it.textSize() > 0);
        REPORTER_ASSERT(reporter, it.clusters());
        for (uint32_t i = 0; i < it.glyphCount(); ++i) {
            REPORTER_ASSERT(reporter, i == it.clusters()[i]);
        }
        REPORTER_ASSERT(reporter, 0 == strncmp(text2, it.text(), it.textSize()));
    }
}

DEF_TEST() [3/7]

DEF_TEST	(	TextBlob_getIntercepts	,
		reporter
	)

Definition at line 513 of file TextBlobTest.cpp.

                                           {
    SkFont font = ToolUtils::DefaultFont();
    font.setSize(16);
 
    SkPoint lowPos[1] = { SkPoint::Make(0, 5) };
    SkPoint highPos[1] = { SkPoint::Make(0, -8) };
    SkPoint zeroPos[1] = { SkPoint::Make(0, 0) };
 
    // 'x' sitting on baseline
    auto blobZeroX = SkTextBlob::MakeFromPosText("x", 1, zeroPos, font);
    // 'x' lowered to intersect baseline
    auto blobLowX = SkTextBlob::MakeFromPosText("x", 1, lowPos, font);
    // 'y' sitting on baseline
    auto blobZeroY = SkTextBlob::MakeFromPosText("y", 1, zeroPos, font);
    // 'y' raised to not intersect baseline
    auto blobHighY = SkTextBlob::MakeFromPosText("y", 1, highPos, font);
 
    // bounds right below baseline
    SkScalar bounds[2] = { 1, 2 };
 
    // 'x' on baseline should not intersect
    REPORTER_ASSERT(reporter, blobZeroX->getIntercepts(bounds, nullptr) == 0);
    // lowered 'x' should intersect
    REPORTER_ASSERT(reporter, blobLowX->getIntercepts(bounds, nullptr) == 2);
    // 'y' on baseline should intersect
    REPORTER_ASSERT(reporter, blobZeroY->getIntercepts(bounds, nullptr) == 2);
    // raised 'y' should not intersect
    REPORTER_ASSERT(reporter, blobHighY->getIntercepts(bounds, nullptr) == 0);
}

DEF_TEST() [4/7]

DEF_TEST	(	TextBlob_iter	,
		reporter
	)

Definition at line 481 of file TextBlobTest.cpp.

                                  {
    sk_sp<SkTypeface> tf = ToolUtils::CreateTestTypeface(nullptr, SkFontStyle::BoldItalic());
 
    SkTextBlobBuilder builder;
    add_run(&builder, "Hello", 10, 20, tf);
    add_run(&builder, "World!", 10, 40, tf);
    auto blob = builder.make();
 
    SkTextBlob::Iter::Run expected[] = {
        { tf.get(), 5, nullptr },
        { tf.get(), 6, nullptr },
    };
 
    SkTextBlob::Iter iter(*blob);
    SkTextBlob::Iter::Run run;
    for (auto exp : expected) {
        REPORTER_ASSERT(reporter, iter.next(&run));
        REPORTER_ASSERT(reporter, run.fTypeface == exp.fTypeface);
        REPORTER_ASSERT(reporter, run.fGlyphCount == exp.fGlyphCount);
        for (int i = 0; i < run.fGlyphCount; ++i) {
            REPORTER_ASSERT(reporter, run.fGlyphIndices[i] != 0,
                            "Glyph Index %d is unexpectedly 0", i);
        }
    }
    REPORTER_ASSERT(reporter, !iter.next(&run));    // we're done
 
    SkTextBlob::Iter iter2(*blob);
    REPORTER_ASSERT(reporter, iter2.next(&run));
    // Hello should have the same glyph repeated for the 'l'
    REPORTER_ASSERT(reporter, run.fGlyphIndices[2] == run.fGlyphIndices[3]);
}

DEF_TEST() [5/7]

DEF_TEST	(	TextBlob_MakeAsDrawText	,
		reporter
	)

Definition at line 467 of file TextBlobTest.cpp.

                                            {
    const char text[] = "Hello";
    auto blob = SkTextBlob::MakeFromString(text, ToolUtils::DefaultFont(), SkTextEncoding::kUTF8);
 
    int runs = 0;
    for(SkTextBlobRunIterator it(blob.get()); !it.done(); it.next()) {
        REPORTER_ASSERT(reporter, it.glyphCount() == strlen(text));
        REPORTER_ASSERT(reporter, it.positioning() == SkTextBlobRunIterator::kFull_Positioning);
        runs += 1;
    }
    REPORTER_ASSERT(reporter, runs == 1);
 
}

DEF_TEST() [6/7]

DEF_TEST	(	TextBlob_paint	,
		reporter
	)

Definition at line 330 of file TextBlobTest.cpp.

                                   {
    TextBlobTester::TestPaintProps(reporter);
}

DEF_TEST() [7/7]

DEF_TEST	(	TextBlob_serialize	,
		reporter
	)

Definition at line 434 of file TextBlobTest.cpp.

                                       {
    sk_sp<SkTextBlob> blob0 = [reporter]() {
        sk_sp<SkTypeface> tf = ToolUtils::CreateTestTypeface(nullptr, SkFontStyle::BoldItalic());
        REPORTER_ASSERT(reporter, tf, "Test typeface was nullptr");
        REPORTER_ASSERT(reporter, tf->countGlyphs() > 0, "Test typeface had no glyphs");
 
        SkTextBlobBuilder builder;
        add_run(&builder, "Hello", 10, 20, nullptr);    // don't flatten a typeface
        add_run(&builder, "World", 10, 40, tf);         // do flatten this typeface
        return builder.make();
    }();
 
    TArray<sk_sp<SkTypeface>> array;
    SkSerialProcs serializeProcs;
    serializeProcs.fTypefaceProc = &SerializeTypeface;
    serializeProcs.fTypefaceCtx = (void*) &array;
    sk_sp<SkData> data = blob0->serialize(serializeProcs);
    REPORTER_ASSERT(reporter, array.size() == 1,
        "Did not serialize exactly one non-empty font, instead %d", array.size());
    REPORTER_ASSERT(reporter, array[0]->countGlyphs() > 0, "Serialized typeface had no glyphs");
    SkDeserialProcs deserializeProcs;
    deserializeProcs.fTypefaceProc = &DeserializeTypeface;
    deserializeProcs.fTypefaceCtx = (void*) &array;
    sk_sp<SkTextBlob> blob1 = SkTextBlob::Deserialize(data->data(), data->size(), deserializeProcs);
    REPORTER_ASSERT(reporter, blob1);
 
    sk_sp<SkImage> img0 = render(blob0.get());
    sk_sp<SkImage> img1 = render(blob1.get());
    if (img0 && img1) {
        REPORTER_ASSERT(reporter, ToolUtils::equal_pixels(img0.get(), img1.get()));
    }
}

DeserializeTypeface()

static sk_sp< SkTypeface > DeserializeTypeface ( const void *  data, size_t  length, void *  ctx  )

static

Definition at line 410 of file TextBlobTest.cpp.

                                                                                         {
    auto array = (TArray<sk_sp<SkTypeface>>*)ctx;
    if (length != sizeof(size_t)) {
        SkDEBUGFAIL("Did not serialize an index");
        return nullptr;
    }
    if (!data) {
        return nullptr;
    }
    size_t idx = 0;
    std::memcpy(&idx, data, sizeof(size_t));
    if (idx >= SkToSizeT(array->size())) {
        SkDEBUGFAIL("Index too big");
        return nullptr;
    }
    return (*array)[idx];
}

render()

static sk_sp< SkImage > render ( const SkTextBlob *  blob )

static

Definition at line 385 of file TextBlobTest.cpp.

                                                     {
    SkASSERT(blob);
    auto surf = SkSurfaces::Raster(
            SkImageInfo::MakeN32Premul(SkScalarRoundToInt(blob->bounds().width()),
                                       SkScalarRoundToInt(blob->bounds().height())));
    if (!surf) {
        return nullptr; // bounds are empty?
    }
    surf->getCanvas()->clear(SK_ColorWHITE);
    surf->getCanvas()->drawTextBlob(blob, -blob->bounds().left(), -blob->bounds().top(), SkPaint());
    return surf->makeImageSnapshot();
}

SerializeTypeface()

static sk_sp< SkData > SerializeTypeface ( SkTypeface *  tf, void *  ctx  )

static

Definition at line 398 of file TextBlobTest.cpp.

                                                                  {
    // Do not serialize the empty font.
    if (!tf || (tf->countGlyphs() == 0 && tf->getBounds().isEmpty())) {
        return nullptr;
    }
    auto array = (TArray<sk_sp<SkTypeface>>*)ctx;
    const size_t idx = array->size();
    array->emplace_back(sk_ref_sp(tf));
    // In this test, we are deserializing on the same machine, so we don't worry about endianness.
    return SkData::MakeWithCopy(&idx, sizeof(idx));
}