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 uint16_t 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 continue;
128 }
129 SkString name1;
130 face1->getFamilyName(&name1);
131 SkFontStyle s1 = face1->fontStyle();
132
133 SkString resource1;
134 face1->getResourceName(&resource1);
135 if (FLAGS_verboseFontMgr) {
136 SkDebugf(" \"%s\" \"%s\"\n", name1.c_str(), resource1.c_str());
137 }
138
139 // Note that fs != s1 is fine, though probably rare.
140
141 sk_sp<SkTypeface> face2(fm->matchFamilyStyle(name1.c_str(), s1));
142 if (!face2) {
143 REPORTER_ASSERT(reporter, face2.get());
144 continue;
145 }
146 SkString name2;
147 face2->getFamilyName(&name2);
148
149 REPORTER_ASSERT(reporter, name1 == name2, "%s == %s", name1.c_str(), name2.c_str());
150
151 // TODO: This should work, but Mac matches the wrong font sometimes.
152 if ((false)) {
153 SkFontStyle s2 = face2->fontStyle();
154 REPORTER_ASSERT(reporter, s1 == s2, "%s [%3d %d %d] != %s [%3d %d %d]",
155 name1.c_str(), s1.weight(), s1.width(), s1.slant(),
156 name2.c_str(), s2.weight(), s2.width(), s2.slant());
157 }
158 }
159 }
160 }
161
DEF_TEST(FontMgr_Match,reporter)162 DEF_TEST(FontMgr_Match, reporter) {
163 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
164 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily(nullptr));
165 REPORTER_ASSERT(reporter, styleSet);
166 }
167
DEF_TEST(FontMgr_MatchFamilyStyle,reporter)168 DEF_TEST(FontMgr_MatchFamilyStyle, reporter) {
169 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
170
171 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily("Non Existing Family Name"));
172 REPORTER_ASSERT(reporter, styleSet);
173 REPORTER_ASSERT(reporter, styleSet->count() == 0);
174
175 using FS = SkFontStyle;
176 sk_sp<SkTypeface> typeface(fm->matchFamilyStyle("Non Existing Family Name", FS::Normal()));
177 REPORTER_ASSERT(reporter, !typeface);
178
179 // TODO: enable after determining if a default font should be required.
180 if ((false)) {
181 sk_sp<SkTypeface> def(fm->matchFamilyStyle(nullptr, FS::Normal()));
182 REPORTER_ASSERT(reporter, def);
183 }
184 }
185
DEF_TEST(FontMgr_MatchStyleCSS3,reporter)186 DEF_TEST(FontMgr_MatchStyleCSS3, reporter) {
187 static const SkFontStyle invalidFontStyle(101, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
188
189 class TestTypeface : public SkTypeface {
190 public:
191 TestTypeface(const SkFontStyle& fontStyle) : SkTypeface(fontStyle, false){}
192 protected:
193 std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override { return nullptr; }
194 sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
195 return sk_ref_sp(this);
196 }
197 std::unique_ptr<SkScalerContext> onCreateScalerContext(
198 const SkScalerContextEffects& effects, const SkDescriptor* desc) const override
199 {
200 return SkScalerContext::MakeEmpty(
201 sk_ref_sp(const_cast<TestTypeface*>(this)), effects, desc);
202 }
203 void onFilterRec(SkScalerContextRec*) const override { }
204 std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const override {
205 return nullptr;
206 }
207 void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
208 void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const override {
209 sk_bzero(glyphs, count * sizeof(glyphs[0]));
210 }
211 int onCountGlyphs() const override { return 0; }
212 void getPostScriptGlyphNames(SkString*) const override {}
213 void getGlyphToUnicodeMap(SkUnichar*) const override {}
214 int onGetUPEM() const override { return 0; }
215 class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
216 public:
217 bool next(SkTypeface::LocalizedString*) override { return false; }
218 };
219 void onGetFamilyName(SkString* familyName) const override {
220 familyName->reset();
221 }
222 bool onGetPostScriptName(SkString*) const override { return false; }
223 SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
224 return new EmptyLocalizedStrings;
225 }
226 bool onGlyphMaskNeedsCurrentColor() const override { return false; }
227 int onGetVariationDesignPosition(
228 SkFontArguments::VariationPosition::Coordinate coordinates[],
229 int coordinateCount) const override
230 {
231 return 0;
232 }
233 int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
234 int parameterCount) const override
235 {
236 return -1;
237 }
238 int onGetTableTags(SkFontTableTag tags[]) const override { return 0; }
239 size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
240 return 0;
241 }
242 };
243
244 class TestFontStyleSet : public SkFontStyleSet {
245 public:
246 TestFontStyleSet(std::initializer_list<SkFontStyle> styles) : fStyles(styles) {}
247 int count() override { return static_cast<int>(fStyles.size()); }
248 void getStyle(int index, SkFontStyle* style, SkString*) override {
249 if (style) {
250 *style = fStyles[index];
251 }
252 }
253 sk_sp<SkTypeface> createTypeface(int index) override {
254 if (index < 0 || this->count() <= index) {
255 return sk_sp<SkTypeface>(new TestTypeface(invalidFontStyle));
256 }
257 return sk_sp<SkTypeface>(new TestTypeface(fStyles[index]));
258 }
259 sk_sp<SkTypeface> matchStyle(const SkFontStyle& pattern) override {
260 return this->matchStyleCSS3(pattern);
261 }
262 private:
263 std::vector<SkFontStyle> fStyles;
264 };
265
266 SkFontStyle condensed_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
267 SkFontStyle condensed_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
268 SkFontStyle condensed_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
269 SkFontStyle condensed_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
270 SkFontStyle condensed_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
271 SkFontStyle condensed_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
272 SkFontStyle expanded_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
273 SkFontStyle expanded_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
274 SkFontStyle expanded_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
275 SkFontStyle expanded_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
276 SkFontStyle expanded_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
277 SkFontStyle expanded_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
278
279 SkFontStyle normal_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
280 SkFontStyle normal_normal_300(SkFontStyle::kLight_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
281 SkFontStyle normal_normal_400(SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
282 SkFontStyle normal_normal_500(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
283 SkFontStyle normal_normal_600(SkFontStyle::kSemiBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
284 SkFontStyle normal_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
285
286 struct StyleSetTest {
287 TestFontStyleSet styleSet;
288 struct Case {
289 SkFontStyle pattern;
290 SkFontStyle expectedResult;
291 };
292 std::vector<Case> cases;
293 } tests[] = {
294 {
295 { normal_normal_500, normal_normal_400 },
296 {
297 { normal_normal_400, normal_normal_400 },
298 { normal_normal_500, normal_normal_500 },
299 },
300 },
301
302 {
303 { normal_normal_500, normal_normal_300 },
304 {
305 { normal_normal_300, normal_normal_300 },
306 { normal_normal_400, normal_normal_500 },
307 { normal_normal_500, normal_normal_500 },
308 },
309 },
310
311 {
312 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900,
313 expanded_normal_100, expanded_normal_900, expanded_italic_100, expanded_italic_900 },
314 {
315 { condensed_normal_100, condensed_normal_100 },
316 { condensed_normal_900, condensed_normal_900 },
317 { condensed_italic_100, condensed_italic_100 },
318 { condensed_italic_900, condensed_italic_900 },
319 { expanded_normal_100, expanded_normal_100 },
320 { expanded_normal_900, expanded_normal_900 },
321 { expanded_italic_100, expanded_italic_100 },
322 { expanded_italic_900, expanded_italic_900 },
323 },
324 },
325
326 {
327 { condensed_normal_100,condensed_italic_100,expanded_normal_100,expanded_italic_100 },
328 {
329 { condensed_normal_100, condensed_normal_100 },
330 { condensed_normal_900, condensed_normal_100 },
331 { condensed_italic_100, condensed_italic_100 },
332 { condensed_italic_900, condensed_italic_100 },
333 { expanded_normal_100, expanded_normal_100 },
334 { expanded_normal_900, expanded_normal_100 },
335 { expanded_italic_100, expanded_italic_100 },
336 { expanded_italic_900, expanded_italic_100 },
337 },
338 },
339
340 {
341 { condensed_normal_900,condensed_italic_900,expanded_normal_900,expanded_italic_900 },
342 {
343 { condensed_normal_100, condensed_normal_900 },
344 { condensed_normal_900, condensed_normal_900 },
345 { condensed_italic_100, condensed_italic_900 },
346 { condensed_italic_900, condensed_italic_900 },
347 { expanded_normal_100, expanded_normal_900 },
348 { expanded_normal_900, expanded_normal_900 },
349 { expanded_italic_100, expanded_italic_900 },
350 { expanded_italic_900, expanded_italic_900 },
351 },
352 },
353
354 {
355 { condensed_normal_100,condensed_normal_900,expanded_normal_100,expanded_normal_900 },
356 {
357 { condensed_normal_100, condensed_normal_100 },
358 { condensed_normal_900, condensed_normal_900 },
359 { condensed_italic_100, condensed_normal_100 },
360 { condensed_italic_900, condensed_normal_900 },
361 { expanded_normal_100, expanded_normal_100 },
362 { expanded_normal_900, expanded_normal_900 },
363 { expanded_italic_100, expanded_normal_100 },
364 { expanded_italic_900, expanded_normal_900 },
365 },
366 },
367
368 {
369 { condensed_normal_100,expanded_normal_100 },
370 {
371 { condensed_normal_100, condensed_normal_100 },
372 { condensed_normal_900, condensed_normal_100 },
373 { condensed_italic_100, condensed_normal_100 },
374 { condensed_italic_900, condensed_normal_100 },
375 { expanded_normal_100, expanded_normal_100 },
376 { expanded_normal_900, expanded_normal_100 },
377 { expanded_italic_100, expanded_normal_100 },
378 { expanded_italic_900, expanded_normal_100 },
379 },
380 },
381
382 {
383 { condensed_normal_900,expanded_normal_900 },
384 {
385 { condensed_normal_100, condensed_normal_900 },
386 { condensed_normal_900, condensed_normal_900 },
387 { condensed_italic_100, condensed_normal_900 },
388 { condensed_italic_900, condensed_normal_900 },
389 { expanded_normal_100, expanded_normal_900 },
390 { expanded_normal_900, expanded_normal_900 },
391 { expanded_italic_100, expanded_normal_900 },
392 { expanded_italic_900, expanded_normal_900 },
393 },
394 },
395
396 {
397 { condensed_italic_100,condensed_italic_900,expanded_italic_100,expanded_italic_900 },
398 {
399 { condensed_normal_100, condensed_italic_100 },
400 { condensed_normal_900, condensed_italic_900 },
401 { condensed_italic_100, condensed_italic_100 },
402 { condensed_italic_900, condensed_italic_900 },
403 { expanded_normal_100, expanded_italic_100 },
404 { expanded_normal_900, expanded_italic_900 },
405 { expanded_italic_100, expanded_italic_100 },
406 { expanded_italic_900, expanded_italic_900 },
407 },
408 },
409
410 {
411 { condensed_italic_100,expanded_italic_100 },
412 {
413 { condensed_normal_100, condensed_italic_100 },
414 { condensed_normal_900, condensed_italic_100 },
415 { condensed_italic_100, condensed_italic_100 },
416 { condensed_italic_900, condensed_italic_100 },
417 { expanded_normal_100, expanded_italic_100 },
418 { expanded_normal_900, expanded_italic_100 },
419 { expanded_italic_100, expanded_italic_100 },
420 { expanded_italic_900, expanded_italic_100 },
421 },
422 },
423
424 {
425 { condensed_italic_900,expanded_italic_900 },
426 {
427 { condensed_normal_100, condensed_italic_900 },
428 { condensed_normal_900, condensed_italic_900 },
429 { condensed_italic_100, condensed_italic_900 },
430 { condensed_italic_900, condensed_italic_900 },
431 { expanded_normal_100, expanded_italic_900 },
432 { expanded_normal_900, expanded_italic_900 },
433 { expanded_italic_100, expanded_italic_900 },
434 { expanded_italic_900, expanded_italic_900 },
435 },
436 },
437
438 {
439 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900 },
440 {
441 { condensed_normal_100, condensed_normal_100 },
442 { condensed_normal_900, condensed_normal_900 },
443 { condensed_italic_100, condensed_italic_100 },
444 { condensed_italic_900, condensed_italic_900 },
445 { expanded_normal_100, condensed_normal_100 },
446 { expanded_normal_900, condensed_normal_900 },
447 { expanded_italic_100, condensed_italic_100 },
448 { expanded_italic_900, condensed_italic_900 },
449 },
450 },
451
452 {
453 { condensed_normal_100,condensed_italic_100 },
454 {
455 { condensed_normal_100, condensed_normal_100 },
456 { condensed_normal_900, condensed_normal_100 },
457 { condensed_italic_100, condensed_italic_100 },
458 { condensed_italic_900, condensed_italic_100 },
459 { expanded_normal_100, condensed_normal_100 },
460 { expanded_normal_900, condensed_normal_100 },
461 { expanded_italic_100, condensed_italic_100 },
462 { expanded_italic_900, condensed_italic_100 },
463 },
464 },
465
466 {
467 { condensed_normal_900,condensed_italic_900 },
468 {
469 { condensed_normal_100, condensed_normal_900 },
470 { condensed_normal_900, condensed_normal_900 },
471 { condensed_italic_100, condensed_italic_900 },
472 { condensed_italic_900, condensed_italic_900 },
473 { expanded_normal_100, condensed_normal_900 },
474 { expanded_normal_900, condensed_normal_900 },
475 { expanded_italic_100, condensed_italic_900 },
476 { expanded_italic_900, condensed_italic_900 },
477 },
478 },
479
480 {
481 { condensed_normal_100,condensed_normal_900 },
482 {
483 { condensed_normal_100, condensed_normal_100 },
484 { condensed_normal_900, condensed_normal_900 },
485 { condensed_italic_100, condensed_normal_100 },
486 { condensed_italic_900, condensed_normal_900 },
487 { expanded_normal_100, condensed_normal_100 },
488 { expanded_normal_900, condensed_normal_900 },
489 { expanded_italic_100, condensed_normal_100 },
490 { expanded_italic_900, condensed_normal_900 },
491 },
492 },
493
494 {
495 { condensed_normal_100 },
496 {
497 { condensed_normal_100, condensed_normal_100 },
498 { condensed_normal_900, condensed_normal_100 },
499 { condensed_italic_100, condensed_normal_100 },
500 { condensed_italic_900, condensed_normal_100 },
501 { expanded_normal_100, condensed_normal_100 },
502 { expanded_normal_900, condensed_normal_100 },
503 { expanded_italic_100, condensed_normal_100 },
504 { expanded_italic_900, condensed_normal_100 },
505 },
506 },
507
508 {
509 { condensed_normal_900 },
510 {
511 { condensed_normal_100, condensed_normal_900 },
512 { condensed_normal_900, condensed_normal_900 },
513 { condensed_italic_100, condensed_normal_900 },
514 { condensed_italic_900, condensed_normal_900 },
515 { expanded_normal_100, condensed_normal_900 },
516 { expanded_normal_900, condensed_normal_900 },
517 { expanded_italic_100, condensed_normal_900 },
518 { expanded_italic_900, condensed_normal_900 },
519 },
520 },
521
522 {
523 { condensed_italic_100,condensed_italic_900 },
524 {
525 { condensed_normal_100, condensed_italic_100 },
526 { condensed_normal_900, condensed_italic_900 },
527 { condensed_italic_100, condensed_italic_100 },
528 { condensed_italic_900, condensed_italic_900 },
529 { expanded_normal_100, condensed_italic_100 },
530 { expanded_normal_900, condensed_italic_900 },
531 { expanded_italic_100, condensed_italic_100 },
532 { expanded_italic_900, condensed_italic_900 },
533 },
534 },
535
536 {
537 { condensed_italic_100 },
538 {
539 { condensed_normal_100, condensed_italic_100 },
540 { condensed_normal_900, condensed_italic_100 },
541 { condensed_italic_100, condensed_italic_100 },
542 { condensed_italic_900, condensed_italic_100 },
543 { expanded_normal_100, condensed_italic_100 },
544 { expanded_normal_900, condensed_italic_100 },
545 { expanded_italic_100, condensed_italic_100 },
546 { expanded_italic_900, condensed_italic_100 },
547 },
548 },
549
550 {
551 { condensed_italic_900 },
552 {
553 { condensed_normal_100, condensed_italic_900 },
554 { condensed_normal_900, condensed_italic_900 },
555 { condensed_italic_100, condensed_italic_900 },
556 { condensed_italic_900, condensed_italic_900 },
557 { expanded_normal_100, condensed_italic_900 },
558 { expanded_normal_900, condensed_italic_900 },
559 { expanded_italic_100, condensed_italic_900 },
560 { expanded_italic_900, condensed_italic_900 },
561 },
562 },
563
564 {
565 { expanded_normal_100,expanded_normal_900,
566 expanded_italic_100,expanded_italic_900 },
567 {
568 { condensed_normal_100, expanded_normal_100 },
569 { condensed_normal_900, expanded_normal_900 },
570 { condensed_italic_100, expanded_italic_100 },
571 { condensed_italic_900, expanded_italic_900 },
572 { condensed_obliqu_100, expanded_italic_100 },
573 { condensed_obliqu_900, expanded_italic_900 },
574 { expanded_normal_100, expanded_normal_100 },
575 { expanded_normal_900, expanded_normal_900 },
576 { expanded_italic_100, expanded_italic_100 },
577 { expanded_italic_900, expanded_italic_900 },
578 { expanded_obliqu_100, expanded_italic_100 },
579 { expanded_obliqu_900, expanded_italic_900 },
580 },
581 },
582
583 {
584 { expanded_normal_100,expanded_italic_100 },
585 {
586 { condensed_normal_100, expanded_normal_100 },
587 { condensed_normal_900, expanded_normal_100 },
588 { condensed_italic_100, expanded_italic_100 },
589 { condensed_italic_900, expanded_italic_100 },
590 { expanded_normal_100, expanded_normal_100 },
591 { expanded_normal_900, expanded_normal_100 },
592 { expanded_italic_100, expanded_italic_100 },
593 { expanded_italic_900, expanded_italic_100 },
594 },
595 },
596
597 {
598 { expanded_normal_900,expanded_italic_900 },
599 {
600 { condensed_normal_100, expanded_normal_900 },
601 { condensed_normal_900, expanded_normal_900 },
602 { condensed_italic_100, expanded_italic_900 },
603 { condensed_italic_900, expanded_italic_900 },
604 { expanded_normal_100, expanded_normal_900 },
605 { expanded_normal_900, expanded_normal_900 },
606 { expanded_italic_100, expanded_italic_900 },
607 { expanded_italic_900, expanded_italic_900 },
608 },
609 },
610
611 {
612 { expanded_normal_100,expanded_normal_900 },
613 {
614 { condensed_normal_100, expanded_normal_100 },
615 { condensed_normal_900, expanded_normal_900 },
616 { condensed_italic_100, expanded_normal_100 },
617 { condensed_italic_900, expanded_normal_900 },
618 { expanded_normal_100, expanded_normal_100 },
619 { expanded_normal_900, expanded_normal_900 },
620 { expanded_italic_100, expanded_normal_100 },
621 { expanded_italic_900, expanded_normal_900 },
622 },
623 },
624
625 {
626 { expanded_normal_100 },
627 {
628 { condensed_normal_100, expanded_normal_100 },
629 { condensed_normal_900, expanded_normal_100 },
630 { condensed_italic_100, expanded_normal_100 },
631 { condensed_italic_900, expanded_normal_100 },
632 { expanded_normal_100, expanded_normal_100 },
633 { expanded_normal_900, expanded_normal_100 },
634 { expanded_italic_100, expanded_normal_100 },
635 { expanded_italic_900, expanded_normal_100 },
636 },
637 },
638
639 {
640 { expanded_normal_900 },
641 {
642 { condensed_normal_100, expanded_normal_900 },
643 { condensed_normal_900, expanded_normal_900 },
644 { condensed_italic_100, expanded_normal_900 },
645 { condensed_italic_900, expanded_normal_900 },
646 { expanded_normal_100, expanded_normal_900 },
647 { expanded_normal_900, expanded_normal_900 },
648 { expanded_italic_100, expanded_normal_900 },
649 { expanded_italic_900, expanded_normal_900 },
650 },
651 },
652
653 {
654 { expanded_italic_100,expanded_italic_900 },
655 {
656 { condensed_normal_100, expanded_italic_100 },
657 { condensed_normal_900, expanded_italic_900 },
658 { condensed_italic_100, expanded_italic_100 },
659 { condensed_italic_900, expanded_italic_900 },
660 { expanded_normal_100, expanded_italic_100 },
661 { expanded_normal_900, expanded_italic_900 },
662 { expanded_italic_100, expanded_italic_100 },
663 { expanded_italic_900, expanded_italic_900 },
664 },
665 },
666
667 {
668 { expanded_italic_100 },
669 {
670 { condensed_normal_100, expanded_italic_100 },
671 { condensed_normal_900, expanded_italic_100 },
672 { condensed_italic_100, expanded_italic_100 },
673 { condensed_italic_900, expanded_italic_100 },
674 { expanded_normal_100, expanded_italic_100 },
675 { expanded_normal_900, expanded_italic_100 },
676 { expanded_italic_100, expanded_italic_100 },
677 { expanded_italic_900, expanded_italic_100 },
678 },
679 },
680
681 {
682 { expanded_italic_900 },
683 {
684 { condensed_normal_100, expanded_italic_900 },
685 { condensed_normal_900, expanded_italic_900 },
686 { condensed_italic_100, expanded_italic_900 },
687 { condensed_italic_900, expanded_italic_900 },
688 { expanded_normal_100, expanded_italic_900 },
689 { expanded_normal_900, expanded_italic_900 },
690 { expanded_italic_100, expanded_italic_900 },
691 { expanded_italic_900, expanded_italic_900 },
692 },
693 },
694
695 {
696 { normal_normal_100, normal_normal_900 },
697 {
698 { normal_normal_300, normal_normal_100 },
699 { normal_normal_400, normal_normal_100 },
700 { normal_normal_500, normal_normal_100 },
701 { normal_normal_600, normal_normal_900 },
702 },
703 },
704
705 {
706 { normal_normal_100, normal_normal_400, normal_normal_900 },
707 {
708 { normal_normal_300, normal_normal_100 },
709 { normal_normal_400, normal_normal_400 },
710 { normal_normal_500, normal_normal_400 },
711 { normal_normal_600, normal_normal_900 },
712 },
713 },
714
715 {
716 { normal_normal_100, normal_normal_500, normal_normal_900 },
717 {
718 { normal_normal_300, normal_normal_100 },
719 { normal_normal_400, normal_normal_500 },
720 { normal_normal_500, normal_normal_500 },
721 { normal_normal_600, normal_normal_900 },
722 },
723 },
724
725 {
726 { },
727 {
728 { normal_normal_300, invalidFontStyle },
729 { normal_normal_400, invalidFontStyle },
730 { normal_normal_500, invalidFontStyle },
731 { normal_normal_600, invalidFontStyle },
732 },
733 },
734 {
735 { expanded_normal_100,expanded_normal_900,
736 expanded_italic_100,expanded_italic_900,
737 expanded_obliqu_100,expanded_obliqu_900, },
738 {
739 { condensed_normal_100, expanded_normal_100 },
740 { condensed_normal_900, expanded_normal_900 },
741 { condensed_italic_100, expanded_italic_100 },
742 { condensed_italic_900, expanded_italic_900 },
743 { condensed_obliqu_100, expanded_obliqu_100 },
744 { condensed_obliqu_900, expanded_obliqu_900 },
745 { expanded_normal_100, expanded_normal_100 },
746 { expanded_normal_900, expanded_normal_900 },
747 { expanded_italic_100, expanded_italic_100 },
748 { expanded_italic_900, expanded_italic_900 },
749 { expanded_obliqu_100, expanded_obliqu_100 },
750 { expanded_obliqu_900, expanded_obliqu_900 },
751 },
752 },
753 {
754 { expanded_normal_100,expanded_normal_900,
755 expanded_obliqu_100,expanded_obliqu_900, },
756 {
757 { condensed_normal_100, expanded_normal_100 },
758 { condensed_normal_900, expanded_normal_900 },
759 { condensed_italic_100, expanded_obliqu_100 },
760 { condensed_italic_900, expanded_obliqu_900 },
761 { condensed_obliqu_100, expanded_obliqu_100 },
762 { condensed_obliqu_900, expanded_obliqu_900 },
763 { expanded_normal_100, expanded_normal_100 },
764 { expanded_normal_900, expanded_normal_900 },
765 { expanded_italic_100, expanded_obliqu_100 },
766 { expanded_italic_900, expanded_obliqu_900 },
767 { expanded_obliqu_100, expanded_obliqu_100 },
768 { expanded_obliqu_900, expanded_obliqu_900 },
769 },
770 },
771 {
772 { expanded_italic_100,expanded_italic_900,
773 expanded_obliqu_100,expanded_obliqu_900, },
774 {
775 { condensed_normal_100, expanded_obliqu_100 },
776 { condensed_normal_900, expanded_obliqu_900 },
777 { condensed_italic_100, expanded_italic_100 },
778 { condensed_italic_900, expanded_italic_900 },
779 { condensed_obliqu_100, expanded_obliqu_100 },
780 { condensed_obliqu_900, expanded_obliqu_900 },
781 { expanded_normal_100, expanded_obliqu_100 },
782 { expanded_normal_900, expanded_obliqu_900 },
783 { expanded_italic_100, expanded_italic_100 },
784 { expanded_italic_900, expanded_italic_900 },
785 { expanded_obliqu_100, expanded_obliqu_100 },
786 { expanded_obliqu_900, expanded_obliqu_900 },
787 },
788 },
789 };
790
791 for (StyleSetTest& test : tests) {
792 for (const StyleSetTest::Case& testCase : test.cases) {
793 sk_sp<SkTypeface> typeface(test.styleSet.matchStyle(testCase.pattern));
794 if (typeface) {
795 REPORTER_ASSERT(reporter, typeface->fontStyle() == testCase.expectedResult);
796 } else {
797 REPORTER_ASSERT(reporter, invalidFontStyle == testCase.expectedResult);
798 }
799 }
800 }
801 }
802
DEF_TEST(FontMgr_MatchCharacter,reporter)803 DEF_TEST(FontMgr_MatchCharacter, reporter) {
804 sk_sp<SkFontMgr> fm(ToolUtils::TestFontMgr());
805 // 0xD800 <= codepoint <= 0xDFFF || 0x10FFFF < codepoint are invalid
806 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x0);
807 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xD800);
808 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xDFFF);
809 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x110000);
810 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x1FFFFF);
811 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, -1);
812 }
813