TypefaceTests.cpp revision 373b15bda93c8b400c5e1271bc93cbef26af503f 
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
30using namespace android;
31
32namespace {
33
34constexpr char kRobotoRegular[] = "/system/fonts/Roboto-Regular.ttf";
35constexpr char kRobotoBold[] = "/system/fonts/Roboto-Bold.ttf";
36constexpr char kRobotoItalic[] = "/system/fonts/Roboto-Italic.ttf";
37constexpr char kRobotoBoldItalic[] = "/system/fonts/Roboto-BoldItalic.ttf";
38
39void 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
45std::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
63std::vector<std::shared_ptr<minikin::FontFamily>> makeSingleFamlyVector(const char* fileName) {
64    return std::vector<std::shared_ptr<minikin::FontFamily>>({ buildFamily(fileName) });
65}
66
67TEST(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
82TEST(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
94TEST(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
121TEST(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
150TEST(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
179TEST(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
209TEST(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
241TEST(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
282TEST(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
324TEST(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
363TEST(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
397TEST(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
408TEST(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
419