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