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