OSDN Git Service

Fix double bolding
[android-x86/frameworks-base.git] / libs / hwui / tests / unit / TypefaceTests.cpp
1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <gtest/gtest.h>
18
19 #include <fcntl.h>
20 #include <sys/mman.h>
21 #include <sys/stat.h>
22 #include <utils/Log.h>
23
24 #include "SkFontMgr.h"
25 #include "SkStream.h"
26
27 #include "hwui/MinikinSkia.h"
28 #include "hwui/Typeface.h"
29
30 using namespace android;
31
32 namespace {
33
34 constexpr char kRobotoRegular[] = "/system/fonts/Roboto-Regular.ttf";
35 constexpr char kRobotoBold[] = "/system/fonts/Roboto-Bold.ttf";
36 constexpr char kRobotoItalic[] = "/system/fonts/Roboto-Italic.ttf";
37 constexpr char kRobotoBoldItalic[] = "/system/fonts/Roboto-BoldItalic.ttf";
38
39 void unmap(const void* ptr, void* context) {
40     void* p = const_cast<void*>(ptr);
41     size_t len = reinterpret_cast<size_t>(context);
42     munmap(p, len);
43 }
44
45 std::shared_ptr<minikin::FontFamily> buildFamily(const char* fileName) {
46     int fd = open(fileName, O_RDONLY);
47     LOG_ALWAYS_FATAL_IF(fd == -1, "Failed to open file %s", fileName);
48     struct stat st = {};
49     LOG_ALWAYS_FATAL_IF(fstat(fd, &st) == -1, "Failed to stat file %s", fileName);
50     void* data = mmap(nullptr, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
51     sk_sp<SkData> skData =
52             SkData::MakeWithProc(data, st.st_size, unmap, reinterpret_cast<void*>(st.st_size));
53     std::unique_ptr<SkStreamAsset> fontData(new SkMemoryStream(skData));
54     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
55     sk_sp<SkTypeface> typeface(fm->createFromStream(fontData.release()));
56     LOG_ALWAYS_FATAL_IF(typeface == nullptr, "Failed to make typeface from %s", fileName);
57     std::shared_ptr<minikin::MinikinFont> font = std::make_shared<MinikinFontSkia>(
58             std::move(typeface), data, st.st_size, 0, std::vector<minikin::FontVariation>());
59     return std::make_shared<minikin::FontFamily>(
60             std::vector<minikin::Font>({ minikin::Font(std::move(font), minikin::FontStyle()) }));
61 }
62
63 std::vector<std::shared_ptr<minikin::FontFamily>> makeSingleFamlyVector(const char* fileName) {
64     return std::vector<std::shared_ptr<minikin::FontFamily>>({ buildFamily(fileName) });
65 }
66
67 TEST(TypefaceTest, resolveDefault_and_setDefaultTest) {
68     std::unique_ptr<Typeface> regular(
69             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoRegular),
70                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
71     EXPECT_EQ(regular.get(), Typeface::resolveDefault(regular.get()));
72
73     Typeface* old = Typeface::resolveDefault(nullptr);  // Keep the original to restore it later.
74     ASSERT_NE(nullptr, old);
75
76     Typeface::setDefault(regular.get());
77     EXPECT_EQ(regular.get(), Typeface::resolveDefault(nullptr));
78
79     Typeface::setDefault(old);  // Restore to the original.
80 }
81
82 TEST(TypefaceTest, createWithDifferentBaseWeight) {
83     std::unique_ptr<Typeface> bold(Typeface::createWithDifferentBaseWeight(nullptr, 700));
84     EXPECT_EQ(7, bold->fStyle.getWeight());
85     EXPECT_FALSE(bold->fStyle.getItalic());
86     EXPECT_EQ(SkTypeface::kNormal, bold->fSkiaStyle);
87
88     std::unique_ptr<Typeface> light(Typeface::createWithDifferentBaseWeight(nullptr, 300));
89     EXPECT_EQ(3, light->fStyle.getWeight());
90     EXPECT_FALSE(light->fStyle.getItalic());
91     EXPECT_EQ(SkTypeface::kNormal, light->fSkiaStyle);
92 }
93
94 TEST(TypefaceTest, createRelativeTest_fromRegular) {
95     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.NORMAL);
96     std::unique_ptr<Typeface> normal(Typeface::createRelative(nullptr, SkTypeface::kNormal));
97     EXPECT_EQ(4, normal->fStyle.getWeight());
98     EXPECT_FALSE(normal->fStyle.getItalic());
99     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
100
101     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD);
102     std::unique_ptr<Typeface> bold(Typeface::createRelative(nullptr, SkTypeface::kBold));
103     EXPECT_EQ(7, bold->fStyle.getWeight());
104     EXPECT_FALSE(bold->fStyle.getItalic());
105     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
106
107     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.ITALIC);
108     std::unique_ptr<Typeface> italic(Typeface::createRelative(nullptr, SkTypeface::kItalic));
109     EXPECT_EQ(4, italic->fStyle.getWeight());
110     EXPECT_TRUE(italic->fStyle.getItalic());
111     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
112
113     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC);
114     std::unique_ptr<Typeface> boldItalic(
115             Typeface::createRelative(nullptr, SkTypeface::kBoldItalic));
116     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
117     EXPECT_TRUE(boldItalic->fStyle.getItalic());
118     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
119 }
120
121 TEST(TypefaceTest, createRelativeTest_BoldBase) {
122     std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 700));
123
124     // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.NORMAL);
125     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));
126     EXPECT_EQ(7, normal->fStyle.getWeight());
127     EXPECT_FALSE(normal->fStyle.getItalic());
128     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
129
130     // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD);
131     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));
132     EXPECT_EQ(10, bold->fStyle.getWeight());
133     EXPECT_FALSE(bold->fStyle.getItalic());
134     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
135
136     // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.ITALIC);
137     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));
138     EXPECT_EQ(7, italic->fStyle.getWeight());
139     EXPECT_TRUE(italic->fStyle.getItalic());
140     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
141
142     // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD_ITALIC);
143     std::unique_ptr<Typeface>
144             boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));
145     EXPECT_EQ(10, boldItalic->fStyle.getWeight());
146     EXPECT_TRUE(boldItalic->fStyle.getItalic());
147     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
148 }
149
150 TEST(TypefaceTest, createRelativeTest_LightBase) {
151     std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 300));
152
153     // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.NORMAL);
154     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));
155     EXPECT_EQ(3, normal->fStyle.getWeight());
156     EXPECT_FALSE(normal->fStyle.getItalic());
157     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
158
159     // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD);
160     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));
161     EXPECT_EQ(6, bold->fStyle.getWeight());
162     EXPECT_FALSE(bold->fStyle.getItalic());
163     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
164
165     // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.ITLIC);
166     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));
167     EXPECT_EQ(3, italic->fStyle.getWeight());
168     EXPECT_TRUE(italic->fStyle.getItalic());
169     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
170
171     // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD_ITALIC);
172     std::unique_ptr<Typeface>
173             boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));
174     EXPECT_EQ(6, boldItalic->fStyle.getWeight());
175     EXPECT_TRUE(boldItalic->fStyle.getItalic());
176     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
177 }
178
179 TEST(TypefaceTest, createRelativeTest_fromBoldStyled) {
180     std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, SkTypeface::kBold));
181
182     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.NORMAL);
183     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));
184     EXPECT_EQ(4, normal->fStyle.getWeight());
185     EXPECT_FALSE(normal->fStyle.getItalic());
186     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
187
188     // In Java Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD);
189     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));
190     EXPECT_EQ(7, bold->fStyle.getWeight());
191     EXPECT_FALSE(bold->fStyle.getItalic());
192     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
193
194     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.ITALIC);
195     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));
196     EXPECT_EQ(4, normal->fStyle.getWeight());
197     EXPECT_TRUE(italic->fStyle.getItalic());
198     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
199
200     // In Java,
201     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD_ITALIC);
202     std::unique_ptr<Typeface>
203             boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));
204     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
205     EXPECT_TRUE(boldItalic->fStyle.getItalic());
206     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
207 }
208
209 TEST(TypefaceTest, createRelativeTest_fromItalicStyled) {
210     std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, SkTypeface::kItalic));
211
212     // In Java,
213     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.NORMAL);
214     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));
215     EXPECT_EQ(4, normal->fStyle.getWeight());
216     EXPECT_FALSE(normal->fStyle.getItalic());
217     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
218
219     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD);
220     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));
221     EXPECT_EQ(7, bold->fStyle.getWeight());
222     EXPECT_FALSE(bold->fStyle.getItalic());
223     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
224
225     // In Java,
226     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.ITALIC);
227     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));
228     EXPECT_EQ(4, italic->fStyle.getWeight());
229     EXPECT_TRUE(italic->fStyle.getItalic());
230     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
231
232     // In Java,
233     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD_ITALIC);
234     std::unique_ptr<Typeface>
235             boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));
236     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
237     EXPECT_TRUE(boldItalic->fStyle.getItalic());
238     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
239 }
240
241 TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) {
242     std::unique_ptr<Typeface> base(Typeface::createAbsolute(nullptr, 400, false));
243
244     // In Java,
245     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
246     //     .setWeight(700).setItalic(false).build();
247     // Typeface.create(typeface, Typeface.NORMAL);
248     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));
249     EXPECT_EQ(4, normal->fStyle.getWeight());
250     EXPECT_FALSE(normal->fStyle.getItalic());
251     EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);
252
253     // In Java,
254     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
255     //     .setWeight(700).setItalic(false).build();
256     // Typeface.create(typeface, Typeface.BOLD);
257     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));
258     EXPECT_EQ(7, bold->fStyle.getWeight());
259     EXPECT_FALSE(bold->fStyle.getItalic());
260     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
261
262     // In Java,
263     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
264     //     .setWeight(700).setItalic(false).build();
265     // Typeface.create(typeface, Typeface.ITALIC);
266     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));
267     EXPECT_EQ(4, italic->fStyle.getWeight());
268     EXPECT_TRUE(italic->fStyle.getItalic());
269     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
270
271     // In Java,
272     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
273     //     .setWeight(700).setItalic(false).build();
274     // Typeface.create(typeface, Typeface.BOLD_ITALIC);
275     std::unique_ptr<Typeface>
276             boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));
277     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
278     EXPECT_TRUE(boldItalic->fStyle.getItalic());
279     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
280 }
281
282 TEST(TypefaceTest, createAbsolute) {
283     // In Java,
284     // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(false)
285     //     .build();
286     std::unique_ptr<Typeface> regular(Typeface::createAbsolute(nullptr, 400, false));
287     EXPECT_EQ(4, regular->fStyle.getWeight());
288     EXPECT_FALSE(regular->fStyle.getItalic());
289     EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);
290
291     // In Java,
292     // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(false)
293     //     .build();
294     std::unique_ptr<Typeface> bold(Typeface::createAbsolute(nullptr, 700, false));
295     EXPECT_EQ(7, bold->fStyle.getWeight());
296     EXPECT_FALSE(bold->fStyle.getItalic());
297     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
298
299     // In Java,
300     // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(true)
301     //     .build();
302     std::unique_ptr<Typeface> italic(Typeface::createAbsolute(nullptr, 400, true));
303     EXPECT_EQ(4, italic->fStyle.getWeight());
304     EXPECT_TRUE(italic->fStyle.getItalic());
305     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
306
307     // In Java,
308     // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(true)
309     //     .build();
310     std::unique_ptr<Typeface> boldItalic(Typeface::createAbsolute(nullptr, 700, true));
311     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
312     EXPECT_TRUE(boldItalic->fStyle.getItalic());
313     EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);
314
315     // In Java,
316     // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(1100).setItalic(true)
317     //     .build();
318     std::unique_ptr<Typeface> over1000(Typeface::createAbsolute(nullptr, 1100, false));
319     EXPECT_EQ(10, over1000->fStyle.getWeight());
320     EXPECT_FALSE(over1000->fStyle.getItalic());
321     EXPECT_EQ(SkTypeface::kBold, over1000->fSkiaStyle);
322 }
323
324 TEST(TypefaceTest, createFromFamilies_Single) {
325     // In Java, new Typeface.Builder("Roboto-Regular.ttf").setWeight(400).setItalic(false).build();
326     std::unique_ptr<Typeface> regular(
327             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoRegular), 400, false));
328     EXPECT_EQ(4, regular->fStyle.getWeight());
329     EXPECT_FALSE(regular->fStyle.getItalic());
330     EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);
331
332     // In Java, new Typeface.Builder("Roboto-Bold.ttf").setWeight(700).setItalic(false).build();
333     std::unique_ptr<Typeface> bold(
334             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 700, false));
335     EXPECT_EQ(7, bold->fStyle.getWeight());
336     EXPECT_FALSE(bold->fStyle.getItalic());
337     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
338
339     // In Java, new Typeface.Builder("Roboto-Italic.ttf").setWeight(400).setItalic(true).build();
340     std::unique_ptr<Typeface> italic(
341             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoItalic), 400, true));
342     EXPECT_EQ(4, italic->fStyle.getWeight());
343     EXPECT_TRUE(italic->fStyle.getItalic());
344     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
345
346     // In Java,
347     // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(700).setItalic(true).build();
348     std::unique_ptr<Typeface> boldItalic(
349             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBoldItalic), 700, true));
350     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
351     EXPECT_TRUE(boldItalic->fStyle.getItalic());
352     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
353
354     // In Java,
355     // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(1100).setItalic(false).build();
356     std::unique_ptr<Typeface> over1000(
357             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 1100, false));
358     EXPECT_EQ(10, over1000->fStyle.getWeight());
359     EXPECT_FALSE(over1000->fStyle.getItalic());
360     EXPECT_EQ(SkTypeface::kBold, over1000->fSkiaStyle);
361 }
362
363 TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) {
364     // In Java, new Typeface.Builder("Roboto-Regular.ttf").build();
365     std::unique_ptr<Typeface> regular(
366             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoRegular),
367                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
368     EXPECT_EQ(4, regular->fStyle.getWeight());
369     EXPECT_FALSE(regular->fStyle.getItalic());
370     EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);
371
372     // In Java, new Typeface.Builder("Roboto-Bold.ttf").build();
373     std::unique_ptr<Typeface> bold(
374             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold),
375                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
376     EXPECT_EQ(7, bold->fStyle.getWeight());
377     EXPECT_FALSE(bold->fStyle.getItalic());
378     EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);
379
380     // In Java, new Typeface.Builder("Roboto-Italic.ttf").build();
381     std::unique_ptr<Typeface> italic(
382             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoItalic),
383                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
384     EXPECT_EQ(4, italic->fStyle.getWeight());
385     EXPECT_TRUE(italic->fStyle.getItalic());
386     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
387
388     // In Java, new Typeface.Builder("Roboto-BoldItalic.ttf").build();
389     std::unique_ptr<Typeface> boldItalic(
390             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBoldItalic),
391                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
392     EXPECT_EQ(7, boldItalic->fStyle.getWeight());
393     EXPECT_TRUE(boldItalic->fStyle.getItalic());
394     EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);
395 }
396
397 TEST(TypefaceTest, createFromFamilies_Family) {
398     std::vector<std::shared_ptr<minikin::FontFamily>> families = {
399             buildFamily(kRobotoRegular), buildFamily(kRobotoBold), buildFamily(kRobotoItalic),
400             buildFamily(kRobotoBoldItalic)
401     };
402     std::unique_ptr<Typeface> typeface(Typeface::createFromFamilies(std::move(families),
403                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
404     EXPECT_EQ(4, typeface->fStyle.getWeight());
405     EXPECT_FALSE(typeface->fStyle.getItalic());
406 }
407
408 TEST(TypefaceTest, createFromFamilies_Family_withoutRegular) {
409     std::vector<std::shared_ptr<minikin::FontFamily>> families = {
410             buildFamily(kRobotoBold), buildFamily(kRobotoItalic), buildFamily(kRobotoBoldItalic)
411     };
412     std::unique_ptr<Typeface> typeface(Typeface::createFromFamilies(std::move(families),
413                     RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
414     EXPECT_EQ(7, typeface->fStyle.getWeight());
415     EXPECT_FALSE(typeface->fStyle.getItalic());
416 }
417
418 }  // namespace