libs/hwui/tests/unit/TypefaceTests.cpp

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