1 /*
2 * Copyright 2013 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/SkFont.h"
9 #include "include/core/SkFontArguments.h"
10 #include "include/core/SkFontMgr.h"
11 #include "include/core/SkFontParameters.h"
12 #include "include/core/SkFontStyle.h"
13 #include "include/core/SkFontTypes.h"
14 #include "include/core/SkRefCnt.h"
15 #include "include/core/SkStream.h"
16 #include "include/core/SkString.h"
17 #include "include/core/SkTypeface.h"
18 #include "include/core/SkTypes.h"
19 #include "include/private/base/SkDebug.h"
20 #include "include/private/base/SkMalloc.h"
21 #include "src/core/SkAdvancedTypefaceMetrics.h" // IWYU pragma: keep
22 #include "src/core/SkFontPriv.h"
23 #include "src/core/SkScalerContext.h"
24 #include "tests/Test.h"
25 #include "tools/flags/CommandLineFlags.h"
26 #include "tools/fonts/FontToolUtils.h"
27
28 #include <cstddef>
29 #include <cstdint>
30 #include <initializer_list>
31 #include <memory>
32 #include <vector>
33
34 class SkDescriptor;
35 class SkFontDescriptor;
36
37 DECLARE_bool(verboseFontMgr)
38
DEF_TEST(FontMgr_Font,reporter)39 DEF_TEST(FontMgr_Font, reporter) {
40 SkFont font(ToolUtils::DefaultTypeface(), 24);
41
42 REPORTER_ASSERT(reporter, 24 == font.getSize());
43 REPORTER_ASSERT(reporter, 1 == font.getScaleX());
44 REPORTER_ASSERT(reporter, 0 == font.getSkewX());
45
46 SkGlyphID glyphs[5];
47 sk_bzero(glyphs, sizeof(glyphs));
48
49 // Check that no glyphs are copied with insufficient storage.
50 int count = font.textToGlyphs("Hello", 5, SkTextEncoding::kUTF8, glyphs, 2);
51 REPORTER_ASSERT(reporter, 5 == count);
52 for (const auto glyph : glyphs) { REPORTER_ASSERT(reporter, glyph == 0); }
53
54 SkAssertResult(font.textToGlyphs("Hello", 5, SkTextEncoding::kUTF8, glyphs,
55 std::size(glyphs)) == count);
56
57 for (int i = 0; i < count; ++i) {
58 REPORTER_ASSERT(reporter, 0 != glyphs[i]);
59 }
60 REPORTER_ASSERT(reporter, glyphs[0] != glyphs[1]); // 'h' != 'e'
61 REPORTER_ASSERT(reporter, glyphs[2] == glyphs[3]); // 'l' == 'l'
62
63 const SkFont newFont(font.makeWithSize(36));
64 REPORTER_ASSERT(reporter, font.getTypeface() == newFont.getTypeface());
65 REPORTER_ASSERT(reporter, 36 == newFont.getSize()); // double check we haven't changed
66 REPORTER_ASSERT(reporter, 24 == font.getSize()); // double check we haven't changed
67 }
68
69 /*
70 * If the font backend is going to "alias" some font names to other fonts
71 * (e.g. sans -> Arial) then we want to at least get the same typeface back
72 * if we request the alias name multiple times.
73 */
DEF_TEST(FontMgr_AliasNames,reporter)74 DEF_TEST(FontMgr_AliasNames, reporter) {
75 const char* inNames[] = {
76 "sans", "sans-serif", "serif", "monospace", "times", "helvetica"
77 };
78
79 for (size_t i = 0; i < std::size(inNames); ++i) {
80 sk_sp<SkTypeface> first(ToolUtils::CreateTestTypeface(inNames[i], SkFontStyle()));
81 if (nullptr == first.get()) {
82 continue;
83 }
84 SkString firstName;
85 first->getFamilyName(&firstName);
86 for (int j = 0; j < 10; ++j) {
87 sk_sp<SkTypeface> face(ToolUtils::CreateTestTypeface(inNames[i], SkFontStyle()));
88
89 SkString name;
90 face->getFamilyName(&name);
91 REPORTER_ASSERT(reporter, first->uniqueID() == face->uniqueID(),
92 "Request \"%s\" First Name: \"%s\" Id: %x Received Name \"%s\" Id %x",
93 inNames[i], firstName.c_str(), first->uniqueID(), name.c_str(), face->uniqueID());
94 }
95 }
96 }
97
DEF_TEST(FontMgr_Iter,reporter)98 DEF_TEST(FontMgr_Iter, reporter) {
99 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
100 int count = fm->countFamilies();
101
102 for (int i = 0; i < count; ++i) {
103 SkString fname;
104 fm->getFamilyName(i, &fname);
105
106 sk_sp<SkFontStyleSet> fnset(fm->matchFamily(fname.c_str()));
107 sk_sp<SkFontStyleSet> set(fm->createStyleSet(i));
108 REPORTER_ASSERT(reporter, fnset->count() == set->count());
109
110 if (FLAGS_verboseFontMgr) {
111 SkDebugf("[%2d] %s\n", i, fname.c_str());
112 }
113
114 for (int j = 0; j < set->count(); ++j) {
115 SkString sname;
116 SkFontStyle fs;
117 set->getStyle(j, &fs, &sname);
118
119 if (FLAGS_verboseFontMgr) {
120 SkDebugf("\t[%d] %s [%3d %d %d]", j, sname.c_str(),
121 fs.weight(), fs.width(), fs.slant());
122 }
123
124 sk_sp<SkTypeface> face1(set->createTypeface(j));
125 if (!face1) {
126 REPORTER_ASSERT(reporter, face1.get(),
127 "Could not create %s %s.", fname.c_str(), sname.c_str());
128 continue;
129 }
130 SkString name1;
131 face1->getFamilyName(&name1);
132 SkFontStyle s1 = face1->fontStyle();
133
134 SkString resource1;
135 face1->getResourceName(&resource1);
136 if (FLAGS_verboseFontMgr) {
137 SkDebugf(" \"%s\" \"%s\"\n", name1.c_str(), resource1.c_str());
138 }
139
140 // Note that fs != s1 is fine, though probably rare.
141
142 sk_sp<SkTypeface> face2(fm->matchFamilyStyle(name1.c_str(), s1));
143 if (!face2) {
144 REPORTER_ASSERT(reporter, face2.get());
145 continue;
146 }
147 SkString name2;
148 face2->getFamilyName(&name2);
149
150 REPORTER_ASSERT(reporter, name1 == name2, "%s == %s", name1.c_str(), name2.c_str());
151
152 SkFontStyle s2 = face2->fontStyle();
153 REPORTER_ASSERT(reporter, s1 == s2, "%s [%3d %d %d] != %s [%3d %d %d]",
154 name1.c_str(), s1.weight(), s1.width(), s1.slant(),
155 name2.c_str(), s2.weight(), s2.width(), s2.slant());
156 }
157 }
158 }
159
DEF_TEST(FontMgr_Match,reporter)160 DEF_TEST(FontMgr_Match, reporter) {
161 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
162 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily(nullptr));
163 REPORTER_ASSERT(reporter, styleSet);
164 }
165
DEF_TEST(FontMgr_MatchFamilyStyle,reporter)166 DEF_TEST(FontMgr_MatchFamilyStyle, reporter) {
167 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
168
169 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily("Non Existing Family Name"));
170 REPORTER_ASSERT(reporter, styleSet);
171 REPORTER_ASSERT(reporter, styleSet->count() == 0);
172
173 using FS = SkFontStyle;
174 sk_sp<SkTypeface> typeface(fm->matchFamilyStyle("Non Existing Family Name", FS::Normal()));
175 REPORTER_ASSERT(reporter, !typeface);
176
177 // TODO: enable after determining if a default font should be required.
178 if ((false)) {
179 sk_sp<SkTypeface> def(fm->matchFamilyStyle(nullptr, FS::Normal()));
180 REPORTER_ASSERT(reporter, def);
181 }
182 }
183
DEF_TEST(FontMgr_MatchStyleCSS3,reporter)184 DEF_TEST(FontMgr_MatchStyleCSS3, reporter) {
185 static const SkFontStyle invalidFontStyle(101, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
186
187 class TestTypeface : public SkTypeface {
188 public:
189 TestTypeface(const SkFontStyle& fontStyle) : SkTypeface(fontStyle, false){}
190 protected:
191 std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override { return nullptr; }
192 sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
193 return sk_ref_sp(this);
194 }
195 std::unique_ptr<SkScalerContext> onCreateScalerContext(
196 const SkScalerContextEffects& effects, const SkDescriptor* desc) const override
197 {
198 return SkScalerContext::MakeEmpty(*const_cast<TestTypeface*>(this), effects, desc);
199 }
200 void onFilterRec(SkScalerContextRec*) const override { }
201 std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const override {
202 return nullptr;
203 }
204 void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
205 void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const override {
206 sk_bzero(glyphs, count * sizeof(glyphs[0]));
207 }
208 int onCountGlyphs() const override { return 0; }
209 void getPostScriptGlyphNames(SkString*) const override {}
210 void getGlyphToUnicodeMap(SkUnichar*) const override {}
211 int onGetUPEM() const override { return 0; }
212 class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
213 public:
214 bool next(SkTypeface::LocalizedString*) override { return false; }
215 };
216 void onGetFamilyName(SkString* familyName) const override {
217 familyName->reset();
218 }
219 bool onGetPostScriptName(SkString*) const override { return false; }
220 SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
221 return new EmptyLocalizedStrings;
222 }
223 bool onGlyphMaskNeedsCurrentColor() const override { return false; }
224 int onGetVariationDesignPosition(
225 SkFontArguments::VariationPosition::Coordinate coordinates[],
226 int coordinateCount) const override
227 {
228 return 0;
229 }
230 int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
231 int parameterCount) const override
232 {
233 return -1;
234 }
235 int onGetTableTags(SkFontTableTag tags[]) const override { return 0; }
236 size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
237 return 0;
238 }
239 };
240
241 class TestFontStyleSet : public SkFontStyleSet {
242 public:
243 TestFontStyleSet(std::initializer_list<SkFontStyle> styles) : fStyles(styles) {}
244 int count() override { return static_cast<int>(fStyles.size()); }
245 void getStyle(int index, SkFontStyle* style, SkString*) override {
246 if (style) {
247 *style = fStyles[index];
248 }
249 }
250 sk_sp<SkTypeface> createTypeface(int index) override {
251 if (index < 0 || this->count() <= index) {
252 return sk_sp<SkTypeface>(new TestTypeface(invalidFontStyle));
253 }
254 return sk_sp<SkTypeface>(new TestTypeface(fStyles[index]));
255 }
256 sk_sp<SkTypeface> matchStyle(const SkFontStyle& pattern) override {
257 return this->matchStyleCSS3(pattern);
258 }
259 private:
260 std::vector<SkFontStyle> fStyles;
261 };
262
263 SkFontStyle condensed_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
264 SkFontStyle condensed_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
265 SkFontStyle condensed_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
266 SkFontStyle condensed_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
267 SkFontStyle condensed_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
268 SkFontStyle condensed_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
269 SkFontStyle expanded_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
270 SkFontStyle expanded_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
271 SkFontStyle expanded_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
272 SkFontStyle expanded_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
273 SkFontStyle expanded_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
274 SkFontStyle expanded_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
275
276 SkFontStyle normal_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
277 SkFontStyle normal_normal_300(SkFontStyle::kLight_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
278 SkFontStyle normal_normal_400(SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
279 SkFontStyle normal_normal_500(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
280 SkFontStyle normal_normal_600(SkFontStyle::kSemiBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
281 SkFontStyle normal_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
282
283 struct StyleSetTest {
284 TestFontStyleSet styleSet;
285 struct Case {
286 SkFontStyle pattern;
287 SkFontStyle expectedResult;
288 };
289 std::vector<Case> cases;
290 } tests[] = {
291 {
292 { normal_normal_500, normal_normal_400 },
293 {
294 { normal_normal_400, normal_normal_400 },
295 { normal_normal_500, normal_normal_500 },
296 },
297 },
298
299 {
300 { normal_normal_500, normal_normal_300 },
301 {
302 { normal_normal_300, normal_normal_300 },
303 { normal_normal_400, normal_normal_500 },
304 { normal_normal_500, normal_normal_500 },
305 },
306 },
307
308 {
309 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900,
310 expanded_normal_100, expanded_normal_900, expanded_italic_100, expanded_italic_900 },
311 {
312 { condensed_normal_100, condensed_normal_100 },
313 { condensed_normal_900, condensed_normal_900 },
314 { condensed_italic_100, condensed_italic_100 },
315 { condensed_italic_900, condensed_italic_900 },
316 { expanded_normal_100, expanded_normal_100 },
317 { expanded_normal_900, expanded_normal_900 },
318 { expanded_italic_100, expanded_italic_100 },
319 { expanded_italic_900, expanded_italic_900 },
320 },
321 },
322
323 {
324 { condensed_normal_100,condensed_italic_100,expanded_normal_100,expanded_italic_100 },
325 {
326 { condensed_normal_100, condensed_normal_100 },
327 { condensed_normal_900, condensed_normal_100 },
328 { condensed_italic_100, condensed_italic_100 },
329 { condensed_italic_900, condensed_italic_100 },
330 { expanded_normal_100, expanded_normal_100 },
331 { expanded_normal_900, expanded_normal_100 },
332 { expanded_italic_100, expanded_italic_100 },
333 { expanded_italic_900, expanded_italic_100 },
334 },
335 },
336
337 {
338 { condensed_normal_900,condensed_italic_900,expanded_normal_900,expanded_italic_900 },
339 {
340 { condensed_normal_100, condensed_normal_900 },
341 { condensed_normal_900, condensed_normal_900 },
342 { condensed_italic_100, condensed_italic_900 },
343 { condensed_italic_900, condensed_italic_900 },
344 { expanded_normal_100, expanded_normal_900 },
345 { expanded_normal_900, expanded_normal_900 },
346 { expanded_italic_100, expanded_italic_900 },
347 { expanded_italic_900, expanded_italic_900 },
348 },
349 },
350
351 {
352 { condensed_normal_100,condensed_normal_900,expanded_normal_100,expanded_normal_900 },
353 {
354 { condensed_normal_100, condensed_normal_100 },
355 { condensed_normal_900, condensed_normal_900 },
356 { condensed_italic_100, condensed_normal_100 },
357 { condensed_italic_900, condensed_normal_900 },
358 { expanded_normal_100, expanded_normal_100 },
359 { expanded_normal_900, expanded_normal_900 },
360 { expanded_italic_100, expanded_normal_100 },
361 { expanded_italic_900, expanded_normal_900 },
362 },
363 },
364
365 {
366 { condensed_normal_100,expanded_normal_100 },
367 {
368 { condensed_normal_100, condensed_normal_100 },
369 { condensed_normal_900, condensed_normal_100 },
370 { condensed_italic_100, condensed_normal_100 },
371 { condensed_italic_900, condensed_normal_100 },
372 { expanded_normal_100, expanded_normal_100 },
373 { expanded_normal_900, expanded_normal_100 },
374 { expanded_italic_100, expanded_normal_100 },
375 { expanded_italic_900, expanded_normal_100 },
376 },
377 },
378
379 {
380 { condensed_normal_900,expanded_normal_900 },
381 {
382 { condensed_normal_100, condensed_normal_900 },
383 { condensed_normal_900, condensed_normal_900 },
384 { condensed_italic_100, condensed_normal_900 },
385 { condensed_italic_900, condensed_normal_900 },
386 { expanded_normal_100, expanded_normal_900 },
387 { expanded_normal_900, expanded_normal_900 },
388 { expanded_italic_100, expanded_normal_900 },
389 { expanded_italic_900, expanded_normal_900 },
390 },
391 },
392
393 {
394 { condensed_italic_100,condensed_italic_900,expanded_italic_100,expanded_italic_900 },
395 {
396 { condensed_normal_100, condensed_italic_100 },
397 { condensed_normal_900, condensed_italic_900 },
398 { condensed_italic_100, condensed_italic_100 },
399 { condensed_italic_900, condensed_italic_900 },
400 { expanded_normal_100, expanded_italic_100 },
401 { expanded_normal_900, expanded_italic_900 },
402 { expanded_italic_100, expanded_italic_100 },
403 { expanded_italic_900, expanded_italic_900 },
404 },
405 },
406
407 {
408 { condensed_italic_100,expanded_italic_100 },
409 {
410 { condensed_normal_100, condensed_italic_100 },
411 { condensed_normal_900, condensed_italic_100 },
412 { condensed_italic_100, condensed_italic_100 },
413 { condensed_italic_900, condensed_italic_100 },
414 { expanded_normal_100, expanded_italic_100 },
415 { expanded_normal_900, expanded_italic_100 },
416 { expanded_italic_100, expanded_italic_100 },
417 { expanded_italic_900, expanded_italic_100 },
418 },
419 },
420
421 {
422 { condensed_italic_900,expanded_italic_900 },
423 {
424 { condensed_normal_100, condensed_italic_900 },
425 { condensed_normal_900, condensed_italic_900 },
426 { condensed_italic_100, condensed_italic_900 },
427 { condensed_italic_900, condensed_italic_900 },
428 { expanded_normal_100, expanded_italic_900 },
429 { expanded_normal_900, expanded_italic_900 },
430 { expanded_italic_100, expanded_italic_900 },
431 { expanded_italic_900, expanded_italic_900 },
432 },
433 },
434
435 {
436 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900 },
437 {
438 { condensed_normal_100, condensed_normal_100 },
439 { condensed_normal_900, condensed_normal_900 },
440 { condensed_italic_100, condensed_italic_100 },
441 { condensed_italic_900, condensed_italic_900 },
442 { expanded_normal_100, condensed_normal_100 },
443 { expanded_normal_900, condensed_normal_900 },
444 { expanded_italic_100, condensed_italic_100 },
445 { expanded_italic_900, condensed_italic_900 },
446 },
447 },
448
449 {
450 { condensed_normal_100,condensed_italic_100 },
451 {
452 { condensed_normal_100, condensed_normal_100 },
453 { condensed_normal_900, condensed_normal_100 },
454 { condensed_italic_100, condensed_italic_100 },
455 { condensed_italic_900, condensed_italic_100 },
456 { expanded_normal_100, condensed_normal_100 },
457 { expanded_normal_900, condensed_normal_100 },
458 { expanded_italic_100, condensed_italic_100 },
459 { expanded_italic_900, condensed_italic_100 },
460 },
461 },
462
463 {
464 { condensed_normal_900,condensed_italic_900 },
465 {
466 { condensed_normal_100, condensed_normal_900 },
467 { condensed_normal_900, condensed_normal_900 },
468 { condensed_italic_100, condensed_italic_900 },
469 { condensed_italic_900, condensed_italic_900 },
470 { expanded_normal_100, condensed_normal_900 },
471 { expanded_normal_900, condensed_normal_900 },
472 { expanded_italic_100, condensed_italic_900 },
473 { expanded_italic_900, condensed_italic_900 },
474 },
475 },
476
477 {
478 { condensed_normal_100,condensed_normal_900 },
479 {
480 { condensed_normal_100, condensed_normal_100 },
481 { condensed_normal_900, condensed_normal_900 },
482 { condensed_italic_100, condensed_normal_100 },
483 { condensed_italic_900, condensed_normal_900 },
484 { expanded_normal_100, condensed_normal_100 },
485 { expanded_normal_900, condensed_normal_900 },
486 { expanded_italic_100, condensed_normal_100 },
487 { expanded_italic_900, condensed_normal_900 },
488 },
489 },
490
491 {
492 { condensed_normal_100 },
493 {
494 { condensed_normal_100, condensed_normal_100 },
495 { condensed_normal_900, condensed_normal_100 },
496 { condensed_italic_100, condensed_normal_100 },
497 { condensed_italic_900, condensed_normal_100 },
498 { expanded_normal_100, condensed_normal_100 },
499 { expanded_normal_900, condensed_normal_100 },
500 { expanded_italic_100, condensed_normal_100 },
501 { expanded_italic_900, condensed_normal_100 },
502 },
503 },
504
505 {
506 { condensed_normal_900 },
507 {
508 { condensed_normal_100, condensed_normal_900 },
509 { condensed_normal_900, condensed_normal_900 },
510 { condensed_italic_100, condensed_normal_900 },
511 { condensed_italic_900, condensed_normal_900 },
512 { expanded_normal_100, condensed_normal_900 },
513 { expanded_normal_900, condensed_normal_900 },
514 { expanded_italic_100, condensed_normal_900 },
515 { expanded_italic_900, condensed_normal_900 },
516 },
517 },
518
519 {
520 { condensed_italic_100,condensed_italic_900 },
521 {
522 { condensed_normal_100, condensed_italic_100 },
523 { condensed_normal_900, condensed_italic_900 },
524 { condensed_italic_100, condensed_italic_100 },
525 { condensed_italic_900, condensed_italic_900 },
526 { expanded_normal_100, condensed_italic_100 },
527 { expanded_normal_900, condensed_italic_900 },
528 { expanded_italic_100, condensed_italic_100 },
529 { expanded_italic_900, condensed_italic_900 },
530 },
531 },
532
533 {
534 { condensed_italic_100 },
535 {
536 { condensed_normal_100, condensed_italic_100 },
537 { condensed_normal_900, condensed_italic_100 },
538 { condensed_italic_100, condensed_italic_100 },
539 { condensed_italic_900, condensed_italic_100 },
540 { expanded_normal_100, condensed_italic_100 },
541 { expanded_normal_900, condensed_italic_100 },
542 { expanded_italic_100, condensed_italic_100 },
543 { expanded_italic_900, condensed_italic_100 },
544 },
545 },
546
547 {
548 { condensed_italic_900 },
549 {
550 { condensed_normal_100, condensed_italic_900 },
551 { condensed_normal_900, condensed_italic_900 },
552 { condensed_italic_100, condensed_italic_900 },
553 { condensed_italic_900, condensed_italic_900 },
554 { expanded_normal_100, condensed_italic_900 },
555 { expanded_normal_900, condensed_italic_900 },
556 { expanded_italic_100, condensed_italic_900 },
557 { expanded_italic_900, condensed_italic_900 },
558 },
559 },
560
561 {
562 { expanded_normal_100,expanded_normal_900,
563 expanded_italic_100,expanded_italic_900 },
564 {
565 { condensed_normal_100, expanded_normal_100 },
566 { condensed_normal_900, expanded_normal_900 },
567 { condensed_italic_100, expanded_italic_100 },
568 { condensed_italic_900, expanded_italic_900 },
569 { condensed_obliqu_100, expanded_italic_100 },
570 { condensed_obliqu_900, expanded_italic_900 },
571 { expanded_normal_100, expanded_normal_100 },
572 { expanded_normal_900, expanded_normal_900 },
573 { expanded_italic_100, expanded_italic_100 },
574 { expanded_italic_900, expanded_italic_900 },
575 { expanded_obliqu_100, expanded_italic_100 },
576 { expanded_obliqu_900, expanded_italic_900 },
577 },
578 },
579
580 {
581 { expanded_normal_100,expanded_italic_100 },
582 {
583 { condensed_normal_100, expanded_normal_100 },
584 { condensed_normal_900, expanded_normal_100 },
585 { condensed_italic_100, expanded_italic_100 },
586 { condensed_italic_900, expanded_italic_100 },
587 { expanded_normal_100, expanded_normal_100 },
588 { expanded_normal_900, expanded_normal_100 },
589 { expanded_italic_100, expanded_italic_100 },
590 { expanded_italic_900, expanded_italic_100 },
591 },
592 },
593
594 {
595 { expanded_normal_900,expanded_italic_900 },
596 {
597 { condensed_normal_100, expanded_normal_900 },
598 { condensed_normal_900, expanded_normal_900 },
599 { condensed_italic_100, expanded_italic_900 },
600 { condensed_italic_900, expanded_italic_900 },
601 { expanded_normal_100, expanded_normal_900 },
602 { expanded_normal_900, expanded_normal_900 },
603 { expanded_italic_100, expanded_italic_900 },
604 { expanded_italic_900, expanded_italic_900 },
605 },
606 },
607
608 {
609 { expanded_normal_100,expanded_normal_900 },
610 {
611 { condensed_normal_100, expanded_normal_100 },
612 { condensed_normal_900, expanded_normal_900 },
613 { condensed_italic_100, expanded_normal_100 },
614 { condensed_italic_900, expanded_normal_900 },
615 { expanded_normal_100, expanded_normal_100 },
616 { expanded_normal_900, expanded_normal_900 },
617 { expanded_italic_100, expanded_normal_100 },
618 { expanded_italic_900, expanded_normal_900 },
619 },
620 },
621
622 {
623 { expanded_normal_100 },
624 {
625 { condensed_normal_100, expanded_normal_100 },
626 { condensed_normal_900, expanded_normal_100 },
627 { condensed_italic_100, expanded_normal_100 },
628 { condensed_italic_900, expanded_normal_100 },
629 { expanded_normal_100, expanded_normal_100 },
630 { expanded_normal_900, expanded_normal_100 },
631 { expanded_italic_100, expanded_normal_100 },
632 { expanded_italic_900, expanded_normal_100 },
633 },
634 },
635
636 {
637 { expanded_normal_900 },
638 {
639 { condensed_normal_100, expanded_normal_900 },
640 { condensed_normal_900, expanded_normal_900 },
641 { condensed_italic_100, expanded_normal_900 },
642 { condensed_italic_900, expanded_normal_900 },
643 { expanded_normal_100, expanded_normal_900 },
644 { expanded_normal_900, expanded_normal_900 },
645 { expanded_italic_100, expanded_normal_900 },
646 { expanded_italic_900, expanded_normal_900 },
647 },
648 },
649
650 {
651 { expanded_italic_100,expanded_italic_900 },
652 {
653 { condensed_normal_100, expanded_italic_100 },
654 { condensed_normal_900, expanded_italic_900 },
655 { condensed_italic_100, expanded_italic_100 },
656 { condensed_italic_900, expanded_italic_900 },
657 { expanded_normal_100, expanded_italic_100 },
658 { expanded_normal_900, expanded_italic_900 },
659 { expanded_italic_100, expanded_italic_100 },
660 { expanded_italic_900, expanded_italic_900 },
661 },
662 },
663
664 {
665 { expanded_italic_100 },
666 {
667 { condensed_normal_100, expanded_italic_100 },
668 { condensed_normal_900, expanded_italic_100 },
669 { condensed_italic_100, expanded_italic_100 },
670 { condensed_italic_900, expanded_italic_100 },
671 { expanded_normal_100, expanded_italic_100 },
672 { expanded_normal_900, expanded_italic_100 },
673 { expanded_italic_100, expanded_italic_100 },
674 { expanded_italic_900, expanded_italic_100 },
675 },
676 },
677
678 {
679 { expanded_italic_900 },
680 {
681 { condensed_normal_100, expanded_italic_900 },
682 { condensed_normal_900, expanded_italic_900 },
683 { condensed_italic_100, expanded_italic_900 },
684 { condensed_italic_900, expanded_italic_900 },
685 { expanded_normal_100, expanded_italic_900 },
686 { expanded_normal_900, expanded_italic_900 },
687 { expanded_italic_100, expanded_italic_900 },
688 { expanded_italic_900, expanded_italic_900 },
689 },
690 },
691
692 {
693 { normal_normal_100, normal_normal_900 },
694 {
695 { normal_normal_300, normal_normal_100 },
696 { normal_normal_400, normal_normal_100 },
697 { normal_normal_500, normal_normal_100 },
698 { normal_normal_600, normal_normal_900 },
699 },
700 },
701
702 {
703 { normal_normal_100, normal_normal_400, normal_normal_900 },
704 {
705 { normal_normal_300, normal_normal_100 },
706 { normal_normal_400, normal_normal_400 },
707 { normal_normal_500, normal_normal_400 },
708 { normal_normal_600, normal_normal_900 },
709 },
710 },
711
712 {
713 { normal_normal_100, normal_normal_500, normal_normal_900 },
714 {
715 { normal_normal_300, normal_normal_100 },
716 { normal_normal_400, normal_normal_500 },
717 { normal_normal_500, normal_normal_500 },
718 { normal_normal_600, normal_normal_900 },
719 },
720 },
721
722 {
723 { },
724 {
725 { normal_normal_300, invalidFontStyle },
726 { normal_normal_400, invalidFontStyle },
727 { normal_normal_500, invalidFontStyle },
728 { normal_normal_600, invalidFontStyle },
729 },
730 },
731 {
732 { expanded_normal_100,expanded_normal_900,
733 expanded_italic_100,expanded_italic_900,
734 expanded_obliqu_100,expanded_obliqu_900, },
735 {
736 { condensed_normal_100, expanded_normal_100 },
737 { condensed_normal_900, expanded_normal_900 },
738 { condensed_italic_100, expanded_italic_100 },
739 { condensed_italic_900, expanded_italic_900 },
740 { condensed_obliqu_100, expanded_obliqu_100 },
741 { condensed_obliqu_900, expanded_obliqu_900 },
742 { expanded_normal_100, expanded_normal_100 },
743 { expanded_normal_900, expanded_normal_900 },
744 { expanded_italic_100, expanded_italic_100 },
745 { expanded_italic_900, expanded_italic_900 },
746 { expanded_obliqu_100, expanded_obliqu_100 },
747 { expanded_obliqu_900, expanded_obliqu_900 },
748 },
749 },
750 {
751 { expanded_normal_100,expanded_normal_900,
752 expanded_obliqu_100,expanded_obliqu_900, },
753 {
754 { condensed_normal_100, expanded_normal_100 },
755 { condensed_normal_900, expanded_normal_900 },
756 { condensed_italic_100, expanded_obliqu_100 },
757 { condensed_italic_900, expanded_obliqu_900 },
758 { condensed_obliqu_100, expanded_obliqu_100 },
759 { condensed_obliqu_900, expanded_obliqu_900 },
760 { expanded_normal_100, expanded_normal_100 },
761 { expanded_normal_900, expanded_normal_900 },
762 { expanded_italic_100, expanded_obliqu_100 },
763 { expanded_italic_900, expanded_obliqu_900 },
764 { expanded_obliqu_100, expanded_obliqu_100 },
765 { expanded_obliqu_900, expanded_obliqu_900 },
766 },
767 },
768 {
769 { expanded_italic_100,expanded_italic_900,
770 expanded_obliqu_100,expanded_obliqu_900, },
771 {
772 { condensed_normal_100, expanded_obliqu_100 },
773 { condensed_normal_900, expanded_obliqu_900 },
774 { condensed_italic_100, expanded_italic_100 },
775 { condensed_italic_900, expanded_italic_900 },
776 { condensed_obliqu_100, expanded_obliqu_100 },
777 { condensed_obliqu_900, expanded_obliqu_900 },
778 { expanded_normal_100, expanded_obliqu_100 },
779 { expanded_normal_900, expanded_obliqu_900 },
780 { expanded_italic_100, expanded_italic_100 },
781 { expanded_italic_900, expanded_italic_900 },
782 { expanded_obliqu_100, expanded_obliqu_100 },
783 { expanded_obliqu_900, expanded_obliqu_900 },
784 },
785 },
786 };
787
788 for (StyleSetTest& test : tests) {
789 for (const StyleSetTest::Case& testCase : test.cases) {
790 sk_sp<SkTypeface> typeface(test.styleSet.matchStyle(testCase.pattern));
791 if (typeface) {
792 REPORTER_ASSERT(reporter, typeface->fontStyle() == testCase.expectedResult);
793 } else {
794 REPORTER_ASSERT(reporter, invalidFontStyle == testCase.expectedResult);
795 }
796 }
797 }
798 }
799
DEF_TEST(FontMgr_MatchCharacter,reporter)800 DEF_TEST(FontMgr_MatchCharacter, reporter) {
801 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
802 // 0xD800 <= codepoint <= 0xDFFF || 0x10FFFF < codepoint are invalid
803 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x0);
804 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xD800);
805 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xDFFF);
806 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x110000);
807 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x1FFFFF);
808 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, -1);
809 }
810