Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Functions | Variables
FontMgrTest.cpp File Reference
#include "include/core/SkFont.h"
#include "include/core/SkFontArguments.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkFontParameters.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMalloc.h"
#include "src/core/SkAdvancedTypefaceMetrics.h"
#include "src/core/SkScalerContext.h"
#include "tests/Test.h"
#include "tools/flags/CommandLineFlags.h"
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <memory>
#include <vector>

Go to the source code of this file.

Functions

 DECLARE_bool (verboseFontMgr) DEF_TEST(FontMgr_Font
 
 REPORTER_ASSERT (reporter, 24==font.getSize())
 
 REPORTER_ASSERT (reporter, 1==font.getScaleX())
 
 REPORTER_ASSERT (reporter, 0==font.getSkewX())
 
 sk_bzero (glyphs, sizeof(glyphs))
 
 REPORTER_ASSERT (reporter, 5==count)
 
 for (const auto glyph :glyphs)
 
 SkAssertResult (font.textToGlyphs("Hello", 5, SkTextEncoding::kUTF8, glyphs, std::size(glyphs))==count)
 
 for (int i=0;i< count;++i)
 
 REPORTER_ASSERT (reporter, glyphs[0] !=glyphs[1])
 
 REPORTER_ASSERT (reporter, glyphs[2]==glyphs[3])
 
const SkFont newFont (font.makeWithSize(36))
 
 REPORTER_ASSERT (reporter, font.getTypefaceOrDefault()==newFont.getTypefaceOrDefault())
 
 REPORTER_ASSERT (reporter, 36==newFont.getSize())
 
 DEF_TEST (FontMgr_AliasNames, reporter)
 
 DEF_TEST (FontMgr_Iter, reporter)
 
 DEF_TEST (FontMgr_Match, reporter)
 
 DEF_TEST (FontMgr_MatchFamilyStyle, reporter)
 
 DEF_TEST (FontMgr_MatchStyleCSS3, reporter)
 
 DEF_TEST (FontMgr_MatchCharacter, reporter)
 

Variables

 reporter
 
uint16_t glyphs [5]
 
int count = font.textToGlyphs("Hello", 5, SkTextEncoding::kUTF8, glyphs, 2)
 

Function Documentation

◆ DECLARE_bool()

DECLARE_bool ( verboseFontMgr  )

◆ DEF_TEST() [1/6]

DEF_TEST ( FontMgr_AliasNames  ,
reporter   
)

Definition at line 73 of file FontMgrTest.cpp.

73 {
74 const char* inNames[] = {
75 "sans", "sans-serif", "serif", "monospace", "times", "helvetica"
76 };
77
78 for (size_t i = 0; i < std::size(inNames); ++i) {
79 sk_sp<SkTypeface> first(SkTypeface::MakeFromName(inNames[i], SkFontStyle()));
80 if (nullptr == first.get()) {
81 continue;
82 }
83 SkString firstName;
84 first->getFamilyName(&firstName);
85 for (int j = 0; j < 10; ++j) {
86 sk_sp<SkTypeface> face(SkTypeface::MakeFromName(inNames[i], SkFontStyle()));
87
88 SkString name;
89 face->getFamilyName(&name);
90 REPORTER_ASSERT(reporter, first->uniqueID() == face->uniqueID(),
91 "Request \"%s\" First Name: \"%s\" Id: %x Received Name \"%s\" Id %x",
92 inNames[i], firstName.c_str(), first->uniqueID(), name.c_str(), face->uniqueID());
93 }
94 }
95}
reporter
reporter
Definition: FontMgrTest.cpp:37
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition: Test.h:281
SkString::c_str
const char * c_str() const
Definition: SkString.h:133
SkTypeface::MakeFromName
static sk_sp< SkTypeface > MakeFromName(const char familyName[], SkFontStyle fontStyle)
Definition: SkTypeface.cpp:207
sk_sp
Definition: SkRefCnt.h:220
name
const char * name
Definition: fuchsia.cc:50

◆ DEF_TEST() [2/6]

DEF_TEST ( FontMgr_Iter  ,
reporter   
)

Definition at line 97 of file FontMgrTest.cpp.

97 {
98 sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
99 int count = fm->countFamilies();
100
101 for (int i = 0; i < count; ++i) {
102 SkString fname;
103 fm->getFamilyName(i, &fname);
104
105 sk_sp<SkFontStyleSet> fnset(fm->matchFamily(fname.c_str()));
106 sk_sp<SkFontStyleSet> set(fm->createStyleSet(i));
107 REPORTER_ASSERT(reporter, fnset->count() == set->count());
108
109 if (FLAGS_verboseFontMgr) {
110 SkDebugf("[%2d] %s\n", i, fname.c_str());
111 }
112
113 for (int j = 0; j < set->count(); ++j) {
114 SkString sname;
115 SkFontStyle fs;
116 set->getStyle(j, &fs, &sname);
117
118 if (FLAGS_verboseFontMgr) {
119 SkDebugf("\t[%d] %s [%3d %d %d]\n", j, sname.c_str(),
120 fs.weight(), fs.width(), fs.slant());
121 }
122
123 sk_sp<SkTypeface> face1(set->createTypeface(j));
124 if (!face1) {
125 REPORTER_ASSERT(reporter, face1.get());
126 continue;
127 }
128 SkString name1;
129 face1->getFamilyName(&name1);
130 SkFontStyle s1 = face1->fontStyle();
131
132 // Note that fs != s1 is fine, though probably rare.
133
134 sk_sp<SkTypeface> face2(fm->matchFamilyStyle(name1.c_str(), s1));
135 if (!face2) {
136 REPORTER_ASSERT(reporter, face2.get());
137 continue;
138 }
139 SkString name2;
140 face2->getFamilyName(&name2);
141
142 REPORTER_ASSERT(reporter, name1 == name2, "%s == %s", name1.c_str(), name2.c_str());
143
144 // TODO: This should work, but Mac matches the wrong font sometimes.
145 if ((false)) {
146 SkFontStyle s2 = face2->fontStyle();
147 REPORTER_ASSERT(reporter, s1 == s2, "%s [%3d %d %d] != %s [%3d %d %d]",
148 name1.c_str(), s1.weight(), s1.width(), s1.slant(),
149 name2.c_str(), s2.weight(), s2.width(), s2.slant());
150 }
151 }
152 }
153}
count
int count
Definition: FontMgrTest.cpp:49
SkDebugf
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
SkFontMgr::RefDefault
static sk_sp< SkFontMgr > RefDefault()
Definition: SkFontMgr.cpp:163
SkFontStyle::slant
Slant slant() const
Definition: SkFontStyle.h:64
SkFontStyle::width
int width() const
Definition: SkFontStyle.h:63
SkFontStyle::weight
int weight() const
Definition: SkFontStyle.h:62
flutter::set
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not set
Definition: switches.h:76

◆ DEF_TEST() [3/6]

DEF_TEST ( FontMgr_Match  ,
reporter   
)

Definition at line 155 of file FontMgrTest.cpp.

155 {
156 sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
157 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily(nullptr));
158 REPORTER_ASSERT(reporter, styleSet);
159}

◆ DEF_TEST() [4/6]

DEF_TEST ( FontMgr_MatchCharacter  ,
reporter   
)

Definition at line 796 of file FontMgrTest.cpp.

796 {
797 sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
798 // 0xD800 <= codepoint <= 0xDFFF || 0x10FFFF < codepoint are invalid
799 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x0);
800 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xD800);
801 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0xDFFF);
802 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x110000);
803 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, 0x1FFFFF);
804 fm->matchFamilyStyleCharacter("Blah", SkFontStyle::Normal(), nullptr, 0, -1);
805}
SkFontStyle::Normal
static constexpr SkFontStyle Normal()
Definition: SkFontStyle.h:66

◆ DEF_TEST() [5/6]

DEF_TEST ( FontMgr_MatchFamilyStyle  ,
reporter   
)

Definition at line 161 of file FontMgrTest.cpp.

161 {
162 sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
163
164 sk_sp<SkFontStyleSet> styleSet(fm->matchFamily("Non Existing Family Name"));
165 REPORTER_ASSERT(reporter, styleSet);
166 REPORTER_ASSERT(reporter, styleSet->count() == 0);
167
168 using FS = SkFontStyle;
169 sk_sp<SkTypeface> typeface(fm->matchFamilyStyle("Non Existing Family Name", FS::Normal()));
170 REPORTER_ASSERT(reporter, !typeface);
171
172 // TODO: enable after determining if a default font should be required.
173 if ((false)) {
174 sk_sp<SkTypeface> def(fm->matchFamilyStyle(nullptr, FS::Normal()));
175 REPORTER_ASSERT(reporter, def);
176 }
177}

◆ DEF_TEST() [6/6]

DEF_TEST ( FontMgr_MatchStyleCSS3  ,
reporter   
)

Definition at line 179 of file FontMgrTest.cpp.

179 {
180 static const SkFontStyle invalidFontStyle(101, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
181
182 class TestTypeface : public SkTypeface {
183 public:
184 TestTypeface(const SkFontStyle& fontStyle) : SkTypeface(fontStyle, false){}
185 protected:
186 std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override { return nullptr; }
187 sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
188 return sk_ref_sp(this);
189 }
190 std::unique_ptr<SkScalerContext> onCreateScalerContext(
191 const SkScalerContextEffects& effects, const SkDescriptor* desc) const override
192 {
193 return SkScalerContext::MakeEmpty(
194 sk_ref_sp(const_cast<TestTypeface*>(this)), effects, desc);
195 }
196 void onFilterRec(SkScalerContextRec*) const override { }
197 std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const override {
198 return nullptr;
199 }
200 void onGetFontDescriptor(SkFontDescriptor*, bool*) const override { }
201 void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const override {
202 sk_bzero(glyphs, count * sizeof(glyphs[0]));
203 }
204 int onCountGlyphs() const override { return 0; }
205 void getPostScriptGlyphNames(SkString*) const override {}
206 void getGlyphToUnicodeMap(SkUnichar*) const override {}
207 int onGetUPEM() const override { return 0; }
208 class EmptyLocalizedStrings : public SkTypeface::LocalizedStrings {
209 public:
210 bool next(SkTypeface::LocalizedString*) override { return false; }
211 };
212 void onGetFamilyName(SkString* familyName) const override {
213 familyName->reset();
214 }
215 bool onGetPostScriptName(SkString*) const override { return false; }
216 SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {
217 return new EmptyLocalizedStrings;
218 }
219 bool onGlyphMaskNeedsCurrentColor() const override { return false; }
220 int onGetVariationDesignPosition(
221 SkFontArguments::VariationPosition::Coordinate coordinates[],
222 int coordinateCount) const override
223 {
224 return 0;
225 }
226 int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],
227 int parameterCount) const override
228 {
229 return -1;
230 }
231 int onGetTableTags(SkFontTableTag tags[]) const override { return 0; }
232 size_t onGetTableData(SkFontTableTag, size_t, size_t, void*) const override {
233 return 0;
234 }
235 };
236
237 class TestFontStyleSet : public SkFontStyleSet {
238 public:
239 TestFontStyleSet(std::initializer_list<SkFontStyle> styles) : fStyles(styles) {}
240 int count() override { return static_cast<int>(fStyles.size()); }
241 void getStyle(int index, SkFontStyle* style, SkString*) override {
242 if (style) {
243 *style = fStyles[index];
244 }
245 }
246 sk_sp<SkTypeface> createTypeface(int index) override {
247 if (index < 0 || this->count() <= index) {
248 return sk_sp<SkTypeface>(new TestTypeface(invalidFontStyle));
249 }
250 return sk_sp<SkTypeface>(new TestTypeface(fStyles[index]));
251 }
252 sk_sp<SkTypeface> matchStyle(const SkFontStyle& pattern) override {
253 return this->matchStyleCSS3(pattern);
254 }
255 private:
256 std::vector<SkFontStyle> fStyles;
257 };
258
259 SkFontStyle condensed_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
260 SkFontStyle condensed_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kUpright_Slant);
261 SkFontStyle condensed_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
262 SkFontStyle condensed_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kItalic_Slant);
263 SkFontStyle condensed_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
264 SkFontStyle condensed_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kCondensed_Width, SkFontStyle::kOblique_Slant);
265 SkFontStyle expanded_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
266 SkFontStyle expanded_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kUpright_Slant);
267 SkFontStyle expanded_italic_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
268 SkFontStyle expanded_italic_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kItalic_Slant);
269 SkFontStyle expanded_obliqu_100(SkFontStyle::kThin_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
270 SkFontStyle expanded_obliqu_900(SkFontStyle::kBlack_Weight, SkFontStyle::kExpanded_Width, SkFontStyle::kOblique_Slant);
271
272 SkFontStyle normal_normal_100(SkFontStyle::kThin_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
273 SkFontStyle normal_normal_300(SkFontStyle::kLight_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
274 SkFontStyle normal_normal_400(SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
275 SkFontStyle normal_normal_500(SkFontStyle::kMedium_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
276 SkFontStyle normal_normal_600(SkFontStyle::kSemiBold_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
277 SkFontStyle normal_normal_900(SkFontStyle::kBlack_Weight, SkFontStyle::kNormal_Width, SkFontStyle::kUpright_Slant);
278
279 struct StyleSetTest {
280 TestFontStyleSet styleSet;
281 struct Case {
282 SkFontStyle pattern;
283 SkFontStyle expectedResult;
284 };
285 std::vector<Case> cases;
286 } tests[] = {
287 {
288 { normal_normal_500, normal_normal_400 },
289 {
290 { normal_normal_400, normal_normal_400 },
291 { normal_normal_500, normal_normal_500 },
292 },
293 },
294
295 {
296 { normal_normal_500, normal_normal_300 },
297 {
298 { normal_normal_300, normal_normal_300 },
299 { normal_normal_400, normal_normal_500 },
300 { normal_normal_500, normal_normal_500 },
301 },
302 },
303
304 {
305 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900,
306 expanded_normal_100, expanded_normal_900, expanded_italic_100, expanded_italic_900 },
307 {
308 { condensed_normal_100, condensed_normal_100 },
309 { condensed_normal_900, condensed_normal_900 },
310 { condensed_italic_100, condensed_italic_100 },
311 { condensed_italic_900, condensed_italic_900 },
312 { expanded_normal_100, expanded_normal_100 },
313 { expanded_normal_900, expanded_normal_900 },
314 { expanded_italic_100, expanded_italic_100 },
315 { expanded_italic_900, expanded_italic_900 },
316 },
317 },
318
319 {
320 { condensed_normal_100,condensed_italic_100,expanded_normal_100,expanded_italic_100 },
321 {
322 { condensed_normal_100, condensed_normal_100 },
323 { condensed_normal_900, condensed_normal_100 },
324 { condensed_italic_100, condensed_italic_100 },
325 { condensed_italic_900, condensed_italic_100 },
326 { expanded_normal_100, expanded_normal_100 },
327 { expanded_normal_900, expanded_normal_100 },
328 { expanded_italic_100, expanded_italic_100 },
329 { expanded_italic_900, expanded_italic_100 },
330 },
331 },
332
333 {
334 { condensed_normal_900,condensed_italic_900,expanded_normal_900,expanded_italic_900 },
335 {
336 { condensed_normal_100, condensed_normal_900 },
337 { condensed_normal_900, condensed_normal_900 },
338 { condensed_italic_100, condensed_italic_900 },
339 { condensed_italic_900, condensed_italic_900 },
340 { expanded_normal_100, expanded_normal_900 },
341 { expanded_normal_900, expanded_normal_900 },
342 { expanded_italic_100, expanded_italic_900 },
343 { expanded_italic_900, expanded_italic_900 },
344 },
345 },
346
347 {
348 { condensed_normal_100,condensed_normal_900,expanded_normal_100,expanded_normal_900 },
349 {
350 { condensed_normal_100, condensed_normal_100 },
351 { condensed_normal_900, condensed_normal_900 },
352 { condensed_italic_100, condensed_normal_100 },
353 { condensed_italic_900, condensed_normal_900 },
354 { expanded_normal_100, expanded_normal_100 },
355 { expanded_normal_900, expanded_normal_900 },
356 { expanded_italic_100, expanded_normal_100 },
357 { expanded_italic_900, expanded_normal_900 },
358 },
359 },
360
361 {
362 { condensed_normal_100,expanded_normal_100 },
363 {
364 { condensed_normal_100, condensed_normal_100 },
365 { condensed_normal_900, condensed_normal_100 },
366 { condensed_italic_100, condensed_normal_100 },
367 { condensed_italic_900, condensed_normal_100 },
368 { expanded_normal_100, expanded_normal_100 },
369 { expanded_normal_900, expanded_normal_100 },
370 { expanded_italic_100, expanded_normal_100 },
371 { expanded_italic_900, expanded_normal_100 },
372 },
373 },
374
375 {
376 { condensed_normal_900,expanded_normal_900 },
377 {
378 { condensed_normal_100, condensed_normal_900 },
379 { condensed_normal_900, condensed_normal_900 },
380 { condensed_italic_100, condensed_normal_900 },
381 { condensed_italic_900, condensed_normal_900 },
382 { expanded_normal_100, expanded_normal_900 },
383 { expanded_normal_900, expanded_normal_900 },
384 { expanded_italic_100, expanded_normal_900 },
385 { expanded_italic_900, expanded_normal_900 },
386 },
387 },
388
389 {
390 { condensed_italic_100,condensed_italic_900,expanded_italic_100,expanded_italic_900 },
391 {
392 { condensed_normal_100, condensed_italic_100 },
393 { condensed_normal_900, condensed_italic_900 },
394 { condensed_italic_100, condensed_italic_100 },
395 { condensed_italic_900, condensed_italic_900 },
396 { expanded_normal_100, expanded_italic_100 },
397 { expanded_normal_900, expanded_italic_900 },
398 { expanded_italic_100, expanded_italic_100 },
399 { expanded_italic_900, expanded_italic_900 },
400 },
401 },
402
403 {
404 { condensed_italic_100,expanded_italic_100 },
405 {
406 { condensed_normal_100, condensed_italic_100 },
407 { condensed_normal_900, condensed_italic_100 },
408 { condensed_italic_100, condensed_italic_100 },
409 { condensed_italic_900, condensed_italic_100 },
410 { expanded_normal_100, expanded_italic_100 },
411 { expanded_normal_900, expanded_italic_100 },
412 { expanded_italic_100, expanded_italic_100 },
413 { expanded_italic_900, expanded_italic_100 },
414 },
415 },
416
417 {
418 { condensed_italic_900,expanded_italic_900 },
419 {
420 { condensed_normal_100, condensed_italic_900 },
421 { condensed_normal_900, condensed_italic_900 },
422 { condensed_italic_100, condensed_italic_900 },
423 { condensed_italic_900, condensed_italic_900 },
424 { expanded_normal_100, expanded_italic_900 },
425 { expanded_normal_900, expanded_italic_900 },
426 { expanded_italic_100, expanded_italic_900 },
427 { expanded_italic_900, expanded_italic_900 },
428 },
429 },
430
431 {
432 { condensed_normal_100,condensed_normal_900,condensed_italic_100,condensed_italic_900 },
433 {
434 { condensed_normal_100, condensed_normal_100 },
435 { condensed_normal_900, condensed_normal_900 },
436 { condensed_italic_100, condensed_italic_100 },
437 { condensed_italic_900, condensed_italic_900 },
438 { expanded_normal_100, condensed_normal_100 },
439 { expanded_normal_900, condensed_normal_900 },
440 { expanded_italic_100, condensed_italic_100 },
441 { expanded_italic_900, condensed_italic_900 },
442 },
443 },
444
445 {
446 { condensed_normal_100,condensed_italic_100 },
447 {
448 { condensed_normal_100, condensed_normal_100 },
449 { condensed_normal_900, condensed_normal_100 },
450 { condensed_italic_100, condensed_italic_100 },
451 { condensed_italic_900, condensed_italic_100 },
452 { expanded_normal_100, condensed_normal_100 },
453 { expanded_normal_900, condensed_normal_100 },
454 { expanded_italic_100, condensed_italic_100 },
455 { expanded_italic_900, condensed_italic_100 },
456 },
457 },
458
459 {
460 { condensed_normal_900,condensed_italic_900 },
461 {
462 { condensed_normal_100, condensed_normal_900 },
463 { condensed_normal_900, condensed_normal_900 },
464 { condensed_italic_100, condensed_italic_900 },
465 { condensed_italic_900, condensed_italic_900 },
466 { expanded_normal_100, condensed_normal_900 },
467 { expanded_normal_900, condensed_normal_900 },
468 { expanded_italic_100, condensed_italic_900 },
469 { expanded_italic_900, condensed_italic_900 },
470 },
471 },
472
473 {
474 { condensed_normal_100,condensed_normal_900 },
475 {
476 { condensed_normal_100, condensed_normal_100 },
477 { condensed_normal_900, condensed_normal_900 },
478 { condensed_italic_100, condensed_normal_100 },
479 { condensed_italic_900, condensed_normal_900 },
480 { expanded_normal_100, condensed_normal_100 },
481 { expanded_normal_900, condensed_normal_900 },
482 { expanded_italic_100, condensed_normal_100 },
483 { expanded_italic_900, condensed_normal_900 },
484 },
485 },
486
487 {
488 { condensed_normal_100 },
489 {
490 { condensed_normal_100, condensed_normal_100 },
491 { condensed_normal_900, condensed_normal_100 },
492 { condensed_italic_100, condensed_normal_100 },
493 { condensed_italic_900, condensed_normal_100 },
494 { expanded_normal_100, condensed_normal_100 },
495 { expanded_normal_900, condensed_normal_100 },
496 { expanded_italic_100, condensed_normal_100 },
497 { expanded_italic_900, condensed_normal_100 },
498 },
499 },
500
501 {
502 { condensed_normal_900 },
503 {
504 { condensed_normal_100, condensed_normal_900 },
505 { condensed_normal_900, condensed_normal_900 },
506 { condensed_italic_100, condensed_normal_900 },
507 { condensed_italic_900, condensed_normal_900 },
508 { expanded_normal_100, condensed_normal_900 },
509 { expanded_normal_900, condensed_normal_900 },
510 { expanded_italic_100, condensed_normal_900 },
511 { expanded_italic_900, condensed_normal_900 },
512 },
513 },
514
515 {
516 { condensed_italic_100,condensed_italic_900 },
517 {
518 { condensed_normal_100, condensed_italic_100 },
519 { condensed_normal_900, condensed_italic_900 },
520 { condensed_italic_100, condensed_italic_100 },
521 { condensed_italic_900, condensed_italic_900 },
522 { expanded_normal_100, condensed_italic_100 },
523 { expanded_normal_900, condensed_italic_900 },
524 { expanded_italic_100, condensed_italic_100 },
525 { expanded_italic_900, condensed_italic_900 },
526 },
527 },
528
529 {
530 { condensed_italic_100 },
531 {
532 { condensed_normal_100, condensed_italic_100 },
533 { condensed_normal_900, condensed_italic_100 },
534 { condensed_italic_100, condensed_italic_100 },
535 { condensed_italic_900, condensed_italic_100 },
536 { expanded_normal_100, condensed_italic_100 },
537 { expanded_normal_900, condensed_italic_100 },
538 { expanded_italic_100, condensed_italic_100 },
539 { expanded_italic_900, condensed_italic_100 },
540 },
541 },
542
543 {
544 { condensed_italic_900 },
545 {
546 { condensed_normal_100, condensed_italic_900 },
547 { condensed_normal_900, condensed_italic_900 },
548 { condensed_italic_100, condensed_italic_900 },
549 { condensed_italic_900, condensed_italic_900 },
550 { expanded_normal_100, condensed_italic_900 },
551 { expanded_normal_900, condensed_italic_900 },
552 { expanded_italic_100, condensed_italic_900 },
553 { expanded_italic_900, condensed_italic_900 },
554 },
555 },
556
557 {
558 { expanded_normal_100,expanded_normal_900,
559 expanded_italic_100,expanded_italic_900 },
560 {
561 { condensed_normal_100, expanded_normal_100 },
562 { condensed_normal_900, expanded_normal_900 },
563 { condensed_italic_100, expanded_italic_100 },
564 { condensed_italic_900, expanded_italic_900 },
565 { condensed_obliqu_100, expanded_italic_100 },
566 { condensed_obliqu_900, expanded_italic_900 },
567 { expanded_normal_100, expanded_normal_100 },
568 { expanded_normal_900, expanded_normal_900 },
569 { expanded_italic_100, expanded_italic_100 },
570 { expanded_italic_900, expanded_italic_900 },
571 { expanded_obliqu_100, expanded_italic_100 },
572 { expanded_obliqu_900, expanded_italic_900 },
573 },
574 },
575
576 {
577 { expanded_normal_100,expanded_italic_100 },
578 {
579 { condensed_normal_100, expanded_normal_100 },
580 { condensed_normal_900, expanded_normal_100 },
581 { condensed_italic_100, expanded_italic_100 },
582 { condensed_italic_900, expanded_italic_100 },
583 { expanded_normal_100, expanded_normal_100 },
584 { expanded_normal_900, expanded_normal_100 },
585 { expanded_italic_100, expanded_italic_100 },
586 { expanded_italic_900, expanded_italic_100 },
587 },
588 },
589
590 {
591 { expanded_normal_900,expanded_italic_900 },
592 {
593 { condensed_normal_100, expanded_normal_900 },
594 { condensed_normal_900, expanded_normal_900 },
595 { condensed_italic_100, expanded_italic_900 },
596 { condensed_italic_900, expanded_italic_900 },
597 { expanded_normal_100, expanded_normal_900 },
598 { expanded_normal_900, expanded_normal_900 },
599 { expanded_italic_100, expanded_italic_900 },
600 { expanded_italic_900, expanded_italic_900 },
601 },
602 },
603
604 {
605 { expanded_normal_100,expanded_normal_900 },
606 {
607 { condensed_normal_100, expanded_normal_100 },
608 { condensed_normal_900, expanded_normal_900 },
609 { condensed_italic_100, expanded_normal_100 },
610 { condensed_italic_900, expanded_normal_900 },
611 { expanded_normal_100, expanded_normal_100 },
612 { expanded_normal_900, expanded_normal_900 },
613 { expanded_italic_100, expanded_normal_100 },
614 { expanded_italic_900, expanded_normal_900 },
615 },
616 },
617
618 {
619 { expanded_normal_100 },
620 {
621 { condensed_normal_100, expanded_normal_100 },
622 { condensed_normal_900, expanded_normal_100 },
623 { condensed_italic_100, expanded_normal_100 },
624 { condensed_italic_900, expanded_normal_100 },
625 { expanded_normal_100, expanded_normal_100 },
626 { expanded_normal_900, expanded_normal_100 },
627 { expanded_italic_100, expanded_normal_100 },
628 { expanded_italic_900, expanded_normal_100 },
629 },
630 },
631
632 {
633 { expanded_normal_900 },
634 {
635 { condensed_normal_100, expanded_normal_900 },
636 { condensed_normal_900, expanded_normal_900 },
637 { condensed_italic_100, expanded_normal_900 },
638 { condensed_italic_900, expanded_normal_900 },
639 { expanded_normal_100, expanded_normal_900 },
640 { expanded_normal_900, expanded_normal_900 },
641 { expanded_italic_100, expanded_normal_900 },
642 { expanded_italic_900, expanded_normal_900 },
643 },
644 },
645
646 {
647 { expanded_italic_100,expanded_italic_900 },
648 {
649 { condensed_normal_100, expanded_italic_100 },
650 { condensed_normal_900, expanded_italic_900 },
651 { condensed_italic_100, expanded_italic_100 },
652 { condensed_italic_900, expanded_italic_900 },
653 { expanded_normal_100, expanded_italic_100 },
654 { expanded_normal_900, expanded_italic_900 },
655 { expanded_italic_100, expanded_italic_100 },
656 { expanded_italic_900, expanded_italic_900 },
657 },
658 },
659
660 {
661 { expanded_italic_100 },
662 {
663 { condensed_normal_100, expanded_italic_100 },
664 { condensed_normal_900, expanded_italic_100 },
665 { condensed_italic_100, expanded_italic_100 },
666 { condensed_italic_900, expanded_italic_100 },
667 { expanded_normal_100, expanded_italic_100 },
668 { expanded_normal_900, expanded_italic_100 },
669 { expanded_italic_100, expanded_italic_100 },
670 { expanded_italic_900, expanded_italic_100 },
671 },
672 },
673
674 {
675 { expanded_italic_900 },
676 {
677 { condensed_normal_100, expanded_italic_900 },
678 { condensed_normal_900, expanded_italic_900 },
679 { condensed_italic_100, expanded_italic_900 },
680 { condensed_italic_900, expanded_italic_900 },
681 { expanded_normal_100, expanded_italic_900 },
682 { expanded_normal_900, expanded_italic_900 },
683 { expanded_italic_100, expanded_italic_900 },
684 { expanded_italic_900, expanded_italic_900 },
685 },
686 },
687
688 {
689 { normal_normal_100, normal_normal_900 },
690 {
691 { normal_normal_300, normal_normal_100 },
692 { normal_normal_400, normal_normal_100 },
693 { normal_normal_500, normal_normal_100 },
694 { normal_normal_600, normal_normal_900 },
695 },
696 },
697
698 {
699 { normal_normal_100, normal_normal_400, normal_normal_900 },
700 {
701 { normal_normal_300, normal_normal_100 },
702 { normal_normal_400, normal_normal_400 },
703 { normal_normal_500, normal_normal_400 },
704 { normal_normal_600, normal_normal_900 },
705 },
706 },
707
708 {
709 { normal_normal_100, normal_normal_500, normal_normal_900 },
710 {
711 { normal_normal_300, normal_normal_100 },
712 { normal_normal_400, normal_normal_500 },
713 { normal_normal_500, normal_normal_500 },
714 { normal_normal_600, normal_normal_900 },
715 },
716 },
717
718 {
719 { },
720 {
721 { normal_normal_300, invalidFontStyle },
722 { normal_normal_400, invalidFontStyle },
723 { normal_normal_500, invalidFontStyle },
724 { normal_normal_600, invalidFontStyle },
725 },
726 },
727 {
728 { expanded_normal_100,expanded_normal_900,
729 expanded_italic_100,expanded_italic_900,
730 expanded_obliqu_100,expanded_obliqu_900, },
731 {
732 { condensed_normal_100, expanded_normal_100 },
733 { condensed_normal_900, expanded_normal_900 },
734 { condensed_italic_100, expanded_italic_100 },
735 { condensed_italic_900, expanded_italic_900 },
736 { condensed_obliqu_100, expanded_obliqu_100 },
737 { condensed_obliqu_900, expanded_obliqu_900 },
738 { expanded_normal_100, expanded_normal_100 },
739 { expanded_normal_900, expanded_normal_900 },
740 { expanded_italic_100, expanded_italic_100 },
741 { expanded_italic_900, expanded_italic_900 },
742 { expanded_obliqu_100, expanded_obliqu_100 },
743 { expanded_obliqu_900, expanded_obliqu_900 },
744 },
745 },
746 {
747 { expanded_normal_100,expanded_normal_900,
748 expanded_obliqu_100,expanded_obliqu_900, },
749 {
750 { condensed_normal_100, expanded_normal_100 },
751 { condensed_normal_900, expanded_normal_900 },
752 { condensed_italic_100, expanded_obliqu_100 },
753 { condensed_italic_900, expanded_obliqu_900 },
754 { condensed_obliqu_100, expanded_obliqu_100 },
755 { condensed_obliqu_900, expanded_obliqu_900 },
756 { expanded_normal_100, expanded_normal_100 },
757 { expanded_normal_900, expanded_normal_900 },
758 { expanded_italic_100, expanded_obliqu_100 },
759 { expanded_italic_900, expanded_obliqu_900 },
760 { expanded_obliqu_100, expanded_obliqu_100 },
761 { expanded_obliqu_900, expanded_obliqu_900 },
762 },
763 },
764 {
765 { expanded_italic_100,expanded_italic_900,
766 expanded_obliqu_100,expanded_obliqu_900, },
767 {
768 { condensed_normal_100, expanded_obliqu_100 },
769 { condensed_normal_900, expanded_obliqu_900 },
770 { condensed_italic_100, expanded_italic_100 },
771 { condensed_italic_900, expanded_italic_900 },
772 { condensed_obliqu_100, expanded_obliqu_100 },
773 { condensed_obliqu_900, expanded_obliqu_900 },
774 { expanded_normal_100, expanded_obliqu_100 },
775 { expanded_normal_900, expanded_obliqu_900 },
776 { expanded_italic_100, expanded_italic_100 },
777 { expanded_italic_900, expanded_italic_900 },
778 { expanded_obliqu_100, expanded_obliqu_100 },
779 { expanded_obliqu_900, expanded_obliqu_900 },
780 },
781 },
782 };
783
784 for (StyleSetTest& test : tests) {
785 for (const StyleSetTest::Case& testCase : test.cases) {
786 sk_sp<SkTypeface> typeface(test.styleSet.matchStyle(testCase.pattern));
787 if (typeface) {
788 REPORTER_ASSERT(reporter, typeface->fontStyle() == testCase.expectedResult);
789 } else {
790 REPORTER_ASSERT(reporter, invalidFontStyle == testCase.expectedResult);
791 }
792 }
793 }
794}
tests
static BlurTest tests[]
Definition: BlurTest.cpp:84
glyphs
uint16_t glyphs[5]
Definition: FontMgrTest.cpp:45
next
static float next(float f)
Definition: PathOpsAngleTest.cpp:32
sk_bzero
static void sk_bzero(void *buffer, size_t size)
Definition: SkMalloc.h:97
sk_ref_sp
sk_sp< T > sk_ref_sp(T *obj)
Definition: SkRefCnt.h:381
SkFontTableTag
uint32_t SkFontTableTag
Definition: SkTypeface.h:44
SkUnichar
int32_t SkUnichar
Definition: SkTypes.h:167
SkGlyphID
uint16_t SkGlyphID
Definition: SkTypes.h:171
SkFontStyleSet::matchStyleCSS3
sk_sp< SkTypeface > matchStyleCSS3(const SkFontStyle &pattern)
Definition: SkFontMgr.cpp:200
SkFontStyleSet::createTypeface
virtual sk_sp< SkTypeface > createTypeface(int index)=0
SkFontStyleSet::matchStyle
virtual sk_sp< SkTypeface > matchStyle(const SkFontStyle &pattern)=0
SkFontStyleSet::count
virtual int count()=0
SkFontStyleSet::getStyle
virtual void getStyle(int index, SkFontStyle *, SkString *style)=0
SkFontStyle::kSemiBold_Weight
@ kSemiBold_Weight
Definition: SkFontStyle.h:25
SkFontStyle::kCondensed_Width
@ kCondensed_Width
Definition: SkFontStyle.h:35
SkScalerContext::MakeEmpty
static std::unique_ptr< SkScalerContext > MakeEmpty(sk_sp< SkTypeface > typeface, const SkScalerContextEffects &effects, const SkDescriptor *desc)
Definition: SkScalerContext.cpp:1271
SkString::reset
void reset()
Definition: SkString.cpp:357
SkTypeface::fontStyle
SkFontStyle fontStyle() const
Definition: SkTypeface.h:58
TestTypeface::getGlyphToUnicodeMap
void getGlyphToUnicodeMap(SkUnichar *glyphToUnicode) const override
Definition: TestTypeface.cpp:149
TestTypeface::onGlyphMaskNeedsCurrentColor
bool onGlyphMaskNeedsCurrentColor() const override
Definition: TestTypeface.h:113
TestTypeface::onCharsToGlyphs
void onCharsToGlyphs(const SkUnichar *chars, int count, SkGlyphID glyphs[]) const override
Definition: TestTypeface.cpp:231
TestTypeface::onGetVariationDesignPosition
int onGetVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[], int coordinateCount) const override
Definition: TestTypeface.h:115
TestTypeface::onCreateFamilyNameIterator
SkTypeface::LocalizedStrings * onCreateFamilyNameIterator() const override
Definition: TestTypeface.cpp:241
TestTypeface::onGetUPEM
int onGetUPEM() const override
Definition: TestTypeface.h:107
TestTypeface::getPostScriptGlyphNames
void getPostScriptGlyphNames(SkString *) const override
Definition: TestTypeface.h:105
TestTypeface::onGetPostScriptName
bool onGetPostScriptName(SkString *) const override
Definition: TestTypeface.cpp:239
TestTypeface::onGetAdvancedMetrics
std::unique_ptr< SkAdvancedTypefaceMetrics > onGetAdvancedMetrics() const override
Definition: TestTypeface.cpp:156
TestTypeface::onGetFamilyName
void onGetFamilyName(SkString *familyName) const override
Definition: TestTypeface.cpp:237
TestTypeface::onGetVariationDesignParameters
int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[], int parameterCount) const override
Definition: TestTypeface.h:120
TestTypeface::onGetTableTags
int onGetTableTags(SkFontTableTag tags[]) const override
Definition: TestTypeface.h:125
TestTypeface::onOpenStream
std::unique_ptr< SkStreamAsset > onOpenStream(int *ttcIndex) const override
Definition: TestTypeface.cpp:165
TestTypeface::onGetTableData
size_t onGetTableData(SkFontTableTag tag, size_t offset, size_t length, void *data) const override
Definition: TestTypeface.h:127
TestTypeface::onCreateScalerContext
std::unique_ptr< SkScalerContext > onCreateScalerContext(const SkScalerContextEffects &, const SkDescriptor *desc) const override
Definition: TestTypeface.cpp:291
TestTypeface::onFilterRec
void onFilterRec(SkScalerContextRec *rec) const override
Definition: TestTypeface.cpp:145
TestTypeface::onMakeClone
sk_sp< SkTypeface > onMakeClone(const SkFontArguments &args) const override
Definition: TestTypeface.h:95
TestTypeface::onCountGlyphs
int onCountGlyphs() const override
Definition: TestTypeface.h:103
TestTypeface::onGetFontDescriptor
void onGetFontDescriptor(SkFontDescriptor *desc, bool *serialize) const override
Definition: TestTypeface.cpp:219
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition: fl_event_channel.h:89

◆ for() [1/2]

for ( const auto glyph :glyphs  )

Definition at line 51 of file FontMgrTest.cpp.

51: glyphs) { REPORTER_ASSERT(reporter, glyph == 0); }

◆ for() [2/2]

for ( )

Definition at line 56 of file FontMgrTest.cpp.

56 {
57 REPORTER_ASSERT(reporter, 0 != glyphs[i]);
58 }

◆ newFont()

const SkFont newFont ( font.  makeWithSize36)

◆ REPORTER_ASSERT() [1/8]

REPORTER_ASSERT ( reporter  ,
0  = =font.getSkewX() 
)

◆ REPORTER_ASSERT() [2/8]

REPORTER_ASSERT ( reporter  ,
1  = =font.getScaleX() 
)

◆ REPORTER_ASSERT() [3/8]

REPORTER_ASSERT ( reporter  ,
24  = =font.getSize() 
)

◆ REPORTER_ASSERT() [4/8]

REPORTER_ASSERT ( reporter  ,
36  = =newFont.getSize() 
)

◆ REPORTER_ASSERT() [5/8]

REPORTER_ASSERT ( reporter  ,
5  = =count 
)

◆ REPORTER_ASSERT() [6/8]

REPORTER_ASSERT ( reporter  ,
font.  getTypefaceOrDefault() = =newFont.getTypefaceOrDefault() 
)

◆ REPORTER_ASSERT() [7/8]

REPORTER_ASSERT ( reporter  ,
glyphs !  [0] = glyphs[1] 
)

◆ REPORTER_ASSERT() [8/8]

REPORTER_ASSERT ( reporter  ,
glyphs  [2] = =glyphs[3] 
)

◆ sk_bzero()

sk_bzero ( glyphs  ,
sizeof(glyphs)   
)

◆ SkAssertResult()

SkAssertResult ( font.  textToGlyphs"Hello", 5, SkTextEncoding::kUTF8, glyphs, std::size(glyphs) = =count)

Variable Documentation

◆ count

int count = font.textToGlyphs("Hello", 5, SkTextEncoding::kUTF8, glyphs, 2)

Definition at line 49 of file FontMgrTest.cpp.

◆ glyphs

uint16_t glyphs[5]

Definition at line 45 of file FontMgrTest.cpp.

◆ reporter

reporter
Initial value:
{
SkFont font(nullptr, 24)
SkFont
Definition: SkFont.h:35

Definition at line 37 of file FontMgrTest.cpp.

Generated on Wed Sep 27 2023 04:53:18 for Flutter Engine by doxygen 1.9.6