automated-tests/src/dali-adaptor-internal/utc-Dali-FontClient.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   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
  18 #include <iostream>
  19
  20 #include <dali-test-suite-utils.h>
  21 #include <dali/dali.h>
  22 #include <dali/devel-api/text-abstraction/bitmap-font.h>
  23 #include <dali/devel-api/text-abstraction/font-client.h>
  24 #include <dali/internal/text/text-abstraction/plugin/font-client-utils.h>
  25 #include <stdint.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <iostream>
  29
  30 using namespace Dali;
  31
  32 int UtcDaliFontClient(void)
  33 {
  34   const int ORDERED_VALUES[] = {-1, 50, 63, 75, 87, 100, 113, 125, 150, 200};
  35
  36   const unsigned int NUM_OF_ORDERED_VALUES = sizeof(ORDERED_VALUES) / sizeof(int);
  37
  38   TestApplication application;
  39   int             result = 0;
  40
  41   tet_infoline("UtcDaliFontClient No table");
  42   result = TextAbstraction::Internal::ValueToIndex(100, NULL, 0u);
  43   DALI_TEST_EQUALS(-1, result, TEST_LOCATION);
  44
  45   tet_infoline("UtcDaliFontClient Non defined values");
  46   result = TextAbstraction::Internal::ValueToIndex(-1, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  47   DALI_TEST_EQUALS(0, result, TEST_LOCATION);
  48   result = TextAbstraction::Internal::ValueToIndex(-3, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  49   DALI_TEST_EQUALS(0, result, TEST_LOCATION);
  50
  51   tet_infoline("UtcDaliFontClient Between non defined and first of range.");
  52   result = TextAbstraction::Internal::ValueToIndex(0, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  53   DALI_TEST_EQUALS(1, result, TEST_LOCATION);
  54   result = TextAbstraction::Internal::ValueToIndex(30, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  55   DALI_TEST_EQUALS(1, result, TEST_LOCATION);
  56   result = TextAbstraction::Internal::ValueToIndex(49, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  57   DALI_TEST_EQUALS(1, result, TEST_LOCATION);
  58
  59   tet_infoline("UtcDaliFontClient Defined in range");
  60   for(unsigned int index = 1u; index < NUM_OF_ORDERED_VALUES; ++index)
  61   {
  62     result = TextAbstraction::Internal::ValueToIndex(ORDERED_VALUES[index], ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  63     DALI_TEST_EQUALS(index, result, TEST_LOCATION);
  64   }
  65
  66   tet_infoline("UtcDaliFontClient Non defined in range");
  67   result = TextAbstraction::Internal::ValueToIndex(51, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  68   DALI_TEST_EQUALS(1, result, TEST_LOCATION);
  69   result = TextAbstraction::Internal::ValueToIndex(55, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  70   DALI_TEST_EQUALS(1, result, TEST_LOCATION);
  71   result = TextAbstraction::Internal::ValueToIndex(62, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  72   DALI_TEST_EQUALS(2, result, TEST_LOCATION);
  73   result = TextAbstraction::Internal::ValueToIndex(64, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  74   DALI_TEST_EQUALS(2, result, TEST_LOCATION);
  75   result = TextAbstraction::Internal::ValueToIndex(151, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  76   DALI_TEST_EQUALS(8, result, TEST_LOCATION);
  77   result = TextAbstraction::Internal::ValueToIndex(175, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  78   DALI_TEST_EQUALS(9, result, TEST_LOCATION);
  79   result = TextAbstraction::Internal::ValueToIndex(176, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  80   DALI_TEST_EQUALS(9, result, TEST_LOCATION);
  81   result = TextAbstraction::Internal::ValueToIndex(199, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  82   DALI_TEST_EQUALS(9, result, TEST_LOCATION);
  83
  84   tet_infoline("UtcDaliFontClient above of range");
  85   result = TextAbstraction::Internal::ValueToIndex(220, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  86   DALI_TEST_EQUALS(9, result, TEST_LOCATION);
  87   result = TextAbstraction::Internal::ValueToIndex(500, ORDERED_VALUES, NUM_OF_ORDERED_VALUES - 1u);
  88   DALI_TEST_EQUALS(9, result, TEST_LOCATION);
  89
  90   END_TEST;
  91 }
  92
  93 int UtcDaliFontClientAtlasLimitation(void)
  94 {
  95   TestApplication             application;
  96   bool                        result     = 0;
  97   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
  98
  99   tet_infoline("UtcDaliFontClientAtlasLimitation Default");
 100   result = fontClient.IsAtlasLimitationEnabled();
 101   DALI_TEST_EQUALS(TextAbstraction::FontClient::DEFAULT_ATLAS_LIMITATION_ENABLED, result, TEST_LOCATION);
 102
 103   tet_infoline("UtcDaliFontClientAtlasLimitation Enabled");
 104   fontClient.EnableAtlasLimitation(true);
 105   result = fontClient.IsAtlasLimitationEnabled();
 106   DALI_TEST_EQUALS(true, result, TEST_LOCATION);
 107
 108   tet_infoline("UtcDaliFontClientAtlasLimitation Disabled");
 109   fontClient.EnableAtlasLimitation(false);
 110   result = fontClient.IsAtlasLimitationEnabled();
 111   DALI_TEST_EQUALS(false, result, TEST_LOCATION);
 112   END_TEST;
 113 }
 114
 115 const std::string DEFAULT_FONT_DIR("/resources/fonts");
 116 const uint32_t    MAX_WIDTH_FIT_IN_ATLAS  = TextAbstraction::FontClient::MAX_TEXT_ATLAS_WIDTH - TextAbstraction::FontClient::PADDING_TEXT_ATLAS_BLOCK;
 117 const uint32_t    MAX_HEIGHT_FIT_IN_ATLAS = TextAbstraction::FontClient::MAX_TEXT_ATLAS_HEIGHT - TextAbstraction::FontClient::PADDING_TEXT_ATLAS_BLOCK;
 118
 119 int UtcDaliFontClientAtlasLimitationEnabled(void)
 120 {
 121   TestApplication application;
 122
 123   char*             pathNamePtr = get_current_dir_name();
 124   const std::string pathName(pathNamePtr);
 125   free(pathNamePtr);
 126
 127   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 128   fontClient.EnableAtlasLimitation(true);
 129
 130   // The font file "DejaVuSans.ttf" is copied from Toolkit to Adaptor to make test-case of specific font-family.
 131   // Note the block size depends on font-family.
 132   // This is to create FontDescription and pass it to GetFontId with point-size (various cases).
 133   TextAbstraction::FontDescription fontDescription;
 134   fontDescription.path   = pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSans.ttf";
 135   fontDescription.family = "DejaVuSans";
 136   fontDescription.width  = TextAbstraction::FontWidth::NONE;
 137   fontDescription.weight = TextAbstraction::FontWeight::NORMAL;
 138   fontDescription.slant  = TextAbstraction::FontSlant::NONE;
 139
 140   // Block's width or height are less than 512
 141   tet_infoline("UtcDaliFontClientAtlasLimitationEnabled PointSize=200");
 142   uint32_t                                     pointSize200 = 200 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 143   TextAbstraction::FontId                      fontId200    = fontClient.GetFontId(fontDescription, pointSize200);
 144   TextAbstraction::FontClient::GlyphBufferData glyphBufferData200;
 145   glyphBufferData200.width  = 0;
 146   glyphBufferData200.height = 0;
 147   fontClient.CreateBitmap(fontId200, 68, false, false, glyphBufferData200, 0);
 148
 149   DALI_TEST_GREATER(MAX_WIDTH_FIT_IN_ATLAS, glyphBufferData200.width, TEST_LOCATION);
 150   DALI_TEST_GREATER(MAX_HEIGHT_FIT_IN_ATLAS, glyphBufferData200.height, TEST_LOCATION);
 151
 152   // Block's width or height are  greater than 512 and less than 1024
 153   uint32_t pointSize1000 = 1000 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 154   tet_infoline("UtcDaliFontClientAtlasLimitationEnabled PointSize=1000");
 155   TextAbstraction::FontId                      fontId1000 = fontClient.GetFontId(fontDescription, pointSize1000);
 156   TextAbstraction::FontClient::GlyphBufferData glyphBufferData1000;
 157   glyphBufferData1000.width  = 0;
 158   glyphBufferData1000.height = 0;
 159   fontClient.CreateBitmap(fontId1000, 68, false, false, glyphBufferData1000, 0);
 160
 161   DALI_TEST_GREATER(MAX_WIDTH_FIT_IN_ATLAS, glyphBufferData1000.width, TEST_LOCATION);
 162   DALI_TEST_GREATER(MAX_HEIGHT_FIT_IN_ATLAS, glyphBufferData1000.height, TEST_LOCATION);
 163
 164   // Block's width or height are greater than 1024 and less than 2048
 165   uint32_t pointSize2000 = 2000 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 166   tet_infoline("UtcDaliFontClientAtlasLimitationEnabled PointSize=2000");
 167   TextAbstraction::FontId                      fontId2000 = fontClient.GetFontId(fontDescription, pointSize2000);
 168   TextAbstraction::FontClient::GlyphBufferData glyphBufferData2000;
 169   glyphBufferData2000.width  = 0;
 170   glyphBufferData2000.height = 0;
 171   fontClient.CreateBitmap(fontId2000, 68, false, false, glyphBufferData2000, 0);
 172
 173   DALI_TEST_GREATER(MAX_WIDTH_FIT_IN_ATLAS, glyphBufferData2000.width, TEST_LOCATION);
 174   DALI_TEST_GREATER(MAX_HEIGHT_FIT_IN_ATLAS, glyphBufferData2000.height, TEST_LOCATION);
 175
 176   END_TEST;
 177 }
 178
 179 int UtcDaliFontClientAtlasLimitationDisabled(void)
 180 {
 181   TestApplication application;
 182
 183   char*             pathNamePtr = get_current_dir_name();
 184   const std::string pathName(pathNamePtr);
 185   free(pathNamePtr);
 186
 187   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 188   fontClient.EnableAtlasLimitation(false);
 189
 190   TextAbstraction::FontDescription fontDescription;
 191   fontDescription.path   = pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSans.ttf";
 192   fontDescription.family = "DejaVuSans";
 193   fontDescription.width  = TextAbstraction::FontWidth::NONE;
 194   fontDescription.weight = TextAbstraction::FontWeight::NORMAL;
 195   fontDescription.slant  = TextAbstraction::FontSlant::NONE;
 196
 197   // Block's width or height are less than 512
 198   tet_infoline("UtcDaliFontClientAtlasLimitationDisabled PointSize=200");
 199   uint32_t                                     pointSize200 = 200 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 200   TextAbstraction::FontId                      fontId200    = fontClient.GetFontId(fontDescription, pointSize200);
 201   TextAbstraction::FontClient::GlyphBufferData glyphBufferData200;
 202   glyphBufferData200.width  = 0;
 203   glyphBufferData200.height = 0;
 204   fontClient.CreateBitmap(fontId200, 68, false, false, glyphBufferData200, 0);
 205
 206   DALI_TEST_GREATER(512u, glyphBufferData200.width, TEST_LOCATION);  //93u
 207   DALI_TEST_GREATER(512u, glyphBufferData200.height, TEST_LOCATION); //115u
 208
 209   // Block's width or height are  greater than 512 and less than 1024
 210   tet_infoline("UtcDaliFontClientAtlasLimitationDisabled PointSize=1000");
 211   uint32_t                                     pointSize1000 = 1000 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 212   TextAbstraction::FontId                      fontId1000    = fontClient.GetFontId(fontDescription, pointSize1000);
 213   TextAbstraction::FontClient::GlyphBufferData glyphBufferData1000;
 214   glyphBufferData1000.width  = 0;
 215   glyphBufferData1000.height = 0;
 216   fontClient.CreateBitmap(fontId1000, 68, false, false, glyphBufferData1000, 0);
 217
 218   DALI_TEST_GREATER(512u, glyphBufferData1000.width, TEST_LOCATION);  //462u
 219   DALI_TEST_GREATER(glyphBufferData1000.height, 512u, TEST_LOCATION); //574u
 220
 221   // Block's width or height are greater than 1024 and less than 2048
 222   tet_infoline("UtcDaliFontClientAtlasLimitationDisabled PointSize=2000");
 223   uint32_t                                     pointSize2000 = 2000 * TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 224   TextAbstraction::FontId                      fontId2000    = fontClient.GetFontId(fontDescription, pointSize2000);
 225   TextAbstraction::FontClient::GlyphBufferData glyphBufferData2000;
 226   glyphBufferData2000.width  = 0;
 227   glyphBufferData2000.height = 0;
 228   fontClient.CreateBitmap(fontId2000, 68, false, false, glyphBufferData2000, 0);
 229
 230   DALI_TEST_GREATER(1024u, glyphBufferData2000.width, TEST_LOCATION);  //924u
 231   DALI_TEST_GREATER(glyphBufferData2000.height, 1024u, TEST_LOCATION); //1148u
 232
 233   END_TEST;
 234 }
 235
 236 int UtcDaliFontClientCurrentMaximumBlockSizeFitInAtlas(void)
 237 {
 238   TestApplication application;
 239   tet_infoline(" UtcDaliFontClientCurrentMaximumBlockSizeFitInAtlas ");
 240
 241   bool                        isChanged;
 242   TextAbstraction::FontClient fontClient;
 243   fontClient = TextAbstraction::FontClient::Get();
 244
 245   Size defaultTextAtlasSize              = fontClient.GetDefaultTextAtlasSize();
 246   Size maximumTextAtlasSize              = fontClient.GetMaximumTextAtlasSize();
 247   Size currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 248
 249   tet_infoline("CurrentMaximumBlockSizeFitInAtlas start with default ");
 250   DALI_TEST_EQUALS(currentMaximumBlockSizeFitInAtlas, defaultTextAtlasSize, TEST_LOCATION);
 251
 252   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is changed with current ");
 253   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(currentMaximumBlockSizeFitInAtlas);
 254   DALI_TEST_CHECK(isChanged);
 255
 256   Size decreaseOnlyWidth(currentMaximumBlockSizeFitInAtlas.width - 1u, currentMaximumBlockSizeFitInAtlas.height);
 257   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is changed with width < current ");
 258   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(decreaseOnlyWidth);
 259   DALI_TEST_CHECK(isChanged);
 260
 261   Size decreaseOnlyHeigth(currentMaximumBlockSizeFitInAtlas.width, currentMaximumBlockSizeFitInAtlas.height - 1u);
 262   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is changed with height < current ");
 263   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(decreaseOnlyHeigth);
 264   DALI_TEST_CHECK(isChanged);
 265
 266   Size decreaseBoth(currentMaximumBlockSizeFitInAtlas.width - 1u, currentMaximumBlockSizeFitInAtlas.height - 1u);
 267   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is changed with size < current ");
 268   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(decreaseBoth);
 269   DALI_TEST_CHECK(isChanged);
 270
 271   Size increaseOnlyWidth(maximumTextAtlasSize.width + 1u, currentMaximumBlockSizeFitInAtlas.height);
 272   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is not changed with width > max ");
 273   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(increaseOnlyWidth);
 274   DALI_TEST_CHECK(!isChanged);
 275
 276   Size increaseOnlyHeigth(currentMaximumBlockSizeFitInAtlas.width, maximumTextAtlasSize.height + 1u);
 277   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is not changed with height > max ");
 278   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(increaseOnlyHeigth);
 279   DALI_TEST_CHECK(!isChanged);
 280
 281   Size increaseBoth(maximumTextAtlasSize.width + 1u, maximumTextAtlasSize.height + 1u);
 282   tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is not changed with size > max ");
 283   isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(increaseBoth);
 284   DALI_TEST_CHECK(!isChanged);
 285
 286   currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 287   if(currentMaximumBlockSizeFitInAtlas.width < maximumTextAtlasSize.width && currentMaximumBlockSizeFitInAtlas.height < maximumTextAtlasSize.height)
 288   {
 289     tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is changed with current < size < max ");
 290     Size increaseWidth = Size(currentMaximumBlockSizeFitInAtlas.width + 1u, currentMaximumBlockSizeFitInAtlas.height);
 291     isChanged          = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(increaseWidth);
 292     DALI_TEST_CHECK(isChanged);
 293     currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 294
 295     Size increaseHeigth = Size(currentMaximumBlockSizeFitInAtlas.width, currentMaximumBlockSizeFitInAtlas.height + 1u);
 296     isChanged           = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(increaseHeigth);
 297     DALI_TEST_CHECK(isChanged);
 298     currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 299
 300     Size sizeLessThanMax = Size(currentMaximumBlockSizeFitInAtlas.width + 1u, currentMaximumBlockSizeFitInAtlas.height + 1u);
 301     isChanged            = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(sizeLessThanMax);
 302
 303     if(currentMaximumBlockSizeFitInAtlas.width < maximumTextAtlasSize.width && currentMaximumBlockSizeFitInAtlas.height < maximumTextAtlasSize.height)
 304     {
 305       DALI_TEST_CHECK(isChanged);
 306     }
 307     else
 308     {
 309       DALI_TEST_CHECK(!isChanged);
 310     }
 311
 312     currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 313
 314     DALI_TEST_NOT_EQUALS(currentMaximumBlockSizeFitInAtlas, defaultTextAtlasSize, 0.0f, TEST_LOCATION);
 315     DALI_TEST_EQUALS(currentMaximumBlockSizeFitInAtlas, sizeLessThanMax, TEST_LOCATION);
 316
 317     tet_infoline("SetCurrentMaximumBlockSizeFitInAtlas is not changed with size == max ");
 318     isChanged = fontClient.SetCurrentMaximumBlockSizeFitInAtlas(maximumTextAtlasSize);
 319     DALI_TEST_CHECK(!isChanged);
 320   }
 321
 322   currentMaximumBlockSizeFitInAtlas = fontClient.GetCurrentMaximumBlockSizeFitInAtlas();
 323   DALI_TEST_NOT_EQUALS(currentMaximumBlockSizeFitInAtlas, maximumTextAtlasSize, 0.0f, TEST_LOCATION);
 324
 325   END_TEST;
 326 }
 327
 328 int UtcDaliFontClientTextAtlasConstants(void)
 329 {
 330   TestApplication application;
 331   tet_infoline(" UtcDaliFontClientTextAtlasConstants ");
 332
 333   TextAbstraction::FontClient fontClient;
 334   fontClient = TextAbstraction::FontClient::Get();
 335
 336   Size defaultTextAtlasSize = fontClient.GetDefaultTextAtlasSize();
 337   Size defaultTextAtlasWidthHeight(TextAbstraction::FontClient::DEFAULT_TEXT_ATLAS_WIDTH, TextAbstraction::FontClient::DEFAULT_TEXT_ATLAS_HEIGHT);
 338   DALI_TEST_EQUALS(defaultTextAtlasSize, TextAbstraction::FontClient::DEFAULT_TEXT_ATLAS_SIZE, TEST_LOCATION);
 339   DALI_TEST_EQUALS(defaultTextAtlasSize, defaultTextAtlasWidthHeight, TEST_LOCATION);
 340
 341   Size maximumTextAtlasSize = fontClient.GetMaximumTextAtlasSize();
 342   Size maxTextAtlasWidthHeight(TextAbstraction::FontClient::MAX_TEXT_ATLAS_WIDTH, TextAbstraction::FontClient::MAX_TEXT_ATLAS_HEIGHT);
 343   DALI_TEST_EQUALS(maximumTextAtlasSize, TextAbstraction::FontClient::MAX_TEXT_ATLAS_SIZE, TEST_LOCATION);
 344   DALI_TEST_EQUALS(maximumTextAtlasSize, maxTextAtlasWidthHeight, TEST_LOCATION);
 345
 346   uint32_t numberOfPointsPerOneUnitOfPointSize = fontClient.GetNumberOfPointsPerOneUnitOfPointSize();
 347   DALI_TEST_EQUALS(numberOfPointsPerOneUnitOfPointSize, TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE, TEST_LOCATION);
 348
 349   END_TEST;
 350 }
 351
 352 using namespace Dali::TextAbstraction;
 353
 354 int UtcDaliFontClientGetDefaultFonts(void)
 355 {
 356   TestApplication application;
 357   tet_infoline(" UtcDaliFontClientGetDefaultFonts ");
 358
 359   FontClient fontClient;
 360   fontClient = FontClient::Get();
 361
 362   FontList fontList;
 363   fontClient.GetDefaultFonts(fontList);
 364
 365   std::ostringstream oss;
 366   oss << fontList << std::endl;
 367
 368   tet_printf("FontList: %s", oss.str().c_str());
 369   DALI_TEST_CHECK(fontList.size() > 0);
 370
 371   END_TEST;
 372 }
 373
 374 int UtcDaliFontClientGetSystemFonts(void)
 375 {
 376   TestApplication application;
 377   tet_infoline(" UtcDaliFontClientGetSystemFonts ");
 378
 379   FontClient fontClient;
 380   fontClient = FontClient::Get();
 381
 382   FontList fontList;
 383   fontClient.GetSystemFonts(fontList);
 384
 385   std::ostringstream oss;
 386   oss << fontList << std::endl;
 387
 388   tet_printf("FontList: %s", oss.str().c_str());
 389   DALI_TEST_CHECK(fontList.size() > 0);
 390
 391   const PointSize26Dot6 pointSize = fontClient.GetPointSize(fontList.size());
 392   DALI_TEST_EQUALS(pointSize, FontClient::DEFAULT_POINT_SIZE, TEST_LOCATION);
 393
 394   END_TEST;
 395 }
 396
 397 std::ostream& operator<<(std::ostream& o, const FontDescription& description)
 398 {
 399   o << "Font path: " << description.path << " family: "
 400     << " width : " << description.width << " weight : " << description.weight << " slant : " << description.slant << std::endl;
 401   return o;
 402 }
 403
 404 int UtcDaliFontClientGetDefaultPlatformFontDescription(void)
 405 {
 406   TestApplication application;
 407   tet_infoline(" UtcDaliFontClientGetDefaultPlatformFontDescription");
 408
 409   FontClient fontClient;
 410   fontClient = FontClient::Get();
 411
 412   FontDescription fontDescription;
 413   fontClient.GetDefaultPlatformFontDescription(fontDescription);
 414
 415   std::ostringstream oss;
 416   oss << fontDescription;
 417   tet_printf("%s", oss.str().c_str());
 418
 419   DALI_TEST_CHECK(fontDescription.path.empty() == false);
 420
 421   FontId fontId = fontClient.FindFallbackFont('A',
 422                                               fontDescription,
 423                                               FontClient::DEFAULT_POINT_SIZE,
 424                                               true);
 425
 426   bool supported = fontClient.IsCharacterSupportedByFont(fontId, 'A');
 427   DALI_TEST_EQUALS(supported, true, TEST_LOCATION);
 428   END_TEST;
 429 }
 430
 431 namespace
 432 {
 433 constexpr uint8_t U1               = 1u;
 434 constexpr uint8_t U2               = 2u;
 435 constexpr uint8_t U3               = 3u;
 436 constexpr uint8_t U4               = 4u;
 437 constexpr uint8_t U5               = 5u;
 438 constexpr uint8_t U6               = 6u;
 439 constexpr uint8_t U0               = 0u;
 440 constexpr uint8_t UTF8_LENGTH[256] = {
 441   U1, U1, U1, U1, U1, U1, U1, U1, U1, U1, //
 442   U1,
 443   U1,
 444   U1,
 445   U1,
 446   U1,
 447   U1,
 448   U1,
 449   U1,
 450   U1,
 451   U1, //
 452   U1,
 453   U1,
 454   U1,
 455   U1,
 456   U1,
 457   U1,
 458   U1,
 459   U1,
 460   U1,
 461   U1, //
 462   U1,
 463   U1,
 464   U1,
 465   U1,
 466   U1,
 467   U1,
 468   U1,
 469   U1,
 470   U1,
 471   U1, //
 472   U1,
 473   U1,
 474   U1,
 475   U1,
 476   U1,
 477   U1,
 478   U1,
 479   U1,
 480   U1,
 481   U1, //
 482   U1,
 483   U1,
 484   U1,
 485   U1,
 486   U1,
 487   U1,
 488   U1,
 489   U1,
 490   U1,
 491   U1, //
 492   U1,
 493   U1,
 494   U1,
 495   U1,
 496   U1,
 497   U1,
 498   U1,
 499   U1,
 500   U1,
 501   U1, //
 502   U1,
 503   U1,
 504   U1,
 505   U1,
 506   U1,
 507   U1,
 508   U1,
 509   U1,
 510   U1,
 511   U1, //
 512   U1,
 513   U1,
 514   U1,
 515   U1,
 516   U1,
 517   U1,
 518   U1,
 519   U1,
 520   U1,
 521   U1, // lead byte = 0xxx xxxx (U+0000 - U+007F + some extended ascii characters)
 522   U1,
 523   U1,
 524   U1,
 525   U1,
 526   U1,
 527   U1,
 528   U1,
 529   U1,
 530   U1,
 531   U1, //
 532   U1,
 533   U1,
 534   U1,
 535   U1,
 536   U1,
 537   U1,
 538   U1,
 539   U1,
 540   U1,
 541   U1, //
 542   U1,
 543   U1,
 544   U1,
 545   U1,
 546   U1,
 547   U1,
 548   U1,
 549   U1,
 550   U1,
 551   U1, //
 552   U1,
 553   U1,
 554   U1,
 555   U1,
 556   U1,
 557   U1,
 558   U1,
 559   U1,
 560   U1,
 561   U1, //
 562   U1,
 563   U1,
 564   U1,
 565   U1,
 566   U1,
 567   U1,
 568   U1,
 569   U1,
 570   U1,
 571   U1, //
 572   U1,
 573   U1,
 574   U1,
 575   U1,
 576   U1,
 577   U1,
 578   U1,
 579   U1,
 580   U1,
 581   U1, //
 582   U1,
 583   U1,
 584   U1,
 585   U1,
 586   U1,
 587   U1,
 588   U1,
 589   U1,
 590   U1,
 591   U1, //
 592   U1,
 593   U1,
 594   U1,
 595   U1,
 596   U1,
 597   U1,
 598   U1,
 599   U1,
 600   U1,
 601   U1, //
 602   U1,
 603   U1,
 604   U1,
 605   U1,
 606   U1,
 607   U1,
 608   U1,
 609   U1,
 610   U1,
 611   U1, //
 612   U1,
 613   U1,
 614   U1,
 615   U1,
 616   U1,
 617   U1,
 618   U1,
 619   U1,
 620   U1,
 621   U1, //
 622   U1,
 623   U1, //
 624
 625   U2,
 626   U2,
 627   U2,
 628   U2,
 629   U2,
 630   U2,
 631   U2,
 632   U2,
 633   U2,
 634   U2, //
 635   U2,
 636   U2,
 637   U2,
 638   U2,
 639   U2,
 640   U2,
 641   U2,
 642   U2,
 643   U2,
 644   U2, // lead byte = 110x xxxx (U+0080 - U+07FF)
 645   U2,
 646   U2,
 647   U2,
 648   U2,
 649   U2,
 650   U2,
 651   U2,
 652   U2,
 653   U2,
 654   U2, //
 655   U2,
 656   U2, //
 657
 658   U3,
 659   U3,
 660   U3,
 661   U3,
 662   U3,
 663   U3,
 664   U3,
 665   U3,
 666   U3,
 667   U3, // lead byte = 1110 xxxx (U+0800 - U+FFFF)
 668   U3,
 669   U3,
 670   U3,
 671   U3,
 672   U3,
 673   U3, //
 674
 675   U4,
 676   U4,
 677   U4,
 678   U4,
 679   U4,
 680   U4,
 681   U4,
 682   U4, // lead byte = 1111 0xxx (U+10000 - U+1FFFFF)
 683
 684   U5,
 685   U5,
 686   U5,
 687   U5, // lead byte = 1111 10xx (U+200000 - U+3FFFFFF)
 688
 689   U6,
 690   U6, // lead byte = 1111 110x (U+4000000 - U+7FFFFFFF)
 691
 692   U0,
 693   U0, // Non valid.
 694 };
 695
 696 constexpr uint8_t CR = 0xd;
 697 constexpr uint8_t LF = 0xa;
 698
 699 uint8_t GetUtf8Length(uint8_t utf8LeadByte)
 700 {
 701   return UTF8_LENGTH[utf8LeadByte];
 702 }
 703
 704 uint32_t Utf8ToUtf32(const uint8_t* const utf8, uint32_t length, uint32_t* utf32)
 705 {
 706   uint32_t numberOfCharacters = 0u;
 707
 708   const uint8_t* begin = utf8;
 709   const uint8_t* end   = utf8 + length;
 710
 711   for(; begin < end; ++numberOfCharacters)
 712   {
 713     const uint8_t leadByte = *begin;
 714
 715     switch(UTF8_LENGTH[leadByte])
 716     {
 717       case U1:
 718       {
 719         if(CR == leadByte)
 720         {
 721           // Replace CR+LF or CR by LF
 722           *utf32++ = LF;
 723
 724           // Look ahead if the next one is a LF.
 725           ++begin;
 726           if(begin < end)
 727           {
 728             if(LF == *begin)
 729             {
 730               ++begin;
 731             }
 732           }
 733         }
 734         else
 735         {
 736           *utf32++ = leadByte;
 737           begin++;
 738         }
 739         break;
 740       }
 741
 742       case U2:
 743       {
 744         uint32_t& code = *utf32++;
 745         code           = leadByte & 0x1fu;
 746         begin++;
 747         code <<= 6u;
 748         code |= *begin++ & 0x3fu;
 749         break;
 750       }
 751
 752       case U3:
 753       {
 754         uint32_t& code = *utf32++;
 755         code           = leadByte & 0x0fu;
 756         begin++;
 757         code <<= 6u;
 758         code |= *begin++ & 0x3fu;
 759         code <<= 6u;
 760         code |= *begin++ & 0x3fu;
 761         break;
 762       }
 763
 764       case U4:
 765       {
 766         uint32_t& code = *utf32++;
 767         code           = leadByte & 0x07u;
 768         begin++;
 769         code <<= 6u;
 770         code |= *begin++ & 0x3fu;
 771         code <<= 6u;
 772         code |= *begin++ & 0x3fu;
 773         code <<= 6u;
 774         code |= *begin++ & 0x3fu;
 775         break;
 776       }
 777
 778       case U5:
 779       {
 780         uint32_t& code = *utf32++;
 781         code           = leadByte & 0x03u;
 782         begin++;
 783         code <<= 6u;
 784         code |= *begin++ & 0x3fu;
 785         code <<= 6u;
 786         code |= *begin++ & 0x3fu;
 787         code <<= 6u;
 788         code |= *begin++ & 0x3fu;
 789         code <<= 6u;
 790         code |= *begin++ & 0x3fu;
 791         break;
 792       }
 793
 794       case U6:
 795       {
 796         uint32_t& code = *utf32++;
 797         code           = leadByte & 0x01u;
 798         begin++;
 799         code <<= 6u;
 800         code |= *begin++ & 0x3fu;
 801         code <<= 6u;
 802         code |= *begin++ & 0x3fu;
 803         code <<= 6u;
 804         code |= *begin++ & 0x3fu;
 805         code <<= 6u;
 806         code |= *begin++ & 0x3fu;
 807         code <<= 6u;
 808         code |= *begin++ & 0x3fu;
 809         break;
 810       }
 811
 812       case U0: // Invalid case
 813       {
 814         begin++;
 815         *utf32++ = 0x20; // Use white space
 816         break;
 817       }
 818     }
 819   }
 820
 821   return numberOfCharacters;
 822 }
 823
 824 TextAbstraction::FontId SetupBitmapFont()
 825 {
 826   struct GlyphDesc
 827   {
 828     GlyphDesc()
 829     {
 830     }
 831     GlyphDesc(const std::string& url, const std::string& utf8)
 832     {
 833       this->url = url;
 834       std::copy(utf8.begin(), utf8.end(), this->utf8);
 835     }
 836     std::string url;
 837     uint8_t     utf8[4];
 838   };
 839   std::vector<GlyphDesc> glyphs;
 840
 841   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0030.png", ":"});
 842   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0031.png", "0"});
 843   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0032.png", "1"});
 844   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0033.png", "2"});
 845   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0034.png", "3"});
 846   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0035.png", "4"});
 847   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0036.png", "5"});
 848   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0037.png", "6"});
 849   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0038.png", "7"});
 850   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0039.png", "8"});
 851   glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u003a.png", "9"});
 852
 853   TextAbstraction::BitmapFont bitmapFont;
 854   bitmapFont.glyphs.reserve(glyphs.size());
 855   bitmapFont.name               = "Digits";
 856   bitmapFont.underlinePosition  = 0.f;
 857   bitmapFont.underlineThickness = 0.f;
 858   bitmapFont.isColorFont        = true;
 859
 860   for(const auto& glyph : glyphs)
 861   {
 862     uint32_t c = 0u;
 863     Utf8ToUtf32(glyph.utf8, GetUtf8Length(glyph.utf8[0u]), &c);
 864     TextAbstraction::BitmapGlyph bitmapGlyph(glyph.url, c, 34.f, 0.f);
 865     bitmapFont.glyphs.push_back(std::move(bitmapGlyph));
 866   }
 867
 868   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 869   return fontClient.GetFontId(bitmapFont);
 870 }
 871
 872 } // namespace
 873
 874 int UtcDaliFontClientTestBitmapFont(void)
 875 {
 876   TestApplication application;
 877   tet_infoline(" UtcDaliFontClientTestBitmapFont");
 878
 879   FontClient fontClient;
 880   fontClient = FontClient::Get();
 881
 882   auto bitmapFontId = SetupBitmapFont();
 883
 884   FontDescription fontDescription;
 885   fontClient.GetDescription(bitmapFontId, fontDescription);
 886   std::ostringstream oss;
 887   oss << fontDescription;
 888   tet_printf("Found: %d: %s", bitmapFontId, oss.str().c_str());
 889
 890   bool color = fontClient.IsColorGlyph(bitmapFontId, fontClient.GetGlyphIndex(bitmapFontId, '2'));
 891   DALI_TEST_EQUALS(color, true, TEST_LOCATION);
 892
 893   DALI_TEST_EQUALS(fontClient.GetPointSize(bitmapFontId), FontClient::DEFAULT_POINT_SIZE, TEST_LOCATION);
 894
 895   DALI_TEST_EQUALS(fontClient.IsCharacterSupportedByFont(bitmapFontId, '3'), true, TEST_LOCATION);
 896   DALI_TEST_EQUALS(fontClient.IsCharacterSupportedByFont(bitmapFontId, 'a'), false, TEST_LOCATION);
 897
 898   END_TEST;
 899 }