1 /*
2 * Copyright 2014 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 "include/core/SkCanvas.h"
9 #include "include/core/SkColor.h"
10 #include "include/core/SkData.h"
11 #include "include/core/SkFont.h"
12 #include "include/core/SkFontStyle.h"
13 #include "include/core/SkFontTypes.h"
14 #include "include/core/SkImage.h"
15 #include "include/core/SkPaint.h"
16 #include "include/core/SkPoint.h"
17 #include "include/core/SkRect.h"
18 #include "include/core/SkRefCnt.h"
19 #include "include/core/SkScalar.h"
20 #include "include/core/SkSerialProcs.h"
21 #include "include/core/SkSurface.h"
22 #include "include/core/SkTextBlob.h"
23 #include "include/core/SkTypeface.h"
24 #include "include/core/SkTypes.h"
25 #include "include/private/base/SkTArray.h"
26 #include "include/private/base/SkTemplates.h"
27 #include "include/private/base/SkTo.h"
28 #include "src/core/SkTextBlobPriv.h"
29 #include "tests/Test.h"
30 #include "tools/ToolUtils.h"
31
32 #include <algorithm>
33 #include <cstdint>
34 #include <cstring>
35 #include <string>
36
37 using namespace skia_private;
38
39 class TextBlobTester {
40 public:
41 // This unit test feeds an SkTextBlobBuilder various runs then checks to see if
42 // the result contains the provided data and merges runs when appropriate.
TestBuilder(skiatest::Reporter * reporter)43 static void TestBuilder(skiatest::Reporter* reporter) {
44 SkTextBlobBuilder builder;
45
46 // empty run set
47 RunBuilderTest(reporter, builder, nullptr, 0, nullptr, 0);
48
49 RunDef set1[] = {
50 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 100 },
51 };
52 RunBuilderTest(reporter, builder, set1, std::size(set1), set1, std::size(set1));
53
54 RunDef set2[] = {
55 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 100, 100 },
56 };
57 RunBuilderTest(reporter, builder, set2, std::size(set2), set2, std::size(set2));
58
59 RunDef set3[] = {
60 { 128, SkTextBlobRunIterator::kFull_Positioning, 100, 100 },
61 };
62 RunBuilderTest(reporter, builder, set3, std::size(set3), set3, std::size(set3));
63
64 RunDef set4[] = {
65 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
66 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
67 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
68 };
69 RunBuilderTest(reporter, builder, set4, std::size(set4), set4, std::size(set4));
70
71 RunDef set5[] = {
72 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 100, 150 },
73 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 200, 150 },
74 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 300, 250 },
75 };
76 RunDef mergedSet5[] = {
77 { 256, SkTextBlobRunIterator::kHorizontal_Positioning, 0, 150 },
78 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 0, 250 },
79 };
80 RunBuilderTest(reporter, builder, set5, std::size(set5), mergedSet5,
81 std::size(mergedSet5));
82
83 RunDef set6[] = {
84 { 128, SkTextBlobRunIterator::kFull_Positioning, 100, 100 },
85 { 128, SkTextBlobRunIterator::kFull_Positioning, 200, 200 },
86 { 128, SkTextBlobRunIterator::kFull_Positioning, 300, 300 },
87 };
88 RunDef mergedSet6[] = {
89 { 384, SkTextBlobRunIterator::kFull_Positioning, 0, 0 },
90 };
91 RunBuilderTest(reporter, builder, set6, std::size(set6), mergedSet6,
92 std::size(mergedSet6));
93
94 RunDef set7[] = {
95 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
96 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
97 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 100, 150 },
98 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 200, 150 },
99 { 128, SkTextBlobRunIterator::kFull_Positioning, 400, 350 },
100 { 128, SkTextBlobRunIterator::kFull_Positioning, 400, 350 },
101 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 450 },
102 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 450 },
103 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 100, 550 },
104 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 200, 650 },
105 { 128, SkTextBlobRunIterator::kFull_Positioning, 400, 750 },
106 { 128, SkTextBlobRunIterator::kFull_Positioning, 400, 850 },
107 };
108 RunDef mergedSet7[] = {
109 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
110 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 150 },
111 { 256, SkTextBlobRunIterator::kHorizontal_Positioning, 0, 150 },
112 { 256, SkTextBlobRunIterator::kFull_Positioning, 0, 0 },
113 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 450 },
114 { 128, SkTextBlobRunIterator::kDefault_Positioning, 100, 450 },
115 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 0, 550 },
116 { 128, SkTextBlobRunIterator::kHorizontal_Positioning, 0, 650 },
117 { 256, SkTextBlobRunIterator::kFull_Positioning, 0, 0 },
118 };
119 RunBuilderTest(reporter, builder, set7, std::size(set7), mergedSet7,
120 std::size(mergedSet7));
121 }
122
123 // This unit test verifies blob bounds computation.
TestBounds(skiatest::Reporter * reporter)124 static void TestBounds(skiatest::Reporter* reporter) {
125 SkTextBlobBuilder builder;
126 SkFont font;
127
128 // Explicit bounds.
129 {
130 sk_sp<SkTextBlob> blob(builder.make());
131 REPORTER_ASSERT(reporter, !blob);
132 }
133
134 {
135 SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
136 builder.allocRun(font, 16, 0, 0, &r1);
137 sk_sp<SkTextBlob> blob(builder.make());
138 REPORTER_ASSERT(reporter, blob->bounds() == r1);
139 }
140
141 {
142 SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
143 builder.allocRunPosH(font, 16, 0, &r1);
144 sk_sp<SkTextBlob> blob(builder.make());
145 REPORTER_ASSERT(reporter, blob->bounds() == r1);
146 }
147
148 {
149 SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
150 builder.allocRunPos(font, 16, &r1);
151 sk_sp<SkTextBlob> blob(builder.make());
152 REPORTER_ASSERT(reporter, blob->bounds() == r1);
153 }
154
155 {
156 SkRect r1 = SkRect::MakeXYWH(10, 10, 20, 20);
157 SkRect r2 = SkRect::MakeXYWH(15, 20, 50, 50);
158 SkRect r3 = SkRect::MakeXYWH(0, 5, 10, 5);
159
160 builder.allocRun(font, 16, 0, 0, &r1);
161 builder.allocRunPosH(font, 16, 0, &r2);
162 builder.allocRunPos(font, 16, &r3);
163
164 sk_sp<SkTextBlob> blob(builder.make());
165 REPORTER_ASSERT(reporter, blob->bounds() == SkRect::MakeXYWH(0, 5, 65, 65));
166 }
167
168 {
169 sk_sp<SkTextBlob> blob(builder.make());
170 REPORTER_ASSERT(reporter, !blob);
171 }
172
173 // Implicit bounds
174
175 {
176 // Exercise the empty bounds path, and ensure that RunRecord-aligned pos buffers
177 // don't trigger asserts (http://crbug.com/542643).
178 font.setSize(0);
179
180 const char* txt = "BOOO";
181 const size_t txtLen = strlen(txt);
182 const int glyphCount = font.countText(txt, txtLen, SkTextEncoding::kUTF8);
183 const SkTextBlobBuilder::RunBuffer& buffer = builder.allocRunPos(font, glyphCount);
184
185 font.textToGlyphs(txt, txtLen, SkTextEncoding::kUTF8, buffer.glyphs, glyphCount);
186
187 memset(buffer.pos, 0, sizeof(SkScalar) * glyphCount * 2);
188 sk_sp<SkTextBlob> blob(builder.make());
189 REPORTER_ASSERT(reporter, blob->bounds().isEmpty());
190 }
191 }
192
193 // Verify that text-related properties are captured in run paints.
TestPaintProps(skiatest::Reporter * reporter)194 static void TestPaintProps(skiatest::Reporter* reporter) {
195 SkFont font;
196 // Kitchen sink font.
197 font.setSize(42);
198 font.setScaleX(4.2f);
199 font.setTypeface(ToolUtils::create_portable_typeface(nullptr, SkFontStyle::Bold()));
200 font.setSkewX(0.42f);
201 font.setHinting(SkFontHinting::kFull);
202 font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
203 font.setEmbolden(true);
204 font.setLinearMetrics(true);
205 font.setSubpixel(true);
206 font.setEmbeddedBitmaps(true);
207 font.setForceAutoHinting(true);
208
209 // Ensure we didn't pick default values by mistake.
210 SkFont defaultFont;
211 REPORTER_ASSERT(reporter, defaultFont.getSize() != font.getSize());
212 REPORTER_ASSERT(reporter, defaultFont.getScaleX() != font.getScaleX());
213 REPORTER_ASSERT(reporter, defaultFont.getTypefaceOrDefault() != font.getTypefaceOrDefault());
214 REPORTER_ASSERT(reporter, defaultFont.getSkewX() != font.getSkewX());
215 REPORTER_ASSERT(reporter, defaultFont.getHinting() != font.getHinting());
216 REPORTER_ASSERT(reporter, defaultFont.getEdging() != font.getEdging());
217 REPORTER_ASSERT(reporter, defaultFont.isEmbolden() != font.isEmbolden());
218 REPORTER_ASSERT(reporter, defaultFont.isLinearMetrics() != font.isLinearMetrics());
219 REPORTER_ASSERT(reporter, defaultFont.isSubpixel() != font.isSubpixel());
220 REPORTER_ASSERT(reporter,
221 defaultFont.isEmbeddedBitmaps() != font.isEmbeddedBitmaps());
222 REPORTER_ASSERT(reporter, defaultFont.isForceAutoHinting() != font.isForceAutoHinting());
223
224 SkTextBlobBuilder builder;
225 AddRun(font, 1, SkTextBlobRunIterator::kDefault_Positioning, SkPoint::Make(0, 0), builder);
226 AddRun(font, 1, SkTextBlobRunIterator::kHorizontal_Positioning, SkPoint::Make(0, 0),
227 builder);
228 AddRun(font, 1, SkTextBlobRunIterator::kFull_Positioning, SkPoint::Make(0, 0), builder);
229 sk_sp<SkTextBlob> blob(builder.make());
230
231 SkTextBlobRunIterator it(blob.get());
232 while (!it.done()) {
233 REPORTER_ASSERT(reporter, it.font() == font);
234 it.next();
235 }
236
237 }
238
239 private:
240 struct RunDef {
241 unsigned count;
242 SkTextBlobRunIterator::GlyphPositioning pos;
243 SkScalar x, y;
244 };
245
RunBuilderTest(skiatest::Reporter * reporter,SkTextBlobBuilder & builder,const RunDef in[],unsigned inCount,const RunDef out[],unsigned outCount)246 static void RunBuilderTest(skiatest::Reporter* reporter, SkTextBlobBuilder& builder,
247 const RunDef in[], unsigned inCount,
248 const RunDef out[], unsigned outCount) {
249 SkFont font;
250
251 for (unsigned i = 0; i < inCount; ++i) {
252 AddRun(font, in[i].count, in[i].pos, SkPoint::Make(in[i].x, in[i].y), builder);
253 }
254
255 sk_sp<SkTextBlob> blob(builder.make());
256 REPORTER_ASSERT(reporter, (inCount > 0) == SkToBool(blob));
257 if (!blob) {
258 return;
259 }
260
261 SkTextBlobRunIterator it(blob.get());
262 for (unsigned i = 0; i < outCount; ++i) {
263 REPORTER_ASSERT(reporter, !it.done());
264 REPORTER_ASSERT(reporter, out[i].pos == it.positioning());
265 REPORTER_ASSERT(reporter, out[i].count == it.glyphCount());
266 if (SkTextBlobRunIterator::kDefault_Positioning == out[i].pos) {
267 REPORTER_ASSERT(reporter, out[i].x == it.offset().x());
268 REPORTER_ASSERT(reporter, out[i].y == it.offset().y());
269 } else if (SkTextBlobRunIterator::kHorizontal_Positioning == out[i].pos) {
270 REPORTER_ASSERT(reporter, out[i].y == it.offset().y());
271 }
272
273 for (unsigned k = 0; k < it.glyphCount(); ++k) {
274 REPORTER_ASSERT(reporter, k % 128 == it.glyphs()[k]);
275 if (SkTextBlobRunIterator::kHorizontal_Positioning == it.positioning()) {
276 REPORTER_ASSERT(reporter, SkIntToScalar(k % 128) == it.pos()[k]);
277 } else if (SkTextBlobRunIterator::kFull_Positioning == it.positioning()) {
278 REPORTER_ASSERT(reporter, SkIntToScalar(k % 128) == it.pos()[k * 2]);
279 REPORTER_ASSERT(reporter, -SkIntToScalar(k % 128) == it.pos()[k * 2 + 1]);
280 }
281 }
282
283 it.next();
284 }
285
286 REPORTER_ASSERT(reporter, it.done());
287 }
288
AddRun(const SkFont & font,int count,SkTextBlobRunIterator::GlyphPositioning pos,const SkPoint & offset,SkTextBlobBuilder & builder,const SkRect * bounds=nullptr)289 static void AddRun(const SkFont& font, int count, SkTextBlobRunIterator::GlyphPositioning pos,
290 const SkPoint& offset, SkTextBlobBuilder& builder,
291 const SkRect* bounds = nullptr) {
292 switch (pos) {
293 case SkTextBlobRunIterator::kDefault_Positioning: {
294 const SkTextBlobBuilder::RunBuffer& rb = builder.allocRun(font, count, offset.x(),
295 offset.y(), bounds);
296 for (int i = 0; i < count; ++i) {
297 rb.glyphs[i] = i;
298 }
299 } break;
300 case SkTextBlobRunIterator::kHorizontal_Positioning: {
301 const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPosH(font, count, offset.y(),
302 bounds);
303 for (int i = 0; i < count; ++i) {
304 rb.glyphs[i] = i;
305 rb.pos[i] = SkIntToScalar(i);
306 }
307 } break;
308 case SkTextBlobRunIterator::kFull_Positioning: {
309 const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPos(font, count, bounds);
310 for (int i = 0; i < count; ++i) {
311 rb.glyphs[i] = i;
312 rb.pos[i * 2] = SkIntToScalar(i);
313 rb.pos[i * 2 + 1] = -SkIntToScalar(i);
314 }
315 } break;
316 default:
317 SK_ABORT("unhandled positioning value");
318 }
319 }
320 };
321
DEF_TEST(TextBlob_builder,reporter)322 DEF_TEST(TextBlob_builder, reporter) {
323 TextBlobTester::TestBuilder(reporter);
324 TextBlobTester::TestBounds(reporter);
325 }
326
DEF_TEST(TextBlob_paint,reporter)327 DEF_TEST(TextBlob_paint, reporter) {
328 TextBlobTester::TestPaintProps(reporter);
329 }
330
DEF_TEST(TextBlob_extended,reporter)331 DEF_TEST(TextBlob_extended, reporter) {
332 SkTextBlobBuilder textBlobBuilder;
333 SkFont font;
334 const char text1[] = "Foo";
335 const char text2[] = "Bar";
336
337 int glyphCount = font.countText(text1, strlen(text1), SkTextEncoding::kUTF8);
338 AutoTMalloc<uint16_t> glyphs(glyphCount);
339 (void)font.textToGlyphs(text1, strlen(text1), SkTextEncoding::kUTF8, glyphs.get(), glyphCount);
340
341 auto run = textBlobBuilder.allocRunText(font, glyphCount, 0, 0, SkToInt(strlen(text2)));
342 memcpy(run.glyphs, glyphs.get(), sizeof(uint16_t) * glyphCount);
343 memcpy(run.utf8text, text2, strlen(text2));
344 for (int i = 0; i < glyphCount; ++i) {
345 run.clusters[i] = std::min(SkToU32(i), SkToU32(strlen(text2)));
346 }
347 sk_sp<SkTextBlob> blob(textBlobBuilder.make());
348 REPORTER_ASSERT(reporter, blob);
349
350 for (SkTextBlobRunIterator it(blob.get()); !it.done(); it.next()) {
351 REPORTER_ASSERT(reporter, it.glyphCount() == (uint32_t)glyphCount);
352 for (uint32_t i = 0; i < it.glyphCount(); ++i) {
353 REPORTER_ASSERT(reporter, it.glyphs()[i] == glyphs[i]);
354 }
355 REPORTER_ASSERT(reporter, SkTextBlobRunIterator::kDefault_Positioning == it.positioning());
356 REPORTER_ASSERT(reporter, (SkPoint{0.0f, 0.0f}) == it.offset());
357 REPORTER_ASSERT(reporter, it.textSize() > 0);
358 REPORTER_ASSERT(reporter, it.clusters());
359 for (uint32_t i = 0; i < it.glyphCount(); ++i) {
360 REPORTER_ASSERT(reporter, i == it.clusters()[i]);
361 }
362 REPORTER_ASSERT(reporter, 0 == strncmp(text2, it.text(), it.textSize()));
363 }
364 }
365
366 ///////////////////////////////////////////////////////////////////////////////////////////////////
add_run(SkTextBlobBuilder * builder,const char text[],SkScalar x,SkScalar y,sk_sp<SkTypeface> tf)367 static void add_run(SkTextBlobBuilder* builder, const char text[], SkScalar x, SkScalar y,
368 sk_sp<SkTypeface> tf) {
369 SkFont font;
370 font.setEdging(SkFont::Edging::kAntiAlias);
371 font.setSubpixel(true);
372 font.setSize(16);
373 font.setTypeface(tf);
374
375 int glyphCount = font.countText(text, strlen(text), SkTextEncoding::kUTF8);
376
377 SkTextBlobBuilder::RunBuffer buffer = builder->allocRun(font, glyphCount, x, y);
378
379 (void)font.textToGlyphs(text, strlen(text), SkTextEncoding::kUTF8, buffer.glyphs, glyphCount);
380 }
381
render(const SkTextBlob * blob)382 static sk_sp<SkImage> render(const SkTextBlob* blob) {
383 auto surf = SkSurface::MakeRasterN32Premul(SkScalarRoundToInt(blob->bounds().width()),
384 SkScalarRoundToInt(blob->bounds().height()));
385 if (!surf) {
386 return nullptr; // bounds are empty?
387 }
388 surf->getCanvas()->clear(SK_ColorWHITE);
389 surf->getCanvas()->drawTextBlob(blob, -blob->bounds().left(), -blob->bounds().top(), SkPaint());
390 return surf->makeImageSnapshot();
391 }
392
SerializeTypeface(SkTypeface * tf,void * ctx)393 static sk_sp<SkData> SerializeTypeface(SkTypeface* tf, void* ctx) {
394 auto array = (SkTArray<sk_sp<SkTypeface>>*)ctx;
395 const size_t idx = array->size();
396 array->emplace_back(sk_ref_sp(tf));
397 // In this test, we are deserializing on the same machine, so we don't worry about endianness.
398 return SkData::MakeWithCopy(&idx, sizeof(idx));
399 }
400
DeserializeTypeface(const void * data,size_t length,void * ctx)401 static sk_sp<SkTypeface> DeserializeTypeface(const void* data, size_t length, void* ctx) {
402 auto array = (SkTArray<sk_sp<SkTypeface>>*)ctx;
403 if (length != sizeof(size_t)) {
404 SkASSERT(false);
405 return nullptr;
406 }
407 size_t idx = *reinterpret_cast<const size_t*>(data);
408 if (idx >= SkToSizeT(array->size())) {
409 SkASSERT(false);
410 return nullptr;
411 }
412 return (*array)[idx];
413 }
414
415 /*
416 * Build a blob with more than one typeface.
417 * Draw it into an offscreen,
418 * then serialize and deserialize,
419 * Then draw the new instance and assert it draws the same as the original.
420 */
DEF_TEST(TextBlob_serialize,reporter)421 DEF_TEST(TextBlob_serialize, reporter) {
422 sk_sp<SkTextBlob> blob0 = []() {
423 sk_sp<SkTypeface> tf = SkTypeface::MakeFromName(nullptr, SkFontStyle::BoldItalic());
424
425 SkTextBlobBuilder builder;
426 add_run(&builder, "Hello", 10, 20, nullptr); // don't flatten a typeface
427 add_run(&builder, "World", 10, 40, tf); // do flatten this typeface
428 return builder.make();
429 }();
430
431 SkTArray<sk_sp<SkTypeface>> array;
432 SkSerialProcs serializeProcs;
433 serializeProcs.fTypefaceProc = &SerializeTypeface;
434 serializeProcs.fTypefaceCtx = (void*) &array;
435 sk_sp<SkData> data = blob0->serialize(serializeProcs);
436 REPORTER_ASSERT(reporter, array.size() == 1);
437 SkDeserialProcs deserializeProcs;
438 deserializeProcs.fTypefaceProc = &DeserializeTypeface;
439 deserializeProcs.fTypefaceCtx = (void*) &array;
440 sk_sp<SkTextBlob> blob1 = SkTextBlob::Deserialize(data->data(), data->size(), deserializeProcs);
441
442 sk_sp<SkImage> img0 = render(blob0.get());
443 sk_sp<SkImage> img1 = render(blob1.get());
444 if (img0 && img1) {
445 REPORTER_ASSERT(reporter, ToolUtils::equal_pixels(img0.get(), img1.get()));
446 }
447 }
448
DEF_TEST(TextBlob_MakeAsDrawText,reporter)449 DEF_TEST(TextBlob_MakeAsDrawText, reporter) {
450 const char text[] = "Hello";
451 auto blob = SkTextBlob::MakeFromString(text, SkFont(), SkTextEncoding::kUTF8);
452
453 int runs = 0;
454 for(SkTextBlobRunIterator it(blob.get()); !it.done(); it.next()) {
455 REPORTER_ASSERT(reporter, it.glyphCount() == strlen(text));
456 REPORTER_ASSERT(reporter, it.positioning() == SkTextBlobRunIterator::kFull_Positioning);
457 runs += 1;
458 }
459 REPORTER_ASSERT(reporter, runs == 1);
460
461 }
462
DEF_TEST(TextBlob_iter,reporter)463 DEF_TEST(TextBlob_iter, reporter) {
464 sk_sp<SkTypeface> tf = SkTypeface::MakeFromName(nullptr, SkFontStyle::BoldItalic());
465
466 SkTextBlobBuilder builder;
467 add_run(&builder, "Hello", 10, 20, nullptr);
468 add_run(&builder, "World", 10, 40, tf);
469 auto blob = builder.make();
470
471 SkTextBlob::Iter::Run expected[] = {
472 { nullptr, 5, nullptr },
473 { tf.get(), 5, nullptr },
474 };
475
476 SkTextBlob::Iter iter(*blob);
477 SkTextBlob::Iter::Run run;
478 for (auto exp : expected) {
479 REPORTER_ASSERT(reporter, iter.next(&run));
480 REPORTER_ASSERT(reporter, run.fTypeface == exp.fTypeface);
481 REPORTER_ASSERT(reporter, run.fGlyphCount == exp.fGlyphCount);
482 for (int i = 0; i < run.fGlyphCount; ++i) {
483 REPORTER_ASSERT(reporter, run.fGlyphIndices[i] != 0);
484 }
485 }
486 REPORTER_ASSERT(reporter, !iter.next(&run)); // we're done
487
488 SkTextBlob::Iter iter2(*blob);
489 REPORTER_ASSERT(reporter, iter2.next(&run));
490 // Hello should have the same glyph repeated for the 'l'
491 REPORTER_ASSERT(reporter, run.fGlyphIndices[2] == run.fGlyphIndices[3]);
492 }
493
DEF_TEST(TextBlob_getIntercepts,reporter)494 DEF_TEST(TextBlob_getIntercepts, reporter) {
495 SkFont font;
496 font.setSize(16);
497
498 SkPoint lowPos[1] = { SkPoint::Make(0, 5) };
499 SkPoint highPos[1] = { SkPoint::Make(0, -8) };
500 SkPoint zeroPos[1] = { SkPoint::Make(0, 0) };
501
502 // 'x' sitting on baseline
503 auto blobZeroX = SkTextBlob::MakeFromPosText("x", 1, zeroPos, font);
504 // 'x' lowered to intersect baseline
505 auto blobLowX = SkTextBlob::MakeFromPosText("x", 1, lowPos, font);
506 // 'y' sitting on baseline
507 auto blobZeroY = SkTextBlob::MakeFromPosText("y", 1, zeroPos, font);
508 // 'y' raised to not intersect baseline
509 auto blobHighY = SkTextBlob::MakeFromPosText("y", 1, highPos, font);
510
511 // bounds right below baseline
512 SkScalar bounds[2] = { 1, 2 };
513
514 // 'x' on baseline should not intersect
515 REPORTER_ASSERT(reporter, blobZeroX->getIntercepts(bounds, nullptr) == 0);
516 // lowered 'x' should intersect
517 REPORTER_ASSERT(reporter, blobLowX->getIntercepts(bounds, nullptr) == 2);
518 // 'y' on baseline should intersect
519 REPORTER_ASSERT(reporter, blobZeroY->getIntercepts(bounds, nullptr) == 2);
520 // raised 'y' should not intersect
521 REPORTER_ASSERT(reporter, blobHighY->getIntercepts(bounds, nullptr) == 0);
522 }
523