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 kRobotoRegular[] = "/system/fonts/Roboto-Regular.ttf";
35 constexpr char kRobotoBold[] = "/system/fonts/Roboto-Bold.ttf";
36 constexpr char kRobotoItalic[] = "/system/fonts/Roboto-Italic.ttf";
37 constexpr char kRobotoBoldItalic[] = "/system/fonts/Roboto-BoldItalic.ttf";
38
unmap(const void * ptr,void * context)39 void 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
buildFamily(const char * fileName)45 std::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
makeSingleFamlyVector(const char * fileName)64 std::vector<std::shared_ptr<minikin::FontFamily>> makeSingleFamlyVector(const char* fileName) {
65 return std::vector<std::shared_ptr<minikin::FontFamily>>({buildFamily(fileName)});
66 }
67
TEST(TypefaceTest,resolveDefault_and_setDefaultTest)68 TEST(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
TEST(TypefaceTest,createWithDifferentBaseWeight)83 TEST(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
TEST(TypefaceTest,createRelativeTest_fromRegular)95 TEST(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
TEST(TypefaceTest,createRelativeTest_BoldBase)121 TEST(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
TEST(TypefaceTest,createRelativeTest_LightBase)154 TEST(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
TEST(TypefaceTest,createRelativeTest_fromBoldStyled)187 TEST(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
TEST(TypefaceTest,createRelativeTest_fromItalicStyled)221 TEST(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
TEST(TypefaceTest,createRelativeTest_fromSpecifiedStyled)257 TEST(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
TEST(TypefaceTest,createAbsolute)298 TEST(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
TEST(TypefaceTest,createFromFamilies_Single)345 TEST(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
TEST(TypefaceTest,createFromFamilies_Single_resolveByTable)389 TEST(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
TEST(TypefaceTest,createFromFamilies_Family)420 TEST(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
TEST(TypefaceTest,createFromFamilies_Family_withoutRegular)430 TEST(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