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