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 kRobotoVariable[] = "/system/fonts/Roboto-Regular.ttf";
35 
36 constexpr char kRegularFont[] = "/system/fonts/NotoSerif-Regular.ttf";
37 constexpr char kBoldFont[] = "/system/fonts/NotoSerif-Bold.ttf";
38 constexpr char kItalicFont[] = "/system/fonts/NotoSerif-Italic.ttf";
39 constexpr char kBoldItalicFont[] = "/system/fonts/NotoSerif-BoldItalic.ttf";
40 
unmap(const void * ptr,void * context)41 void unmap(const void* ptr, void* context) {
42     void* p = const_cast<void*>(ptr);
43     size_t len = reinterpret_cast<size_t>(context);
44     munmap(p, len);
45 }
46 
buildFamily(const char * fileName)47 std::shared_ptr<minikin::FontFamily> buildFamily(const char* fileName) {
48     int fd = open(fileName, O_RDONLY);
49     LOG_ALWAYS_FATAL_IF(fd == -1, "Failed to open file %s", fileName);
50     struct stat st = {};
51     LOG_ALWAYS_FATAL_IF(fstat(fd, &st) == -1, "Failed to stat file %s", fileName);
52     void* data = mmap(nullptr, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
53     sk_sp<SkData> skData =
54             SkData::MakeWithProc(data, st.st_size, unmap, reinterpret_cast<void*>(st.st_size));
55     std::unique_ptr<SkStreamAsset> fontData(new SkMemoryStream(skData));
56     sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
57     sk_sp<SkTypeface> typeface(fm->makeFromStream(std::move(fontData)));
58     LOG_ALWAYS_FATAL_IF(typeface == nullptr, "Failed to make typeface from %s", fileName);
59     std::shared_ptr<minikin::MinikinFont> font =
60             std::make_shared<MinikinFontSkia>(std::move(typeface), 0, data, st.st_size, fileName, 0,
61                                               std::vector<minikin::FontVariation>());
62     std::vector<std::shared_ptr<minikin::Font>> fonts;
63     fonts.push_back(minikin::Font::Builder(font).build());
64     return std::make_shared<minikin::FontFamily>(std::move(fonts));
65 }
66 
makeSingleFamlyVector(const char * fileName)67 std::vector<std::shared_ptr<minikin::FontFamily>> makeSingleFamlyVector(const char* fileName) {
68     return std::vector<std::shared_ptr<minikin::FontFamily>>({buildFamily(fileName)});
69 }
70 
TEST(TypefaceTest,resolveDefault_and_setDefaultTest)71 TEST(TypefaceTest, resolveDefault_and_setDefaultTest) {
72     std::unique_ptr<Typeface> regular(Typeface::createFromFamilies(
73             makeSingleFamlyVector(kRobotoVariable), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
74     EXPECT_EQ(regular.get(), Typeface::resolveDefault(regular.get()));
75 
76     // Keep the original to restore it later.
77     const Typeface* old = Typeface::resolveDefault(nullptr);
78     ASSERT_NE(nullptr, old);
79 
80     Typeface::setDefault(regular.get());
81     EXPECT_EQ(regular.get(), Typeface::resolveDefault(nullptr));
82 
83     Typeface::setDefault(old);  // Restore to the original.
84 }
85 
TEST(TypefaceTest,createWithDifferentBaseWeight)86 TEST(TypefaceTest, createWithDifferentBaseWeight) {
87     std::unique_ptr<Typeface> bold(Typeface::createWithDifferentBaseWeight(nullptr, 700));
88     EXPECT_EQ(700, bold->fStyle.weight());
89     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
90     EXPECT_EQ(Typeface::kNormal, bold->fAPIStyle);
91 
92     std::unique_ptr<Typeface> light(Typeface::createWithDifferentBaseWeight(nullptr, 300));
93     EXPECT_EQ(300, light->fStyle.weight());
94     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, light->fStyle.slant());
95     EXPECT_EQ(Typeface::kNormal, light->fAPIStyle);
96 }
97 
TEST(TypefaceTest,createRelativeTest_fromRegular)98 TEST(TypefaceTest, createRelativeTest_fromRegular) {
99     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.NORMAL);
100     std::unique_ptr<Typeface> normal(Typeface::createRelative(nullptr, Typeface::kNormal));
101     EXPECT_EQ(400, normal->fStyle.weight());
102     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
103     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
104 
105     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD);
106     std::unique_ptr<Typeface> bold(Typeface::createRelative(nullptr, Typeface::kBold));
107     EXPECT_EQ(700, bold->fStyle.weight());
108     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
109     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
110 
111     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.ITALIC);
112     std::unique_ptr<Typeface> italic(Typeface::createRelative(nullptr, Typeface::kItalic));
113     EXPECT_EQ(400, italic->fStyle.weight());
114     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
115     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
116 
117     // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC);
118     std::unique_ptr<Typeface> boldItalic(Typeface::createRelative(nullptr, Typeface::kBoldItalic));
119     EXPECT_EQ(700, boldItalic->fStyle.weight());
120     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
121     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
122 }
123 
TEST(TypefaceTest,createRelativeTest_BoldBase)124 TEST(TypefaceTest, createRelativeTest_BoldBase) {
125     std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 700));
126 
127     // In Java, Typeface.create(Typeface.create("sans-serif-bold"),
128     // Typeface.NORMAL);
129     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));
130     EXPECT_EQ(700, normal->fStyle.weight());
131     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
132     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
133 
134     // In Java, Typeface.create(Typeface.create("sans-serif-bold"),
135     // Typeface.BOLD);
136     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));
137     EXPECT_EQ(1000, bold->fStyle.weight());
138     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
139     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
140 
141     // In Java, Typeface.create(Typeface.create("sans-serif-bold"),
142     // Typeface.ITALIC);
143     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));
144     EXPECT_EQ(700, italic->fStyle.weight());
145     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
146     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
147 
148     // In Java, Typeface.create(Typeface.create("sans-serif-bold"),
149     // Typeface.BOLD_ITALIC);
150     std::unique_ptr<Typeface> boldItalic(
151             Typeface::createRelative(base.get(), Typeface::kBoldItalic));
152     EXPECT_EQ(1000, boldItalic->fStyle.weight());
153     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
154     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
155 }
156 
TEST(TypefaceTest,createRelativeTest_LightBase)157 TEST(TypefaceTest, createRelativeTest_LightBase) {
158     std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 300));
159 
160     // In Java, Typeface.create(Typeface.create("sans-serif-light"),
161     // Typeface.NORMAL);
162     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));
163     EXPECT_EQ(300, normal->fStyle.weight());
164     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
165     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
166 
167     // In Java, Typeface.create(Typeface.create("sans-serif-light"),
168     // Typeface.BOLD);
169     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));
170     EXPECT_EQ(600, bold->fStyle.weight());
171     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
172     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
173 
174     // In Java, Typeface.create(Typeface.create("sans-serif-light"),
175     // Typeface.ITLIC);
176     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));
177     EXPECT_EQ(300, italic->fStyle.weight());
178     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
179     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
180 
181     // In Java, Typeface.create(Typeface.create("sans-serif-light"),
182     // Typeface.BOLD_ITALIC);
183     std::unique_ptr<Typeface> boldItalic(
184             Typeface::createRelative(base.get(), Typeface::kBoldItalic));
185     EXPECT_EQ(600, boldItalic->fStyle.weight());
186     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
187     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
188 }
189 
TEST(TypefaceTest,createRelativeTest_fromBoldStyled)190 TEST(TypefaceTest, createRelativeTest_fromBoldStyled) {
191     std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, Typeface::kBold));
192 
193     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD),
194     // Typeface.NORMAL);
195     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));
196     EXPECT_EQ(400, normal->fStyle.weight());
197     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
198     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
199 
200     // In Java Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD),
201     // Typeface.BOLD);
202     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));
203     EXPECT_EQ(700, bold->fStyle.weight());
204     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
205     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
206 
207     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD),
208     // Typeface.ITALIC);
209     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));
210     EXPECT_EQ(400, normal->fStyle.weight());
211     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
212     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
213 
214     // In Java,
215     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD),
216     // Typeface.BOLD_ITALIC);
217     std::unique_ptr<Typeface> boldItalic(
218             Typeface::createRelative(base.get(), Typeface::kBoldItalic));
219     EXPECT_EQ(700, boldItalic->fStyle.weight());
220     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
221     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
222 }
223 
TEST(TypefaceTest,createRelativeTest_fromItalicStyled)224 TEST(TypefaceTest, createRelativeTest_fromItalicStyled) {
225     std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, Typeface::kItalic));
226 
227     // In Java,
228     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC),
229     // Typeface.NORMAL);
230     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));
231     EXPECT_EQ(400, normal->fStyle.weight());
232     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
233     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
234 
235     // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT,
236     // Typeface.ITALIC), Typeface.BOLD);
237     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));
238     EXPECT_EQ(700, bold->fStyle.weight());
239     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
240     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
241 
242     // In Java,
243     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC),
244     // Typeface.ITALIC);
245     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));
246     EXPECT_EQ(400, italic->fStyle.weight());
247     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
248     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
249 
250     // In Java,
251     // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC),
252     // Typeface.BOLD_ITALIC);
253     std::unique_ptr<Typeface> boldItalic(
254             Typeface::createRelative(base.get(), Typeface::kBoldItalic));
255     EXPECT_EQ(700, boldItalic->fStyle.weight());
256     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
257     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
258 }
259 
TEST(TypefaceTest,createRelativeTest_fromSpecifiedStyled)260 TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) {
261     std::unique_ptr<Typeface> base(Typeface::createAbsolute(nullptr, 400, false));
262 
263     // In Java,
264     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
265     //     .setWeight(700).setItalic(false).build();
266     // Typeface.create(typeface, Typeface.NORMAL);
267     std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));
268     EXPECT_EQ(400, normal->fStyle.weight());
269     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, normal->fStyle.slant());
270     EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);
271 
272     // In Java,
273     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
274     //     .setWeight(700).setItalic(false).build();
275     // Typeface.create(typeface, Typeface.BOLD);
276     std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));
277     EXPECT_EQ(700, bold->fStyle.weight());
278     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
279     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
280 
281     // In Java,
282     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
283     //     .setWeight(700).setItalic(false).build();
284     // Typeface.create(typeface, Typeface.ITALIC);
285     std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));
286     EXPECT_EQ(400, italic->fStyle.weight());
287     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
288     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
289 
290     // In Java,
291     // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")
292     //     .setWeight(700).setItalic(false).build();
293     // Typeface.create(typeface, Typeface.BOLD_ITALIC);
294     std::unique_ptr<Typeface> boldItalic(
295             Typeface::createRelative(base.get(), Typeface::kBoldItalic));
296     EXPECT_EQ(700, boldItalic->fStyle.weight());
297     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
298     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
299 }
300 
TEST(TypefaceTest,createAbsolute)301 TEST(TypefaceTest, createAbsolute) {
302     // In Java,
303     // new
304     // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(false)
305     //     .build();
306     std::unique_ptr<Typeface> regular(Typeface::createAbsolute(nullptr, 400, false));
307     EXPECT_EQ(400, regular->fStyle.weight());
308     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, regular->fStyle.slant());
309     EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);
310 
311     // In Java,
312     // new
313     // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(false)
314     //     .build();
315     std::unique_ptr<Typeface> bold(Typeface::createAbsolute(nullptr, 700, false));
316     EXPECT_EQ(700, bold->fStyle.weight());
317     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
318     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
319 
320     // In Java,
321     // new
322     // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(true)
323     //     .build();
324     std::unique_ptr<Typeface> italic(Typeface::createAbsolute(nullptr, 400, true));
325     EXPECT_EQ(400, italic->fStyle.weight());
326     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
327     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
328 
329     // In Java,
330     // new
331     // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(true)
332     //     .build();
333     std::unique_ptr<Typeface> boldItalic(Typeface::createAbsolute(nullptr, 700, true));
334     EXPECT_EQ(700, boldItalic->fStyle.weight());
335     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
336     EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);
337 
338     // In Java,
339     // new
340     // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(1100).setItalic(true)
341     //     .build();
342     std::unique_ptr<Typeface> over1000(Typeface::createAbsolute(nullptr, 1100, false));
343     EXPECT_EQ(1000, over1000->fStyle.weight());
344     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, over1000->fStyle.slant());
345     EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle);
346 }
347 
TEST(TypefaceTest,createFromFamilies_Single)348 TEST(TypefaceTest, createFromFamilies_Single) {
349     // In Java, new
350     // Typeface.Builder("Roboto-Regular.ttf").setWeight(400).setItalic(false).build();
351     std::unique_ptr<Typeface> regular(
352             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoVariable), 400, false));
353     EXPECT_EQ(400, regular->fStyle.weight());
354     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, regular->fStyle.slant());
355     EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);
356 
357     // In Java, new
358     // Typeface.Builder("Roboto-Regular.ttf").setWeight(700).setItalic(false).build();
359     std::unique_ptr<Typeface> bold(
360             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoVariable), 700, false));
361     EXPECT_EQ(700, bold->fStyle.weight());
362     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
363     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
364 
365     // In Java, new
366     // Typeface.Builder("Roboto-Regular.ttf").setWeight(400).setItalic(true).build();
367     std::unique_ptr<Typeface> italic(
368             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoVariable), 400, true));
369     EXPECT_EQ(400, italic->fStyle.weight());
370     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
371     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
372 
373     // In Java,
374     // new
375     // Typeface.Builder("Roboto-Regular.ttf").setWeight(700).setItalic(true).build();
376     std::unique_ptr<Typeface> boldItalic(
377             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoVariable), 700, true));
378     EXPECT_EQ(700, boldItalic->fStyle.weight());
379     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
380     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
381 
382     // In Java,
383     // new
384     // Typeface.Builder("Roboto-Regular.ttf").setWeight(1100).setItalic(false).build();
385     std::unique_ptr<Typeface> over1000(
386             Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoVariable), 1100, false));
387     EXPECT_EQ(1000, over1000->fStyle.weight());
388     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, over1000->fStyle.slant());
389     EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle);
390 }
391 
TEST(TypefaceTest,createFromFamilies_Single_resolveByTable)392 TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) {
393     // In Java, new Typeface.Builder("Family-Regular.ttf").build();
394     std::unique_ptr<Typeface> regular(Typeface::createFromFamilies(
395             makeSingleFamlyVector(kRegularFont), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
396     EXPECT_EQ(400, regular->fStyle.weight());
397     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, regular->fStyle.slant());
398     EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);
399 
400     // In Java, new Typeface.Builder("Family-Bold.ttf").build();
401     std::unique_ptr<Typeface> bold(Typeface::createFromFamilies(
402             makeSingleFamlyVector(kBoldFont), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
403     EXPECT_EQ(700, bold->fStyle.weight());
404     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, bold->fStyle.slant());
405     EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);
406 
407     // In Java, new Typeface.Builder("Family-Italic.ttf").build();
408     std::unique_ptr<Typeface> italic(Typeface::createFromFamilies(
409             makeSingleFamlyVector(kItalicFont), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
410     EXPECT_EQ(400, italic->fStyle.weight());
411     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, italic->fStyle.slant());
412     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
413 
414     // In Java, new Typeface.Builder("Family-BoldItalic.ttf").build();
415     std::unique_ptr<Typeface> boldItalic(
416             Typeface::createFromFamilies(makeSingleFamlyVector(kBoldItalicFont),
417                                          RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
418     EXPECT_EQ(700, boldItalic->fStyle.weight());
419     EXPECT_EQ(minikin::FontStyle::Slant::ITALIC, boldItalic->fStyle.slant());
420     EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);
421 }
422 
TEST(TypefaceTest,createFromFamilies_Family)423 TEST(TypefaceTest, createFromFamilies_Family) {
424     std::vector<std::shared_ptr<minikin::FontFamily>> families = {
425             buildFamily(kRegularFont), buildFamily(kBoldFont), buildFamily(kItalicFont),
426             buildFamily(kBoldItalicFont)};
427     std::unique_ptr<Typeface> typeface(Typeface::createFromFamilies(
428             std::move(families), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
429     EXPECT_EQ(400, typeface->fStyle.weight());
430     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, typeface->fStyle.slant());
431 }
432 
TEST(TypefaceTest,createFromFamilies_Family_withoutRegular)433 TEST(TypefaceTest, createFromFamilies_Family_withoutRegular) {
434     std::vector<std::shared_ptr<minikin::FontFamily>> families = {
435             buildFamily(kBoldFont), buildFamily(kItalicFont), buildFamily(kBoldItalicFont)};
436     std::unique_ptr<Typeface> typeface(Typeface::createFromFamilies(
437             std::move(families), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));
438     EXPECT_EQ(700, typeface->fStyle.weight());
439     EXPECT_EQ(minikin::FontStyle::Slant::UPRIGHT, typeface->fStyle.slant());
440 }
441 
442 }  // namespace
443