automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp

   1 /*
   2  * Copyright (c) 2022 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 <stdlib.h>
  19 #include <unistd.h>
  20 #include <iostream>
  21
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <dali-toolkit/dali-toolkit.h>
  24 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
  25 #include <dali-toolkit/devel-api/controls/text-controls/text-style-properties-devel.h>
  26 #include <dali-toolkit/devel-api/text/bitmap-font.h>
  27 #include <dali-toolkit/devel-api/text/rendering-backend.h>
  28 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
  29 #include <dali-toolkit/devel-api/text/text-utils-devel.h>
  30 #include <dali/devel-api/adaptor-framework/image-loading.h>
  31 #include <dali/devel-api/text-abstraction/bitmap-font.h>
  32 #include <dali/devel-api/text-abstraction/font-client.h>
  33 #include "test-text-geometry-utils.h"
  34
  35 using namespace Dali;
  36 using namespace Toolkit;
  37
  38 void dali_textlabel_startup(void)
  39 {
  40   test_return_value = TET_UNDEF;
  41 }
  42
  43 void dali_textlabel_cleanup(void)
  44 {
  45   test_return_value = TET_PASS;
  46 }
  47
  48 namespace
  49 {
  50 const char* const PROPERTY_NAME_RENDERING_BACKEND        = "renderingBackend";
  51 const char* const PROPERTY_NAME_TEXT                     = "text";
  52 const char* const PROPERTY_NAME_FONT_FAMILY              = "fontFamily";
  53 const char* const PROPERTY_NAME_FONT_STYLE               = "fontStyle";
  54 const char* const PROPERTY_NAME_POINT_SIZE               = "pointSize";
  55 const char* const PROPERTY_NAME_MULTI_LINE               = "multiLine";
  56 const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT     = "horizontalAlignment";
  57 const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT       = "verticalAlignment";
  58 const char* const PROPERTY_NAME_TEXT_COLOR               = "textColor";
  59 const char* const PROPERTY_NAME_ENABLE_MARKUP            = "enableMarkup";
  60 const char* const PROPERTY_NAME_ENABLE_AUTO_SCROLL       = "enableAutoScroll";
  61 const char* const PROPERTY_NAME_ENABLE_AUTO_SCROLL_SPEED = "autoScrollSpeed";
  62 const char* const PROPERTY_NAME_ENABLE_AUTO_SCROLL_LOOPS = "autoScrollLoopCount";
  63 const char* const PROPERTY_NAME_ENABLE_AUTO_SCROLL_GAP   = "autoScrollGap";
  64
  65 const char* const PROPERTY_NAME_LINE_SPACING  = "lineSpacing";
  66 const char* const PROPERTY_NAME_UNDERLINE     = "underline";
  67 const char* const PROPERTY_NAME_SHADOW        = "shadow";
  68 const char* const PROPERTY_NAME_EMBOSS        = "emboss";
  69 const char* const PROPERTY_NAME_OUTLINE       = "outline";
  70 const char* const PROPERTY_NAME_BACKGROUND    = "textBackground";
  71 const char* const PROPERTY_NAME_STRIKETHROUGH = "strikethrough";
  72
  73 const char* const PROPERTY_NAME_PIXEL_SIZE             = "pixelSize";
  74 const char* const PROPERTY_NAME_ELLIPSIS               = "ellipsis";
  75 const char* const PROPERTY_NAME_AUTO_SCROLL_LOOP_DELAY = "autoScrollLoopDelay";
  76 const char* const PROPERTY_NAME_FONT_SIZE_SCALE        = "fontSizeScale";
  77 const char* const PROPERTY_NAME_ENABLE_FONT_SIZE_SCALE = "enableFontSizeScale";
  78
  79 const char* const PROPERTY_NAME_ELLIPSIS_POSITION = "ellipsisPosition";
  80
  81 const std::string  DEFAULT_FONT_DIR("/resources/fonts");
  82 const unsigned int EMOJI_FONT_SIZE = 3840u; // 60 * 64
  83
  84 static bool gAnchorClickedCallBackCalled;
  85 static bool gAnchorClickedCallBackNotCalled;
  86
  87 static bool gTextFitChangedCallBackCalled;
  88
  89 struct CallbackFunctor
  90 {
  91   CallbackFunctor(bool* callbackFlag)
  92   : mCallbackFlag(callbackFlag)
  93   {
  94   }
  95
  96   void operator()()
  97   {
  98     *mCallbackFlag = true;
  99   }
 100   bool* mCallbackFlag;
 101 };
 102
 103 static void TestAnchorClickedCallback(TextLabel control, const char* href, unsigned int hrefLength)
 104 {
 105   tet_infoline(" TestAnchorClickedCallback");
 106
 107   gAnchorClickedCallBackNotCalled = false;
 108
 109   if(!strcmp(href, "https://www.tizen.org") && hrefLength == strlen(href))
 110   {
 111     gAnchorClickedCallBackCalled = true;
 112   }
 113 }
 114
 115 static void TestTextFitChangedCallback(TextLabel control)
 116 {
 117   tet_infoline(" TestTextFitChangedCallback");
 118   gTextFitChangedCallBackCalled = true;
 119 }
 120
 121 bool DaliTestCheckMaps(const Property::Map& mapGet, const Property::Map& mapSet, const std::vector<std::string>& indexConversionTable = std::vector<std::string>())
 122 {
 123   const Property::Map::SizeType size = mapGet.Count();
 124
 125   if(size == mapSet.Count())
 126   {
 127     for(unsigned int index = 0u; index < size; ++index)
 128     {
 129       const KeyValuePair& valueGet = mapGet.GetKeyValue(index);
 130
 131       // Find the keys of the 'get' map
 132       Property::Index indexKey  = valueGet.first.indexKey;
 133       std::string     stringKey = valueGet.first.stringKey;
 134
 135       if(!indexConversionTable.empty())
 136       {
 137         if(stringKey.empty())
 138         {
 139           stringKey = indexConversionTable[indexKey];
 140         }
 141
 142         if((indexKey == Property::INVALID_INDEX) && !stringKey.empty())
 143         {
 144           Property::Index index = 0u;
 145           for(auto key : indexConversionTable)
 146           {
 147             if(key == stringKey)
 148             {
 149               indexKey = index;
 150               break;
 151             }
 152             ++index;
 153           }
 154         }
 155       }
 156
 157       const Property::Value* const valueSet = mapSet.Find(indexKey, stringKey);
 158
 159       if(nullptr != valueSet)
 160       {
 161         if((valueSet->GetType() == Dali::Property::STRING) && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
 162         {
 163           tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
 164           return false;
 165         }
 166         else if((valueSet->GetType() == Dali::Property::BOOLEAN) && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
 167         {
 168           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
 169           return false;
 170         }
 171         else if((valueSet->GetType() == Dali::Property::INTEGER) && (valueGet.second.Get<int>() != valueSet->Get<int>()))
 172         {
 173           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
 174           return false;
 175         }
 176         else if((valueSet->GetType() == Dali::Property::FLOAT) && (valueGet.second.Get<float>() != valueSet->Get<float>()))
 177         {
 178           tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
 179           return false;
 180         }
 181         else if((valueSet->GetType() == Dali::Property::VECTOR2) && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
 182         {
 183           Vector2 vector2Get = valueGet.second.Get<Vector2>();
 184           Vector2 vector2Set = valueSet->Get<Vector2>();
 185           tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
 186           return false;
 187         }
 188         else if((valueSet->GetType() == Dali::Property::VECTOR4) && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
 189         {
 190           Vector4 vector4Get = valueGet.second.Get<Vector4>();
 191           Vector4 vector4Set = valueSet->Get<Vector4>();
 192           tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
 193           return false;
 194         }
 195       }
 196       else
 197       {
 198         if(valueGet.first.type == Property::Key::INDEX)
 199         {
 200           tet_printf("  The key %d doesn't exist.", valueGet.first.indexKey);
 201         }
 202         else
 203         {
 204           tet_printf("  The key %s doesn't exist.", valueGet.first.stringKey.c_str());
 205         }
 206         return false;
 207       }
 208     }
 209   }
 210
 211   return true;
 212 }
 213
 214 } // namespace
 215
 216 int UtcDaliToolkitTextLabelConstructorP(void)
 217 {
 218   ToolkitTestApplication application;
 219   tet_infoline(" UtcDaliToolkitTextLabelConstructorP");
 220   TextLabel textLabel;
 221   DALI_TEST_CHECK(!textLabel);
 222   END_TEST;
 223 }
 224
 225 int UtcDaliToolkitTextLabelNewP(void)
 226 {
 227   ToolkitTestApplication application;
 228   tet_infoline(" UtcDaliToolkitTextLabelNewP");
 229   TextLabel textLabel = TextLabel::New("Test Text");
 230   DALI_TEST_CHECK(textLabel);
 231   END_TEST;
 232 }
 233
 234 int UtcDaliToolkitTextLabelDownCastP(void)
 235 {
 236   ToolkitTestApplication application;
 237   tet_infoline(" UtcDaliToolkitTextLabelDownCastP");
 238   TextLabel  textLabel1 = TextLabel::New();
 239   BaseHandle object(textLabel1);
 240
 241   TextLabel textLabel2 = TextLabel::DownCast(object);
 242   DALI_TEST_CHECK(textLabel2);
 243
 244   TextLabel textLabel3 = DownCast<TextLabel>(object);
 245   DALI_TEST_CHECK(textLabel3);
 246   END_TEST;
 247 }
 248
 249 int UtcDaliToolkitTextLabelDownCastN(void)
 250 {
 251   ToolkitTestApplication application;
 252   tet_infoline(" UtcDaliToolkitTextLabelDownCastN");
 253   BaseHandle uninitializedObject;
 254   TextLabel  textLabel1 = TextLabel::DownCast(uninitializedObject);
 255   DALI_TEST_CHECK(!textLabel1);
 256
 257   TextLabel textLabel2 = DownCast<TextLabel>(uninitializedObject);
 258   DALI_TEST_CHECK(!textLabel2);
 259   END_TEST;
 260 }
 261
 262 int UtcDaliToolkitTextLabelCopyConstructorP(void)
 263 {
 264   ToolkitTestApplication application;
 265   tet_infoline(" UtcDaliToolkitTextLabelCopyConstructorP");
 266   TextLabel textLabel = TextLabel::New();
 267   textLabel.SetProperty(TextLabel::Property::TEXT_COLOR, Color::RED);
 268
 269   TextLabel copy(textLabel);
 270   DALI_TEST_CHECK(copy);
 271   DALI_TEST_CHECK(copy.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR) == textLabel.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR));
 272   END_TEST;
 273 }
 274
 275 int UtcDaliTextLabelMoveConstructor(void)
 276 {
 277   ToolkitTestApplication application;
 278
 279   TextLabel textLabel = TextLabel::New();
 280   textLabel.SetProperty(TextLabel::Property::TEXT, "Test");
 281   DALI_TEST_CHECK(textLabel.GetProperty<std::string>(TextLabel::Property::TEXT) == "Test");
 282
 283   TextLabel moved = std::move(textLabel);
 284   DALI_TEST_CHECK(moved);
 285   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 286   DALI_TEST_CHECK(moved.GetProperty<std::string>(TextLabel::Property::TEXT) == "Test");
 287   DALI_TEST_CHECK(!textLabel);
 288
 289   END_TEST;
 290 }
 291
 292 int UtcDaliToolkitTextLabelAssignmentOperatorP(void)
 293 {
 294   ToolkitTestApplication application;
 295   tet_infoline(" UtcDaliToolkitTextLabelAssingmentOperatorP");
 296   TextLabel textLabel = TextLabel::New();
 297   textLabel.SetProperty(TextLabel::Property::TEXT_COLOR, Color::RED);
 298
 299   TextLabel copy = textLabel;
 300   DALI_TEST_CHECK(copy);
 301   DALI_TEST_CHECK(copy.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR) == textLabel.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR));
 302   END_TEST;
 303 }
 304
 305 int UtcDaliTextLabelMoveAssignment(void)
 306 {
 307   ToolkitTestApplication application;
 308
 309   TextLabel textLabel = TextLabel::New();
 310   textLabel.SetProperty(TextLabel::Property::TEXT, "Test");
 311   DALI_TEST_CHECK(textLabel.GetProperty<std::string>(TextLabel::Property::TEXT) == "Test");
 312
 313   TextLabel moved;
 314   moved = std::move(textLabel);
 315   DALI_TEST_CHECK(moved);
 316   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 317   DALI_TEST_CHECK(moved.GetProperty<std::string>(TextLabel::Property::TEXT) == "Test");
 318   DALI_TEST_CHECK(!textLabel);
 319
 320   END_TEST;
 321 }
 322
 323 // Positive test case for a method
 324 int UtcDaliToolkitTextLabelGetPropertyP(void)
 325 {
 326   ToolkitTestApplication application;
 327   tet_infoline(" UtcDaliToolkitTextLabelGetPropertyP");
 328   TextLabel label = TextLabel::New("Test Text");
 329   DALI_TEST_CHECK(label);
 330
 331   // Check Property Indices are correct
 332   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_RENDERING_BACKEND) == DevelTextLabel::Property::RENDERING_BACKEND);
 333   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_TEXT) == TextLabel::Property::TEXT);
 334   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_FONT_FAMILY) == TextLabel::Property::FONT_FAMILY);
 335   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_FONT_STYLE) == TextLabel::Property::FONT_STYLE);
 336   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_POINT_SIZE) == TextLabel::Property::POINT_SIZE);
 337   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_MULTI_LINE) == TextLabel::Property::MULTI_LINE);
 338   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_HORIZONTAL_ALIGNMENT) == TextLabel::Property::HORIZONTAL_ALIGNMENT);
 339   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_VERTICAL_ALIGNMENT) == TextLabel::Property::VERTICAL_ALIGNMENT);
 340   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_TEXT_COLOR) == TextLabel::Property::TEXT_COLOR);
 341   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_MARKUP) == TextLabel::Property::ENABLE_MARKUP);
 342   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_AUTO_SCROLL) == TextLabel::Property::ENABLE_AUTO_SCROLL);
 343   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_AUTO_SCROLL_SPEED) == TextLabel::Property::AUTO_SCROLL_SPEED);
 344   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_AUTO_SCROLL_LOOPS) == TextLabel::Property::AUTO_SCROLL_LOOP_COUNT);
 345   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_AUTO_SCROLL_GAP) == TextLabel::Property::AUTO_SCROLL_GAP);
 346   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_LINE_SPACING) == TextLabel::Property::LINE_SPACING);
 347   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_UNDERLINE) == TextLabel::Property::UNDERLINE);
 348   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_SHADOW) == TextLabel::Property::SHADOW);
 349   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_EMBOSS) == TextLabel::Property::EMBOSS);
 350   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_OUTLINE) == TextLabel::Property::OUTLINE);
 351   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_BACKGROUND) == DevelTextLabel::Property::BACKGROUND);
 352   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_PIXEL_SIZE) == TextLabel::Property::PIXEL_SIZE);
 353   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ELLIPSIS) == TextLabel::Property::ELLIPSIS);
 354   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_AUTO_SCROLL_LOOP_DELAY) == TextLabel::Property::AUTO_SCROLL_LOOP_DELAY);
 355   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_FONT_SIZE_SCALE) == DevelTextLabel::Property::FONT_SIZE_SCALE);
 356   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ENABLE_FONT_SIZE_SCALE) == DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE);
 357   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_ELLIPSIS_POSITION) == DevelTextLabel::Property::ELLIPSIS_POSITION);
 358   DALI_TEST_CHECK(label.GetPropertyIndex(PROPERTY_NAME_STRIKETHROUGH) == DevelTextLabel::Property::STRIKETHROUGH);
 359
 360   END_TEST;
 361 }
 362
 363 int UtcDaliToolkitTextLabelSetPropertyP(void)
 364 {
 365   ToolkitTestApplication application;
 366   tet_infoline(" UtcDaliToolkitTextLabelSetPropertyP");
 367   TextLabel label = TextLabel::New();
 368   DALI_TEST_CHECK(label);
 369
 370   application.GetScene().Add(label);
 371
 372   // Note - we can't check the defaults since the stylesheets are platform-specific
 373   label.SetProperty(DevelTextLabel::Property::RENDERING_BACKEND, DevelText::RENDERING_SHARED_ATLAS);
 374   DALI_TEST_EQUALS((DevelText::RenderingType)label.GetProperty<int>(DevelTextLabel::Property::RENDERING_BACKEND), DevelText::RENDERING_SHARED_ATLAS, TEST_LOCATION);
 375
 376   // Check that text can be correctly reset
 377   label.SetProperty(TextLabel::Property::TEXT, "Setting Text");
 378   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::TEXT), std::string("Setting Text"), TEST_LOCATION);
 379
 380   // Check font properties.
 381   label.SetProperty(TextLabel::Property::FONT_FAMILY, "Setting font family");
 382   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::FONT_FAMILY), std::string("Setting font family"), TEST_LOCATION);
 383
 384   Property::Map fontStyleMapSet;
 385   Property::Map fontStyleMapGet;
 386
 387   fontStyleMapSet.Insert("weight", "bold");
 388   fontStyleMapSet.Insert("width", "condensed");
 389   fontStyleMapSet.Insert("slant", "italic");
 390   label.SetProperty(TextLabel::Property::FONT_STYLE, fontStyleMapSet);
 391
 392   fontStyleMapGet = label.GetProperty<Property::Map>(TextLabel::Property::FONT_STYLE);
 393   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
 394   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
 395
 396   // Check the old font style format.
 397   fontStyleMapSet.Clear();
 398   fontStyleMapSet.Insert("weight", "thin");
 399   fontStyleMapSet.Insert("width", "expanded");
 400   fontStyleMapSet.Insert("slant", "oblique");
 401   const std::string strFontStyle = "{\"weight\":\"thin\",\"width\":\"expanded\",\"slant\":\"oblique\"}";
 402
 403   label.SetProperty(TextLabel::Property::FONT_STYLE, "{\"weight\":\"thin\",\"width\":\"expanded\",\"slant\":\"oblique\"}");
 404   std::string getFontStyle = label.GetProperty<std::string>(TextLabel::Property::FONT_STYLE);
 405   DALI_TEST_EQUALS(getFontStyle, strFontStyle, TEST_LOCATION);
 406
 407   label.SetProperty(TextLabel::Property::POINT_SIZE, 10.f);
 408   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::POINT_SIZE), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 409
 410   label.SetProperty(DevelTextLabel::Property::FONT_SIZE_SCALE, 2.5f);
 411   DALI_TEST_EQUALS(label.GetProperty<float>(DevelTextLabel::Property::FONT_SIZE_SCALE), 2.5f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 412   label.SetProperty(DevelTextLabel::Property::FONT_SIZE_SCALE, 1.0f);
 413
 414   label.SetProperty(DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE, false);
 415   DALI_TEST_EQUALS(label.GetProperty<bool>(DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE), false, TEST_LOCATION);
 416   label.SetProperty(DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE, true);
 417
 418   // Reset font style.
 419   fontStyleMapSet.Clear();
 420   fontStyleMapSet.Insert("weight", "normal");
 421   fontStyleMapSet.Insert("slant", "oblique");
 422
 423   label.SetProperty(TextLabel::Property::FONT_STYLE, fontStyleMapSet);
 424   fontStyleMapGet = label.GetProperty<Property::Map>(TextLabel::Property::FONT_STYLE);
 425   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
 426   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
 427
 428   fontStyleMapSet.Clear();
 429   fontStyleMapSet.Insert("slant", "roman");
 430
 431   label.SetProperty(TextLabel::Property::FONT_STYLE, fontStyleMapSet);
 432   fontStyleMapGet = label.GetProperty<Property::Map>(TextLabel::Property::FONT_STYLE);
 433   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
 434
 435   // Replace 'roman' for 'normal'.
 436   Property::Value* slantValue = fontStyleMapGet.Find("slant");
 437   if(NULL != slantValue)
 438   {
 439     if("normal" == slantValue->Get<std::string>())
 440     {
 441       fontStyleMapGet["slant"] = "roman";
 442     }
 443   }
 444   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
 445
 446   fontStyleMapSet.Clear();
 447
 448   label.SetProperty(TextLabel::Property::FONT_STYLE, fontStyleMapSet);
 449   fontStyleMapGet = label.GetProperty<Property::Map>(TextLabel::Property::FONT_STYLE);
 450   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
 451   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
 452
 453   // Toggle multi-line
 454   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
 455   DALI_TEST_EQUALS(label.GetProperty<bool>(TextLabel::Property::MULTI_LINE), true, TEST_LOCATION);
 456
 457   // Check that the Alignment properties can be correctly set
 458   label.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
 459   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::HORIZONTAL_ALIGNMENT), "CENTER", TEST_LOCATION);
 460   label.SetProperty(TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER");
 461   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::VERTICAL_ALIGNMENT), "CENTER", TEST_LOCATION);
 462
 463   // Check that text color can be properly set
 464   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::BLUE);
 465   DALI_TEST_EQUALS(label.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR), Color::BLUE, TEST_LOCATION);
 466
 467   Property::Map strikethroughMapSet;
 468   Property::Map strikethroughMapGet;
 469
 470   strikethroughMapSet.Insert("enable", false);
 471   strikethroughMapSet.Insert("color", Color::BLUE);
 472   strikethroughMapSet.Insert("height", 2.0f);
 473
 474   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
 475
 476   strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
 477   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
 478   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
 479
 480   Property::Map underlineMapSet;
 481   Property::Map underlineMapGet;
 482
 483   underlineMapSet.Insert("enable", false);
 484   underlineMapSet.Insert("color", Color::BLUE);
 485   underlineMapSet.Insert("height", 0);
 486   underlineMapSet.Insert("type", Text::Underline::SOLID);
 487   underlineMapSet.Insert("dashWidth", 2);
 488   underlineMapSet.Insert("dashGap", 1);
 489
 490   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 491
 492   application.SendNotification();
 493   application.Render();
 494
 495   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 496   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 497   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 498
 499   //DASHED Underline
 500   underlineMapSet.Clear();
 501   underlineMapGet.Clear();
 502
 503   underlineMapSet.Insert("enable", false);
 504   underlineMapSet.Insert("color", Color::BLUE);
 505   underlineMapSet.Insert("height", 0);
 506   underlineMapSet.Insert("type", Text::Underline::DASHED);
 507   underlineMapSet.Insert("dashWidth", 2);
 508   underlineMapSet.Insert("dashGap", 1);
 509
 510   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 511
 512   application.SendNotification();
 513   application.Render();
 514
 515   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 516   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 517   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 518
 519   //DOUBLE Underline
 520   underlineMapSet.Clear();
 521   underlineMapGet.Clear();
 522
 523   underlineMapSet.Insert("enable", false);
 524   underlineMapSet.Insert("color", Color::BLUE);
 525   underlineMapSet.Insert("height", 0);
 526   underlineMapSet.Insert("type", Text::Underline::DOUBLE);
 527   underlineMapSet.Insert("dashWidth", 2);
 528   underlineMapSet.Insert("dashGap", 1);
 529
 530   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 531
 532   application.SendNotification();
 533   application.Render();
 534
 535   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 536   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 537   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 538
 539   TextLabel label2 = TextLabel::New("New text");
 540   DALI_TEST_CHECK(label2);
 541   DALI_TEST_EQUALS(label2.GetProperty<std::string>(TextLabel::Property::TEXT), std::string("New text"), TEST_LOCATION);
 542
 543   // Check the enable markup property.
 544   DALI_TEST_CHECK(!label.GetProperty<bool>(TextLabel::Property::ENABLE_MARKUP));
 545   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
 546   DALI_TEST_CHECK(label.GetProperty<bool>(TextLabel::Property::ENABLE_MARKUP));
 547
 548   // Check the text property when markup is enabled
 549   label.SetProperty(TextLabel::Property::TEXT, "<color value='white'>Markup</color><color value='cyan'>Text</color>");
 550   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::TEXT), std::string("MarkupText"), TEST_LOCATION);
 551
 552   // Check for incomplete marks.
 553   label.SetProperty(TextLabel::Property::TEXT, "<color='white'><i>Markup</i><b>Text</b></color>");
 554   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::TEXT), std::string("MarkupText"), TEST_LOCATION);
 555   try
 556   {
 557     application.SendNotification();
 558     application.Render();
 559   }
 560   catch(...)
 561   {
 562     tet_result(TET_FAIL);
 563   }
 564
 565   // Check autoscroll properties
 566   const int         SCROLL_SPEED      = 80;
 567   const int         SCROLL_LOOPS      = 4;
 568   const float       SCROLL_GAP        = 50.0f;
 569   const float       SCROLL_LOOP_DELAY = 0.3f;
 570   const std::string STOP_IMMEDIATE    = std::string("IMMEDIATE");
 571   const std::string STOP_FINISH_LOOP  = std::string("FINISH_LOOP");
 572
 573   label.SetProperty(TextLabel::Property::MULTI_LINE, false); // Autoscroll only supported in single line
 574   DALI_TEST_CHECK(!label.GetProperty<bool>(TextLabel::Property::ENABLE_AUTO_SCROLL));
 575   label.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
 576   DALI_TEST_CHECK(label.GetProperty<bool>(TextLabel::Property::ENABLE_AUTO_SCROLL));
 577   label.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, SCROLL_SPEED);
 578   DALI_TEST_EQUALS(SCROLL_SPEED, label.GetProperty<int>(TextLabel::Property::AUTO_SCROLL_SPEED), TEST_LOCATION);
 579   label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, SCROLL_LOOPS);
 580   DALI_TEST_EQUALS(SCROLL_LOOPS, label.GetProperty<int>(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT), TEST_LOCATION);
 581   label.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, SCROLL_GAP);
 582   DALI_TEST_EQUALS(SCROLL_GAP, label.GetProperty<float>(TextLabel::Property::AUTO_SCROLL_GAP), TEST_LOCATION);
 583   label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_DELAY, SCROLL_LOOP_DELAY);
 584   DALI_TEST_EQUALS(SCROLL_LOOP_DELAY, label.GetProperty<float>(TextLabel::Property::AUTO_SCROLL_LOOP_DELAY), TEST_LOCATION);
 585
 586   //Check autoscroll stop type property
 587   label.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
 588   DALI_TEST_EQUALS(STOP_IMMEDIATE, label.GetProperty<std::string>(TextLabel::Property::AUTO_SCROLL_STOP_MODE), TEST_LOCATION);
 589
 590   label.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
 591   DALI_TEST_EQUALS(STOP_FINISH_LOOP, label.GetProperty<std::string>(TextLabel::Property::AUTO_SCROLL_STOP_MODE), TEST_LOCATION);
 592
 593   // test natural size with multi-line and line spacing
 594   {
 595     TextLabel label3             = TextLabel::New("Some text here\nend there\nend here");
 596     Vector3   oneLineNaturalSize = label3.GetNaturalSize();
 597     label3.SetProperty(TextLabel::Property::MULTI_LINE, true);
 598     label3.SetProperty(TextLabel::Property::LINE_SPACING, 0);
 599     Vector3 multiLineNaturalSize = label3.GetNaturalSize();
 600
 601     // The width of the text when multi-line is enabled will be smaller (lines separated on '\n')
 602     // The height of the text when multi-line is enabled will be larger
 603     DALI_TEST_CHECK(oneLineNaturalSize.width > multiLineNaturalSize.width);
 604     DALI_TEST_CHECK(oneLineNaturalSize.height < multiLineNaturalSize.height);
 605
 606     // Change line spacing, meaning height will increase by 3 times the amount specified as we have three lines
 607     // Everything else will remain the same
 608     int lineSpacing = 20;
 609     label3.SetProperty(TextLabel::Property::LINE_SPACING, lineSpacing);
 610     Vector3 expectedAfterLineSpacingApplied(multiLineNaturalSize);
 611     expectedAfterLineSpacingApplied.height += 3 * lineSpacing;
 612     DALI_TEST_EQUALS(expectedAfterLineSpacingApplied, label3.GetNaturalSize(), TEST_LOCATION);
 613   }
 614
 615   // single line, line spacing must not affect natural size of the text, only add the spacing to the height
 616   {
 617     TextLabel label3 = TextLabel::New("Some text here end there end here");
 618     label3.SetProperty(TextLabel::Property::MULTI_LINE, false);
 619     label3.SetProperty(TextLabel::Property::LINE_SPACING, 0);
 620     Vector3 textNaturalSize = label3.GetNaturalSize();
 621     int     lineSpacing     = 20;
 622     label3.SetProperty(TextLabel::Property::LINE_SPACING, lineSpacing);
 623     Vector3 expectedNaturalSizeWithLineSpacing(textNaturalSize);
 624     expectedNaturalSizeWithLineSpacing.height += lineSpacing;
 625     DALI_TEST_EQUALS(expectedNaturalSizeWithLineSpacing, label3.GetNaturalSize(), TEST_LOCATION);
 626   }
 627   // Check the line spacing property
 628   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::LINE_SPACING), 0.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 629   label.SetProperty(TextLabel::Property::LINE_SPACING, 10.f);
 630   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::LINE_SPACING), 10.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 631
 632   // Check the strikethrough property
 633   strikethroughMapSet.Clear();
 634   strikethroughMapSet.Insert("enable", true);
 635   strikethroughMapSet.Insert("color", Color::RED);
 636   strikethroughMapSet.Insert("height", 2.0f);
 637
 638   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
 639
 640   application.SendNotification();
 641   application.Render();
 642
 643   strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
 644   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
 645   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
 646
 647   // Check the transparent strikethrough property for coverage.
 648   strikethroughMapSet.Clear();
 649   strikethroughMapSet.Insert("enable", true);
 650   strikethroughMapSet.Insert("color", Color::TRANSPARENT);
 651   strikethroughMapSet.Insert("height", 2.0f);
 652
 653   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
 654
 655   application.SendNotification();
 656   application.Render();
 657
 658   strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
 659   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
 660   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
 661
 662   strikethroughMapSet.Clear();
 663   strikethroughMapSet.Insert(Toolkit::DevelText::Strikethrough::Property::ENABLE, true);
 664   strikethroughMapSet.Insert(Toolkit::DevelText::Strikethrough::Property::COLOR, Color::RED);
 665   strikethroughMapSet.Insert(Toolkit::DevelText::Strikethrough::Property::HEIGHT, 2.0f);
 666
 667   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
 668
 669   application.SendNotification();
 670   application.Render();
 671
 672   strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
 673   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
 674   std::vector<std::string> strikethroughIndicesConversionTable = {"enable", "color", "height"};
 675   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet, strikethroughIndicesConversionTable), true, TEST_LOCATION);
 676
 677   strikethroughMapSet.Clear();
 678
 679   Property::Map strikethroughDisabledMapGet;
 680   strikethroughDisabledMapGet.Insert("enable", false);
 681   strikethroughDisabledMapGet.Insert("color", Color::RED);
 682   strikethroughDisabledMapGet.Insert("height", 2.0f);
 683
 684   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
 685
 686   application.SendNotification();
 687   application.Render();
 688
 689   strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
 690   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughDisabledMapGet.Count(), TEST_LOCATION);
 691   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughDisabledMapGet), true, TEST_LOCATION);
 692
 693   // Check the underline property
 694   underlineMapSet.Clear();
 695   underlineMapSet.Insert("enable", true);
 696   underlineMapSet.Insert("color", Color::RED);
 697   underlineMapSet.Insert("height", 1);
 698   underlineMapSet.Insert("type", Text::Underline::SOLID);
 699   underlineMapSet.Insert("dashWidth", 2);
 700   underlineMapSet.Insert("dashGap", 1);
 701
 702   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 703
 704   application.SendNotification();
 705   application.Render();
 706
 707   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 708   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 709   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 710
 711   underlineMapSet.Clear();
 712   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::ENABLE, true);
 713   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::COLOR, Color::GREEN);
 714   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::HEIGHT, 2);
 715   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::TYPE, Text::Underline::DASHED);
 716   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_WIDTH, 2);
 717   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_GAP, 1);
 718
 719   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 720
 721   application.SendNotification();
 722   application.Render();
 723
 724   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 725   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 726   std::vector<std::string> underlineIndicesConversionTable = {"enable", "color", "height", "type", "dashWidth", "dashGap"};
 727   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet, underlineIndicesConversionTable), true, TEST_LOCATION);
 728
 729   underlineMapSet.Clear();
 730
 731   Property::Map underlineDisabledMapGet;
 732   underlineDisabledMapGet.Insert("enable", false);
 733   underlineDisabledMapGet.Insert("color", Color::GREEN);
 734   underlineDisabledMapGet.Insert("height", 2);
 735   underlineDisabledMapGet.Insert("type", Text::Underline::SOLID);
 736   underlineDisabledMapGet.Insert("dashWidth", 2);
 737   underlineDisabledMapGet.Insert("dashGap", 1);
 738
 739   label.SetProperty(TextLabel::Property::UNDERLINE, underlineDisabledMapGet);
 740
 741   application.SendNotification();
 742   application.Render();
 743
 744   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 745   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineDisabledMapGet.Count(), TEST_LOCATION);
 746   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineDisabledMapGet), true, TEST_LOCATION);
 747
 748   // Check the dashed underline property
 749   underlineMapSet.Clear();
 750   underlineMapSet.Insert("enable", true);
 751   underlineMapSet.Insert("color", Color::RED);
 752   underlineMapSet.Insert("height", 1);
 753   underlineMapSet.Insert("type", Text::Underline::DASHED);
 754   underlineMapSet.Insert("dashWidth", 2);
 755   underlineMapSet.Insert("dashGap", 1);
 756
 757   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 758
 759   application.SendNotification();
 760   application.Render();
 761
 762   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 763   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 764   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 765
 766   underlineMapSet.Clear();
 767   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::ENABLE, true);
 768   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::COLOR, Color::GREEN);
 769   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::HEIGHT, 2);
 770   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::TYPE, Text::Underline::DASHED);
 771   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_WIDTH, 2);
 772   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_GAP, 1);
 773
 774   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 775
 776   application.SendNotification();
 777   application.Render();
 778
 779   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 780   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 781   underlineIndicesConversionTable = {"enable", "color", "height", "type", "dashWidth", "dashGap"};
 782   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet, underlineIndicesConversionTable), true, TEST_LOCATION);
 783
 784   underlineMapSet.Clear();
 785
 786   underlineDisabledMapGet.Clear();
 787   underlineDisabledMapGet.Insert("enable", false);
 788   underlineDisabledMapGet.Insert("color", Color::GREEN);
 789   underlineDisabledMapGet.Insert("height", 2);
 790   underlineDisabledMapGet.Insert("type", Text::Underline::DASHED);
 791   underlineDisabledMapGet.Insert("dashWidth", 2);
 792   underlineDisabledMapGet.Insert("dashGap", 1);
 793
 794   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 795
 796   application.SendNotification();
 797   application.Render();
 798
 799   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 800   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineDisabledMapGet.Count(), TEST_LOCATION);
 801   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineDisabledMapGet), true, TEST_LOCATION);
 802
 803   // Check the double underline property
 804   underlineMapSet.Clear();
 805   underlineMapSet.Insert("enable", true);
 806   underlineMapSet.Insert("color", Color::RED);
 807   underlineMapSet.Insert("height", 1);
 808   underlineMapSet.Insert("type", Text::Underline::DOUBLE);
 809   underlineMapSet.Insert("dashWidth", 2);
 810   underlineMapSet.Insert("dashGap", 1);
 811
 812   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 813
 814   application.SendNotification();
 815   application.Render();
 816
 817   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 818   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 819   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 820
 821   // Check the transparent double underline property for coverage.
 822   underlineMapSet.Clear();
 823   underlineMapSet.Insert("enable", true);
 824   underlineMapSet.Insert("color", Color::TRANSPARENT);
 825   underlineMapSet.Insert("height", 1);
 826   underlineMapSet.Insert("type", Text::Underline::DOUBLE);
 827   underlineMapSet.Insert("dashWidth", 2);
 828   underlineMapSet.Insert("dashGap", 1);
 829
 830   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 831
 832   application.SendNotification();
 833   application.Render();
 834
 835   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 836   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 837   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 838
 839   underlineMapSet.Clear();
 840   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::ENABLE, true);
 841   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::COLOR, Color::GREEN);
 842   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::HEIGHT, 2);
 843   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::TYPE, Text::Underline::DOUBLE);
 844   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_WIDTH, 2);
 845   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::DASH_GAP, 1);
 846
 847   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
 848
 849   application.SendNotification();
 850   application.Render();
 851
 852   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 853   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
 854   underlineIndicesConversionTable = {"enable", "color", "height", "type", "dashWidth", "dashGap"};
 855   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet, underlineIndicesConversionTable), true, TEST_LOCATION);
 856
 857   underlineMapSet.Clear();
 858
 859   underlineDisabledMapGet.Clear();
 860   underlineDisabledMapGet.Insert("enable", false);
 861   underlineDisabledMapGet.Insert("color", Color::GREEN);
 862   underlineDisabledMapGet.Insert("height", 2);
 863   underlineDisabledMapGet.Insert("type", Text::Underline::DOUBLE);
 864   underlineDisabledMapGet.Insert("dashWidth", 2);
 865   underlineDisabledMapGet.Insert("dashGap", 1);
 866
 867   label.SetProperty(TextLabel::Property::UNDERLINE, underlineDisabledMapGet);
 868
 869   application.SendNotification();
 870   application.Render();
 871
 872   underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
 873   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineDisabledMapGet.Count(), TEST_LOCATION);
 874   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineDisabledMapGet), true, TEST_LOCATION);
 875
 876   // Check the shadow property
 877
 878   Property::Map shadowMapSet;
 879   Property::Map shadowMapGet;
 880
 881   shadowMapSet.Insert("color", Color::GREEN);
 882   shadowMapSet.Insert("offset", Vector2(2.0f, 2.0f));
 883   shadowMapSet.Insert("blurRadius", 5.0f);
 884
 885   label.SetProperty(TextLabel::Property::SHADOW, shadowMapSet);
 886
 887   shadowMapGet = label.GetProperty<Property::Map>(TextLabel::Property::SHADOW);
 888   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
 889   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
 890
 891   shadowMapSet.Clear();
 892
 893   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::COLOR, Color::BLUE);
 894   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::OFFSET, "3.0 3.0");
 895   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::BLUR_RADIUS, 3.0f);
 896
 897   label.SetProperty(TextLabel::Property::SHADOW, shadowMapSet);
 898
 899   // Replace the offset (string) by a vector2
 900   shadowMapSet.Clear();
 901   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::COLOR, Color::BLUE);
 902   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::OFFSET, Vector2(3.0, 3.0));
 903   shadowMapSet.Insert(Toolkit::DevelText::Shadow::Property::BLUR_RADIUS, 3.0f);
 904
 905   shadowMapGet = label.GetProperty<Property::Map>(TextLabel::Property::SHADOW);
 906   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
 907   std::vector<std::string> shadowIndicesConversionTable = {"color", "offset", "blurRadius"};
 908   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet, shadowIndicesConversionTable), true, TEST_LOCATION);
 909
 910   shadowMapSet.Clear();
 911   Property::Map shadowDisabledMapGet;
 912   shadowDisabledMapGet.Insert("color", Color::BLUE);
 913   shadowDisabledMapGet.Insert("offset", Vector2(0.0f, 0.0f));
 914   shadowDisabledMapGet.Insert("blurRadius", 3.0f);
 915
 916   label.SetProperty(TextLabel::Property::SHADOW, shadowMapSet);
 917
 918   shadowMapGet = label.GetProperty<Property::Map>(TextLabel::Property::SHADOW);
 919   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowDisabledMapGet.Count(), TEST_LOCATION);
 920   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowDisabledMapGet), true, TEST_LOCATION);
 921
 922   // Check the emboss property
 923   label.SetProperty(TextLabel::Property::EMBOSS, "Emboss properties");
 924   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::EMBOSS), std::string("Emboss properties"), TEST_LOCATION);
 925
 926   // Check the outline property
 927
 928   // Test string type first
 929   // This is purely to maintain backward compatibility, but we don't support string as the outline property type.
 930   label.SetProperty(TextLabel::Property::OUTLINE, "Outline properties");
 931   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::OUTLINE), std::string("Outline properties"), TEST_LOCATION);
 932
 933   // Then test the property map type
 934   Property::Map outlineMapSet;
 935   Property::Map outlineMapGet;
 936
 937   outlineMapSet["color"] = Color::RED;
 938   outlineMapSet["width"] = 2.0f;
 939   label.SetProperty(TextLabel::Property::OUTLINE, outlineMapSet);
 940
 941   outlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::OUTLINE);
 942   DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
 943   DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
 944
 945   outlineMapSet.Clear();
 946   outlineMapSet[Toolkit::DevelText::Outline::Property::COLOR] = Color::BLUE;
 947   outlineMapSet[Toolkit::DevelText::Outline::Property::WIDTH] = 3.0f;
 948   label.SetProperty(TextLabel::Property::OUTLINE, outlineMapSet);
 949
 950   outlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::OUTLINE);
 951   DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
 952   std::vector<std::string> outlineIndicesConversionTable = {"color", "width"};
 953   DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet, outlineIndicesConversionTable), true, TEST_LOCATION);
 954
 955   // Check the background property
 956   Property::Map backgroundMapSet;
 957   Property::Map backgroundMapGet;
 958
 959   backgroundMapSet["enable"] = true;
 960   backgroundMapSet["color"]  = Color::RED;
 961   label.SetProperty(DevelTextLabel::Property::BACKGROUND, backgroundMapSet);
 962
 963   backgroundMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::BACKGROUND);
 964   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
 965   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
 966
 967   // Check the transparent background property for coverage
 968   backgroundMapSet.Clear();
 969   backgroundMapSet["enable"] = true;
 970   backgroundMapSet["color"]  = Color::TRANSPARENT;
 971   label.SetProperty(DevelTextLabel::Property::BACKGROUND, backgroundMapSet);
 972
 973   application.SendNotification();
 974   application.Render();
 975
 976   backgroundMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::BACKGROUND);
 977   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
 978   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
 979
 980   backgroundMapSet.Clear();
 981   backgroundMapSet[Toolkit::DevelText::Background::Property::ENABLE] = true;
 982   backgroundMapSet[Toolkit::DevelText::Background::Property::COLOR]  = Color::GREEN;
 983   label.SetProperty(DevelTextLabel::Property::BACKGROUND, backgroundMapSet);
 984
 985   backgroundMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::BACKGROUND);
 986   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
 987   std::vector<std::string> backgroundIndicesConversionTable = {"enable", "color"};
 988   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet, backgroundIndicesConversionTable), true, TEST_LOCATION);
 989
 990   // Check the pixel size of font
 991   label.SetProperty(TextLabel::Property::PIXEL_SIZE, 20.f);
 992   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::PIXEL_SIZE), 20.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 993
 994   // Check the ellipsis property
 995   DALI_TEST_CHECK(label.GetProperty<bool>(TextLabel::Property::ELLIPSIS));
 996   label.SetProperty(TextLabel::Property::ELLIPSIS, false);
 997   DALI_TEST_CHECK(!label.GetProperty<bool>(TextLabel::Property::ELLIPSIS));
 998
 999   // Check the layout direction property
1000   label.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
1001   DALI_TEST_EQUALS(label.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
1002
1003   // Check the line size property
1004   DALI_TEST_EQUALS(label.GetProperty<float>(DevelTextLabel::Property::MIN_LINE_SIZE), 0.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1005   label.SetProperty(DevelTextLabel::Property::MIN_LINE_SIZE, 50.f);
1006   DALI_TEST_EQUALS(label.GetProperty<float>(DevelTextLabel::Property::MIN_LINE_SIZE), 50.0f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1007
1008   application.SendNotification();
1009   application.Render();
1010
1011   END_TEST;
1012 }
1013
1014 int UtcDaliToolkitTextlabelAtlasRenderP(void)
1015 {
1016   ToolkitTestApplication application;
1017   tet_infoline(" UtcDaliToolkitTextLabelAtlasRenderP");
1018   TextLabel label = TextLabel::New("Test Text");
1019   DALI_TEST_CHECK(label);
1020
1021   // Avoid a crash when core load gl resources.
1022   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1023
1024   application.GetScene().Add(label);
1025
1026   // Turn on all the effects
1027   label.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
1028   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
1029
1030   Property::Map underlineMap;
1031   underlineMap.Insert("enable", true);
1032   underlineMap.Insert("color", Color::RED);
1033   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMap);
1034
1035   Property::Map shadowMap;
1036   shadowMap.Insert("color", Color::BLUE);
1037   shadowMap.Insert("offset", Vector2(1.0f, 1.0f));
1038   label.SetProperty(TextLabel::Property::SHADOW, shadowMap);
1039
1040   Property::Map strikethroughMap;
1041   strikethroughMap.Insert("enable", true);
1042   strikethroughMap.Insert("color", Color::GREEN);
1043   strikethroughMap.Insert("height", 2.0f);
1044   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMap);
1045
1046   try
1047   {
1048     // Render some text with the shared atlas backend
1049     label.SetProperty(DevelTextLabel::Property::RENDERING_BACKEND, DevelText::RENDERING_SHARED_ATLAS);
1050     application.SendNotification();
1051     application.Render();
1052   }
1053   catch(...)
1054   {
1055     tet_result(TET_FAIL);
1056   }
1057
1058   try
1059   {
1060     // Render some text with the shared atlas backend
1061     label.SetProperty(DevelTextLabel::Property::RENDERING_BACKEND, DevelText::RENDERING_VECTOR_BASED);
1062     application.SendNotification();
1063     application.Render();
1064   }
1065   catch(...)
1066   {
1067     tet_result(TET_FAIL);
1068   }
1069   END_TEST;
1070 }
1071
1072 int UtcDaliToolkitTextLabelLanguagesP(void)
1073 {
1074   ToolkitTestApplication application;
1075   tet_infoline(" UtcDaliToolkitTextLabelLanguagesP");
1076   TextLabel label = TextLabel::New();
1077   DALI_TEST_CHECK(label);
1078
1079   application.GetScene().Add(label);
1080
1081   const std::string scripts(
1082     " привет мир, γειά σου Κόσμε, Hello world, مرحبا بالعالم, שלום עולם, "
1083     "բարեւ աշխարհը, მსოფლიოში, 안녕하세요, 你好世界, ひらがな, カタカナ, "
1084     "ওহে বিশ্ব, မင်္ဂလာပါကမ္ဘာလောက, हैलो वर्ल्ड, હેલો વર્લ્ડ, ਸਤਿ ਸ੍ਰੀ ਅਕਾਲ ਦੁਨਿਆ, ಹಲೋ ವರ್ಲ್ಡ್, "
1085     "ഹലോ വേൾഡ്, ଓଡ଼ିଆ, හෙලෝ වර්ල්ඩ්, ஹலோ உலகம், హలో వరల్డ్, "
1086     "ສະບາຍດີໂລກ, สวัสดีโลก, ជំរាបសួរពិភពលោក, "
1087     "\xF0\x9F\x98\x81 \xF0\x9F\x98\x82 \xF0\x9F\x98\x83 \xF0\x9F\x98\x84."); // these characters on the last line are emojis.
1088
1089   label.SetProperty(TextLabel::Property::TEXT, scripts);
1090   DALI_TEST_EQUALS(label.GetProperty<std::string>(TextLabel::Property::TEXT), scripts, TEST_LOCATION);
1091
1092   application.SendNotification();
1093   application.Render();
1094
1095   END_TEST;
1096 }
1097
1098 int UtcDaliToolkitTextLabelEmojisP(void)
1099 {
1100   ToolkitTestApplication application;
1101   tet_infoline(" UtcDaliToolkitTextLabelLanguagesP");
1102   TextLabel label = TextLabel::New();
1103   DALI_TEST_CHECK(label);
1104
1105   application.GetScene().Add(label);
1106
1107   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1108
1109   char*             pathNamePtr = get_current_dir_name();
1110   const std::string pathName(pathNamePtr);
1111   free(pathNamePtr);
1112
1113   TextAbstraction::FontDescription fontDescription;
1114   fontDescription.path   = pathName + DEFAULT_FONT_DIR + "/tizen/BreezeColorEmoji.ttf";
1115   fontDescription.family = "BreezeColorEmoji";
1116   fontDescription.width  = TextAbstraction::FontWidth::NONE;
1117   fontDescription.weight = TextAbstraction::FontWeight::NORMAL;
1118   fontDescription.slant  = TextAbstraction::FontSlant::NONE;
1119
1120   fontClient.GetFontId(fontDescription, EMOJI_FONT_SIZE);
1121
1122   const std::string emojis = "<font family='BreezeColorEmoji' size='60'>\xF0\x9F\x98\x81 \xF0\x9F\x98\x82 \xF0\x9F\x98\x83 \xF0\x9F\x98\x84</font>";
1123   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
1124   label.SetProperty(TextLabel::Property::TEXT, emojis);
1125
1126   Property::Map shadowMap;
1127   shadowMap.Insert("color", "green");
1128   shadowMap.Insert("offset", "2 2");
1129   label.SetProperty(TextLabel::Property::SHADOW, shadowMap);
1130
1131   application.SendNotification();
1132   application.Render();
1133
1134   // EMOJI + ZWJ + EMOJI case for coverage.
1135   const std::string emojiWithZWJ = "&#x1f469;&#x200d;&#x1f52c;";
1136   label.SetProperty(TextLabel::Property::TEXT, emojiWithZWJ);
1137
1138   application.SendNotification();
1139   application.Render();
1140
1141   // EMOJI Sequences case for coverage.
1142   std::string emojiSequences =
1143     "Glyphs not included in the font &#xf01a;&#xf01b;&#xf01c;&#xf01d;&#xf01e;&#xf01f;\n"   //case for coverage when glyph is not included in the font
1144     "Text VS15 &#x262a;&#xfe0e;\n"                                                         //text presentation sequence and selector
1145     "Color VS16 &#x262a;&#xfe0f;\n"                                                        //emoji presentation sequence and selector
1146     "Default &#x262a; \n"                                                                  //default presentation
1147     "FamilyManWomanGirlBoy &#x1F468;&#x200D;&#x1F469;&#x200D;&#x1F467;&#x200D;&#x1F466;\n" // emoji multi zwj sequence
1148     "WomanScientist &#x1f469;&#x200d;&#x1f52c;\n"                                          // emoji zwj sequence
1149     "WomanScientistLightSkinTone&#x1F469;&#x1F3FB;&#x200D;&#x1F52C; \n"                    //emoji modifier sequence: skin tone & JWZ
1150     "LeftRightArrowText&#x2194;&#xfe0e;\n"                                                 //text presentation sequence and selector
1151     "LeftRightArrowEmoji&#x2194;&#xfe0f;\n"                                                //emoji presentation sequence and selector
1152     "SouthKoreaFlag&#x1f1f0;&#x1f1f7;\n"                                                   //emoji flag sequence
1153     "JordanFlag&#x1f1ef;&#x1f1f4;\n"                                                       // emoji flag sequence
1154     "EnglandFlag&#x1F3F4;&#xE0067;&#xE0062;&#xE0065;&#xE006E;&#xE0067;&#xE007F;\n"         //emoji tag sequence like England flag
1155     "Runner &#x1f3c3;&#x200d;&#x27a1;&#xfe0f; \n"
1156     "VictoryHandMediumLightSkinTone:&#x270C;&#xFE0F;&#x1F3FC;\n"               //emoji modifier sequence: skin tone
1157     "RainbowFlag:&#x1F3F3;&#xFE0F;&#x200D;&#x1F308; \n"                        //emoji zwj sequence: Rainbow Flag
1158     "keycap# &#x0023;&#xFE0F;&#x20E3; \n"                                      // fully-qualified  emoji keycap sequence
1159     "keycap#_text &#x0023;&#x20E3; \n"                                         // unqualified emoji keycap sequence
1160     "keycap3 &#x0033;&#xfe0f;&#x20e3; \n"                                      // fully-qualified  emoji keycap sequence
1161     "keycap3_text &#x0033;&#x20e3; \n"                                         // unqualified emoji keycap sequence
1162     "two adjacent glyphs &#x262a;&#xfe0f;&#xfe0f;&#xfe0f;&#x262a;&#xfe0f;\n"   //This line should be rendered as two adjacent glyphs
1163     "Digit 8&#xfe0f; 8&#xfe0e; 8\n"                                            // should be rendered according to selector
1164     "Surfing Medium Skin Female:  &#x1f3c4;&#x1f3fc;&#x200d;&#x2640;&#xfe0f;"; // Person Surfing + Medium Skin Tone +? Zero Width Joiner + Female Sign
1165
1166   label.SetProperty(TextLabel::Property::TEXT, emojiSequences);
1167   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
1168   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
1169   label.SetProperty(TextLabel::Property::ELLIPSIS, false);
1170
1171   application.SendNotification();
1172   application.Render();
1173   END_TEST;
1174 }
1175
1176 int UtcDaliToolkitTextlabelScrollingP(void)
1177 {
1178   ToolkitTestApplication application;
1179   tet_infoline(" UtcDaliToolkitTextLabelScrollingP");
1180   TextLabel labelImmediate = TextLabel::New("Some text to scroll");
1181   TextLabel labelFinished  = TextLabel::New("مرحبا بالعالم");
1182
1183   DALI_TEST_CHECK(labelImmediate);
1184   DALI_TEST_CHECK(labelFinished);
1185   // Avoid a crash when core load gl resources.
1186   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1187   application.GetScene().Add(labelImmediate);
1188   // Turn on all the effects
1189   labelImmediate.SetProperty(TextLabel::Property::MULTI_LINE, false);
1190   labelImmediate.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1191   labelImmediate.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1192   labelImmediate.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1193   labelImmediate.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1194
1195   application.GetScene().Add(labelFinished);
1196   // Turn on all the effects
1197   labelFinished.SetProperty(TextLabel::Property::MULTI_LINE, false);
1198   labelFinished.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1199   labelFinished.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1200   labelFinished.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1201   labelFinished.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
1202
1203   try
1204   {
1205     // Render some text with the shared atlas backend
1206     labelImmediate.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1207     labelFinished.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1208
1209     labelImmediate.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1210     labelFinished.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1211
1212     labelImmediate.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1213     labelFinished.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1214     application.SendNotification();
1215     application.Render();
1216
1217     labelImmediate.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1218     labelFinished.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1219     application.SendNotification();
1220     application.Render();
1221   }
1222   catch(...)
1223   {
1224     tet_result(TET_FAIL);
1225   }
1226
1227   END_TEST;
1228 }
1229
1230 int UtcDaliToolkitTextlabelScrollingCenterAlignP(void)
1231 {
1232   ToolkitTestApplication application;
1233   TextLabel              labelShort = TextLabel::New("Some text to scroll");
1234   TextLabel              labelLong  = TextLabel::New("Some text to scroll that is greater than the width of the text. The quick brown fox jumps over the lazy dog. Hello World, we meet again!");
1235
1236   DALI_TEST_CHECK(labelShort);
1237   DALI_TEST_CHECK(labelLong);
1238   // Avoid a crash when core load gl resources.
1239   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1240   application.GetScene().Add(labelShort);
1241   // Turn on all the effects
1242   labelShort.SetProperty(TextLabel::Property::MULTI_LINE, false);
1243   labelShort.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
1244   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1245   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1246   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1247   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1248
1249   application.GetScene().Add(labelLong);
1250   // Turn on all the effects
1251   labelLong.SetProperty(TextLabel::Property::MULTI_LINE, false);
1252   labelLong.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
1253   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1254   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1255   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1256   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
1257
1258   try
1259   {
1260     // Render some text with the shared atlas backend
1261     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1262     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1263     application.SendNotification();
1264     application.Render();
1265
1266     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1267     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1268     application.SendNotification();
1269     application.Render();
1270   }
1271   catch(...)
1272   {
1273     tet_result(TET_FAIL);
1274   }
1275
1276   END_TEST;
1277 }
1278
1279 int UtcDaliToolkitTextlabelScrollingCenterAlignRTLP(void)
1280 {
1281   ToolkitTestApplication application;
1282   TextLabel              labelShort = TextLabel::New("مرحبا بالعالم");
1283   TextLabel              labelLong  = TextLabel::New("لكن لا بد أن أوضح لك أن كل هذه الأفكار المغلوطة حول استنكار  النشوة وتمجيد الألم نشأت بالفعل، وسأعرض لك التفاصيل لتكتشف حقيقة وأساس تلك السعادة البشرية، فلا أحد يرفض أو يكره أو يتجنب الشعور بالسعادة، ولكن بفضل هؤلاء الأشخاص الذين لا يدركون بأن السعادة لا بد أن نستشعرها بصورة أكثر عقلانية ومنطقية فيعرضهم هذا لمواجهة الظروف الأليمة، وأكرر بأنه لا يوجد من يرغب في الحب ونيل المنال ويتلذذ بالآلام، الألم هو الألم ولكن نتيجة لظروف ما قد تكمن السعاده فيما نتحمله من كد وأسي");
1284
1285   DALI_TEST_CHECK(labelShort);
1286   DALI_TEST_CHECK(labelLong);
1287   // Avoid a crash when core load gl resources.
1288   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1289   application.GetScene().Add(labelShort);
1290   // Turn on all the effects
1291   labelShort.SetProperty(TextLabel::Property::MULTI_LINE, false);
1292   labelShort.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
1293   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1294   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1295   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1296   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1297
1298   application.GetScene().Add(labelLong);
1299   // Turn on all the effects
1300   labelLong.SetProperty(TextLabel::Property::MULTI_LINE, false);
1301   labelLong.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER");
1302   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1303   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1304   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1305   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
1306
1307   try
1308   {
1309     // Render some text with the shared atlas backend
1310     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1311     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1312     application.SendNotification();
1313     application.Render();
1314
1315     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1316     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1317     application.SendNotification();
1318     application.Render();
1319   }
1320   catch(...)
1321   {
1322     tet_result(TET_FAIL);
1323   }
1324
1325   END_TEST;
1326 }
1327
1328 int UtcDaliToolkitTextlabelScrollingEndAlignP(void)
1329 {
1330   ToolkitTestApplication application;
1331   TextLabel              labelShort = TextLabel::New("Some text to scroll");
1332   TextLabel              labelLong  = TextLabel::New("Some text to scroll that is greater than the width of the text. The quick brown fox jumps over the lazy dog. Hello World, we meet again!");
1333
1334   DALI_TEST_CHECK(labelShort);
1335   DALI_TEST_CHECK(labelLong);
1336   // Avoid a crash when core load gl resources.
1337   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1338   application.GetScene().Add(labelShort);
1339   // Turn on all the effects
1340   labelShort.SetProperty(TextLabel::Property::MULTI_LINE, false);
1341   labelShort.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "END");
1342   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1343   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1344   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1345   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1346
1347   application.GetScene().Add(labelLong);
1348   // Turn on all the effects
1349   labelLong.SetProperty(TextLabel::Property::MULTI_LINE, false);
1350   labelLong.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "END");
1351   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1352   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1353   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1354   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
1355
1356   try
1357   {
1358     // Render some text with the shared atlas backend
1359     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1360     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1361     application.SendNotification();
1362     application.Render();
1363
1364     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1365     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1366     application.SendNotification();
1367     application.Render();
1368   }
1369   catch(...)
1370   {
1371     tet_result(TET_FAIL);
1372   }
1373
1374   END_TEST;
1375 }
1376
1377 int UtcDaliToolkitTextlabelScrollingEndAlignRTLP(void)
1378 {
1379   ToolkitTestApplication application;
1380   TextLabel              labelShort = TextLabel::New("مرحبا بالعالم");
1381   TextLabel              labelLong  = TextLabel::New("لكن لا بد أن أوضح لك أن كل هذه الأفكار المغلوطة حول استنكار  النشوة وتمجيد الألم نشأت بالفعل، وسأعرض لك التفاصيل لتكتشف حقيقة وأساس تلك السعادة البشرية، فلا أحد يرفض أو يكره أو يتجنب الشعور بالسعادة، ولكن بفضل هؤلاء الأشخاص الذين لا يدركون بأن السعادة لا بد أن نستشعرها بصورة أكثر عقلانية ومنطقية فيعرضهم هذا لمواجهة الظروف الأليمة، وأكرر بأنه لا يوجد من يرغب في الحب ونيل المنال ويتلذذ بالآلام، الألم هو الألم ولكن نتيجة لظروف ما قد تكمن السعاده فيما نتحمله من كد وأسي");
1382
1383   DALI_TEST_CHECK(labelShort);
1384   DALI_TEST_CHECK(labelLong);
1385   // Avoid a crash when core load gl resources.
1386   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1387   application.GetScene().Add(labelShort);
1388   // Turn on all the effects
1389   labelShort.SetProperty(TextLabel::Property::MULTI_LINE, false);
1390   labelShort.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "END");
1391   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1392   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1393   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1394   labelShort.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1395
1396   application.GetScene().Add(labelLong);
1397   // Turn on all the effects
1398   labelLong.SetProperty(TextLabel::Property::MULTI_LINE, false);
1399   labelLong.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, "END");
1400   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1401   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1402   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1403   labelLong.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::FINISH_LOOP);
1404
1405   try
1406   {
1407     // Render some text with the shared atlas backend
1408     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1409     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1410     application.SendNotification();
1411     application.Render();
1412
1413     labelShort.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1414     labelLong.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1415     application.SendNotification();
1416     application.Render();
1417   }
1418   catch(...)
1419   {
1420     tet_result(TET_FAIL);
1421   }
1422
1423   END_TEST;
1424 }
1425
1426 int UtcDaliToolkitTextlabelScrollingInterruptedP(void)
1427 {
1428   ToolkitTestApplication application;
1429   tet_infoline(" UtcDaliToolkitTextlabelScrollingInterruptedP");
1430   TextLabel label = TextLabel::New("Some text to scroll");
1431   DALI_TEST_CHECK(label);
1432   // Avoid a crash when core load gl resources.
1433   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1434   application.GetScene().Add(label);
1435   label.SetProperty(Actor::Property::SIZE, Vector2(360.0f, 20.f));
1436   // Turn on all the effects
1437   label.SetProperty(TextLabel::Property::MULTI_LINE, false);
1438   label.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1439   label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1440   label.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1441
1442   // Render the text.
1443   application.SendNotification();
1444   application.Render();
1445
1446   unsigned int actorCount1 = label.GetChildCount();
1447   tet_printf("Initial actor count is(%d)\n", actorCount1);
1448
1449   try
1450   {
1451     // Render some text with the shared atlas backend
1452     label.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1453     application.SendNotification();
1454     application.Render(2000);
1455
1456     unsigned int actorCount1 = label.GetChildCount();
1457     tet_printf("Actor count after scrolling is(%d)\n", actorCount1);
1458
1459     label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::RED);
1460
1461     // Render the text.
1462     application.SendNotification();
1463     application.Render();
1464
1465     unsigned int actorCount2 = label.GetChildCount();
1466     tet_printf("After changing color the actor count is(%d)\n", actorCount2);
1467
1468     DALI_TEST_EQUALS(actorCount1, actorCount2, TEST_LOCATION);
1469   }
1470   catch(...)
1471   {
1472     tet_result(TET_FAIL);
1473   }
1474
1475   END_TEST;
1476 }
1477
1478 int UtcDaliToolkitTextlabelScrollingN(void)
1479 {
1480   ToolkitTestApplication application;
1481   tet_infoline(" UtcDaliToolkitTextlabelScrollingN");
1482
1483   TextLabel label = TextLabel::New("Some text to scroll");
1484   DALI_TEST_CHECK(label);
1485
1486   application.GetScene().Add(label);
1487
1488   // Avoid a crash when core load gl resources.
1489   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1490
1491   // The text scrolling works only on single line text.
1492   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
1493
1494   // Turn on all the effects.
1495   label.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1496   label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1497   label.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1498
1499   // Enable the auto scrolling effect.
1500   label.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1501
1502   // The auto scrolling shouldn't be enabled.
1503   const bool enabled = label.GetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL).Get<bool>();
1504   DALI_TEST_CHECK(!enabled);
1505
1506   END_TEST;
1507 }
1508
1509 int UtcDaliToolkitTextlabelScrollingWithEllipsis(void)
1510 {
1511   ToolkitTestApplication application;
1512   tet_infoline(" UtcDaliToolkitTextlabelScrollingWithEllipsis");
1513
1514   TextLabel label = TextLabel::New("Some text to scroll");
1515   DALI_TEST_CHECK(label);
1516
1517   application.GetScene().Add(label);
1518
1519   // Avoid a crash when core load gl resources.
1520   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1521
1522   // Turn on all the effects.
1523   label.SetProperty(TextLabel::Property::AUTO_SCROLL_GAP, 50.0f);
1524   label.SetProperty(TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 3);
1525   label.SetProperty(TextLabel::Property::AUTO_SCROLL_SPEED, 80.0f);
1526
1527   try
1528   {
1529     // Enable the auto scrolling effect.
1530     label.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, true);
1531     label.SetProperty(TextLabel::Property::AUTO_SCROLL_STOP_MODE, TextLabel::AutoScrollStopMode::IMMEDIATE);
1532
1533     // Disable the ellipsis
1534     label.SetProperty(TextLabel::Property::ELLIPSIS, false);
1535
1536     // Render the text.
1537     application.SendNotification();
1538     application.Render();
1539
1540     // Stop auto scrolling
1541     label.SetProperty(TextLabel::Property::ENABLE_AUTO_SCROLL, false);
1542
1543     // Check the ellipsis property
1544     DALI_TEST_CHECK(!label.GetProperty<bool>(TextLabel::Property::ELLIPSIS));
1545   }
1546   catch(...)
1547   {
1548     tet_result(TET_FAIL);
1549   }
1550
1551   END_TEST;
1552 }
1553
1554 int UtcDaliToolkitTextlabelEllipsis(void)
1555 {
1556   ToolkitTestApplication application;
1557   tet_infoline(" UtcDaliToolkitTextlabelEllipsis");
1558
1559   TextLabel label = TextLabel::New("Hello world");
1560   DALI_TEST_CHECK(label);
1561
1562   // Avoid a crash when core load gl resources.
1563   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1564
1565   application.GetScene().Add(label);
1566
1567   // Turn on all the effects
1568   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
1569   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1570   label.SetProperty(Actor::Property::SIZE, Vector2(360.0f, 10.f));
1571
1572   try
1573   {
1574     // Render the text.
1575     application.SendNotification();
1576     application.Render();
1577   }
1578   catch(...)
1579   {
1580     tet_result(TET_FAIL);
1581   }
1582
1583   label.SetProperty(TextLabel::Property::TEXT, "Hello world                                        ");
1584   label.SetProperty(DevelTextLabel::Property::IGNORE_SPACES_AFTER_TEXT, false);
1585   label.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 10.f));
1586
1587   try
1588   {
1589     // Render the text.
1590     application.SendNotification();
1591     application.Render();
1592   }
1593   catch(...)
1594   {
1595     tet_result(TET_FAIL);
1596   }
1597
1598   label.SetProperty(TextLabel::Property::TEXT, "Hello world");
1599   label.SetProperty(DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION, true);
1600   label.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 10.f));
1601
1602   try
1603   {
1604     // Render the text.
1605     application.SendNotification();
1606     application.Render();
1607   }
1608   catch(...)
1609   {
1610     tet_result(TET_FAIL);
1611   }
1612
1613   END_TEST;
1614 }
1615
1616 int UtcDaliToolkitTextlabelTextWrapMode(void)
1617 {
1618   ToolkitTestApplication application;
1619   tet_infoline(" UtcDaliToolkitTextlabelTextWarpMode");
1620
1621   int lineCount = 0;
1622
1623   TextLabel label = TextLabel::New();
1624   label.SetProperty(Actor::Property::SIZE, Vector2(300.0f, 300.f));
1625   label.SetProperty(TextLabel::Property::TEXT, "Hello world Hello world");
1626   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
1627
1628   //label.SetProperty( TextLabel::Property::POINT_SIZE, 18 );
1629   application.GetScene().Add(label);
1630
1631   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, "WORD");
1632   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(Text::LineWrap::WORD), TEST_LOCATION);
1633
1634   application.SendNotification();
1635   application.Render();
1636
1637   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
1638   DALI_TEST_EQUALS(lineCount, 2, TEST_LOCATION);
1639
1640   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, "CHARACTER");
1641   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(Text::LineWrap::CHARACTER), TEST_LOCATION);
1642
1643   application.SendNotification();
1644   application.Render();
1645
1646   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, Text::LineWrap::WORD);
1647   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(Text::LineWrap::WORD), TEST_LOCATION);
1648
1649   application.SendNotification();
1650   application.Render();
1651
1652   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
1653   DALI_TEST_EQUALS(lineCount, 2, TEST_LOCATION);
1654
1655   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, Text::LineWrap::CHARACTER);
1656   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(Text::LineWrap::CHARACTER), TEST_LOCATION);
1657
1658   application.SendNotification();
1659   application.Render();
1660
1661   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
1662   DALI_TEST_EQUALS(lineCount, 2, TEST_LOCATION);
1663
1664   tet_infoline("Ensure invalid string does not change wrapping mode");
1665   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, "InvalidWrapMode");
1666   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(Text::LineWrap::CHARACTER), TEST_LOCATION);
1667
1668   END_TEST;
1669 }
1670
1671 int UtcDaliToolkitTextLabelColorComponents(void)
1672 {
1673   ToolkitTestApplication application;
1674
1675   TextLabel label = TextLabel::New();
1676   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::RED);
1677   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_RED), 1.0f, TEST_LOCATION);
1678   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_GREEN), 0.0f, TEST_LOCATION);
1679   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_BLUE), 0.0f, TEST_LOCATION);
1680   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_ALPHA), 1.0f, TEST_LOCATION);
1681
1682   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::GREEN);
1683   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_RED), 0.0f, TEST_LOCATION);
1684   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_GREEN), 1.0f, TEST_LOCATION);
1685   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_BLUE), 0.0f, TEST_LOCATION);
1686   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_ALPHA), 1.0f, TEST_LOCATION);
1687
1688   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::BLUE);
1689   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_RED), 0.0f, TEST_LOCATION);
1690   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_GREEN), 0.0f, TEST_LOCATION);
1691   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_BLUE), 1.0f, TEST_LOCATION);
1692   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_ALPHA), 1.0f, TEST_LOCATION);
1693
1694   label.SetProperty(TextLabel::Property::TEXT_COLOR_ALPHA, 0.6f);
1695   DALI_TEST_EQUALS(label.GetProperty<float>(TextLabel::Property::TEXT_COLOR_ALPHA), 0.6f, TEST_LOCATION);
1696   DALI_TEST_EQUALS(label.GetProperty<Vector4>(TextLabel::Property::TEXT_COLOR), Vector4(0.0f, 0.0f, 1.0f, 0.6f), TEST_LOCATION);
1697
1698   // Test a transparent text - Rendering should be skipped.
1699   label.SetProperty(TextLabel::Property::TEXT, "Hello world Hello world");
1700   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::BLUE);
1701
1702   application.GetScene().Add(label);
1703
1704   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1705   drawTrace.Enable(true);
1706
1707   application.SendNotification();
1708   application.Render();
1709
1710   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION); // Should be rendered
1711
1712   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::TRANSPARENT);
1713
1714   drawTrace.Reset();
1715
1716   application.SendNotification();
1717   application.Render();
1718
1719   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), false, TEST_LOCATION); // Rendering should be skipped
1720
1721   label.SetProperty(TextLabel::Property::TEXT_COLOR, Color::RED);
1722
1723   drawTrace.Reset();
1724
1725   application.SendNotification();
1726   application.Render();
1727
1728   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION); // Should be rendered again
1729
1730   END_TEST;
1731 }
1732
1733 int UtcDaliToolkitTextlabelTextStyle01(void)
1734 {
1735   ToolkitTestApplication application;
1736   tet_infoline(" UtcDaliToolkitTextlabelTextStyle Setting Outline after Shadow");
1737
1738   TextLabel label = TextLabel::New();
1739   label.SetProperty(Actor::Property::SIZE, Vector2(300.0f, 300.f));
1740   label.SetProperty(TextLabel::Property::TEXT, "Hello world Hello world");
1741   label.SetProperty(TextLabel::Property::POINT_SIZE, 12);
1742   application.GetScene().Add(label);
1743
1744   Property::Map outlineMapSet;
1745   Property::Map outlineMapGet;
1746
1747   outlineMapSet["color"] = Color::BLUE;
1748   outlineMapSet["width"] = 2.0f;
1749   label.SetProperty(TextLabel::Property::OUTLINE, outlineMapSet);
1750
1751   application.SendNotification();
1752   application.Render();
1753
1754   Property::Map shadowMapSet;
1755   shadowMapSet.Insert("color", "green");
1756   shadowMapSet.Insert("offset", "2 2");
1757   shadowMapSet.Insert("blurRadius", "3");
1758   label.SetProperty(TextLabel::Property::SHADOW, shadowMapSet);
1759
1760   outlineMapSet["color"] = Color::RED;
1761   outlineMapSet["width"] = 0.0f;
1762   label.SetProperty(TextLabel::Property::OUTLINE, outlineMapSet);
1763
1764   application.SendNotification();
1765   application.Render();
1766
1767   outlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::OUTLINE);
1768
1769   Property::Value* colorValue = outlineMapGet.Find("color");
1770
1771   bool colorMatched(false);
1772
1773   if(colorValue)
1774   {
1775     Property::Type valueType = colorValue->GetType();
1776
1777     if(Property::STRING == valueType)
1778     {
1779       std::string stringValue;
1780       colorValue->Get(stringValue);
1781       if(stringValue == "red")
1782       {
1783         colorMatched = true;
1784       }
1785     }
1786     else if(Property::VECTOR4 == valueType)
1787     {
1788       Vector4 colorVector4;
1789       colorValue->Get(colorVector4);
1790       if(colorVector4 == Color::RED)
1791       {
1792         colorMatched = true;
1793       }
1794     }
1795   }
1796
1797   DALI_TEST_EQUALS(colorMatched, true, TEST_LOCATION);
1798
1799   END_TEST;
1800 }
1801
1802 int UtcDaliToolkitTextlabelMultiline(void)
1803 {
1804   ToolkitTestApplication application;
1805   tet_infoline(" UtcDaliToolkitTextlabelMultiline");
1806
1807   TextLabel label = TextLabel::New();
1808   label.SetProperty(TextLabel::Property::TEXT, "Hello world Hello world Hello world Hello world Hello world Hello world");
1809   label.SetProperty(TextLabel::Property::POINT_SIZE, 20);
1810   label.SetProperty(TextLabel::Property::MULTI_LINE, false);
1811   application.GetScene().Add(label);
1812
1813   application.SendNotification();
1814   application.Render();
1815
1816   int lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
1817   DALI_TEST_EQUALS(lineCount, 1, TEST_LOCATION);
1818
1819   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
1820
1821   application.SendNotification();
1822   application.Render();
1823
1824   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
1825   DALI_TEST_EQUALS(true, (lineCount > 1), TEST_LOCATION);
1826
1827   END_TEST;
1828 }
1829
1830 int UtcDaliToolkitTextlabelTextDirection(void)
1831 {
1832   ToolkitTestApplication application;
1833   tet_infoline(" UtcDaliToolkitTextlabelTextDirection");
1834
1835   TextLabel label = TextLabel::New();
1836   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::TEXT_DIRECTION), static_cast<int>(Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT), TEST_LOCATION);
1837
1838   label.SetProperty(TextLabel::Property::TEXT, "Hello world");
1839   label.SetProperty(TextLabel::Property::POINT_SIZE, 20);
1840   label.SetProperty(DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION, false);
1841   application.GetScene().Add(label);
1842
1843   // Test LTR text
1844   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::TEXT_DIRECTION), static_cast<int>(Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT), TEST_LOCATION);
1845
1846   // Test RTL text
1847   label.SetProperty(TextLabel::Property::TEXT, "ﻡﺮﺤﺑﺍ ﺏﺎﻠﻋﺎﻠﻣ ﻡﺮﺤﺑﺍ");
1848   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::TEXT_DIRECTION), static_cast<int>(Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT), TEST_LOCATION);
1849
1850   // Test RTL text starting with weak character
1851   label.SetProperty(TextLabel::Property::TEXT, "()ﻡﺮﺤﺑﺍ ﺏﺎﻠﻋﺎﻠﻣ ﻡﺮﺤﺑﺍ");
1852   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::TEXT_DIRECTION), static_cast<int>(Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT), TEST_LOCATION);
1853
1854   // Test RTL text string with emoji and weak character
1855   label.SetProperty(TextLabel::Property::TEXT, "\xF0\x9F\x98\x81 () ﻡﺮﺤﺑﺍ ﺏﺎﻠﻋﺎﻠﻣ ﻡﺮﺤﺑﺍ");
1856   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::TEXT_DIRECTION), static_cast<int>(Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT), TEST_LOCATION);
1857
1858   END_TEST;
1859 }
1860
1861 int UtcDaliToolkitTextlabelVerticalLineAlignment(void)
1862 {
1863   ToolkitTestApplication application;
1864   tet_infoline(" UtcDaliToolkitTextlabelVerticalLineAlignment");
1865
1866   TextLabel label = TextLabel::New();
1867
1868   label.SetProperty(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, DevelText::VerticalLineAlignment::TOP);
1869   label.SetProperty(TextLabel::Property::TEXT, "Hello world");
1870   label.SetProperty(TextLabel::Property::POINT_SIZE, 15);
1871   label.SetProperty(TextLabel::Property::LINE_SPACING, 12);
1872   application.GetScene().Add(label);
1873   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT), static_cast<int>(Toolkit::DevelText::VerticalLineAlignment::TOP), TEST_LOCATION);
1874
1875   label.SetProperty(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, DevelText::VerticalLineAlignment::MIDDLE);
1876   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT), static_cast<int>(Toolkit::DevelText::VerticalLineAlignment::MIDDLE), TEST_LOCATION);
1877
1878   label.SetProperty(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, DevelText::VerticalLineAlignment::BOTTOM);
1879   DALI_TEST_EQUALS(label.GetProperty<int>(DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT), static_cast<int>(Toolkit::DevelText::VerticalLineAlignment::BOTTOM), TEST_LOCATION);
1880
1881   END_TEST;
1882 }
1883
1884 int UtcDaliToolkitTextLabelBitmapFont(void)
1885 {
1886   ToolkitTestApplication application;
1887   tet_infoline(" UtcDaliToolkitTextLabelBitmapFont");
1888
1889   DevelText::BitmapFontDescription fontDescription;
1890   fontDescription.name               = "Digits";
1891   fontDescription.underlinePosition  = 0.f;
1892   fontDescription.underlineThickness = 0.f;
1893
1894   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0030.png", ":", 34.f, 0.f});
1895   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0031.png", "0", 34.f, 0.f});
1896   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0032.png", "1", 34.f, 0.f});
1897   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0033.png", "2", 34.f, 0.f});
1898   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0034.png", "3", 34.f, 0.f});
1899   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0035.png", "4", 34.f, 0.f});
1900   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0036.png", "5", 34.f, 0.f});
1901   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0037.png", "6", 34.f, 0.f});
1902   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0038.png", "7", 34.f, 0.f});
1903   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0039.png", "8", 34.f, 0.f});
1904   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u003a.png", "9", 34.f, 0.f});
1905
1906   TextAbstraction::BitmapFont bitmapFont;
1907   DevelText::CreateBitmapFont(fontDescription, bitmapFont);
1908
1909   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1910   fontClient.GetFontId(bitmapFont);
1911
1912   TextLabel label = TextLabel::New();
1913
1914   label.SetProperty(TextLabel::Property::TEXT, "0123456789:");
1915   label.SetProperty(TextLabel::Property::FONT_FAMILY, "Digits");
1916
1917   // The text has been laid out with the bitmap font if the natural size is the sum of all the width (322) and 34 height.
1918   DALI_TEST_EQUALS(label.GetNaturalSize(), Vector3(322.f, 34.f, 0.f), Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1919
1920   application.GetScene().Add(label);
1921
1922   application.SendNotification();
1923   application.Render();
1924
1925   // The text has been rendered if the height of the text-label is the height of the line.
1926   DALI_TEST_EQUALS(label.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, 34.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1927
1928   END_TEST;
1929 }
1930
1931 int ConvertPointToPixel(float point)
1932 {
1933   unsigned int                horizontalDpi = 0u;
1934   unsigned int                verticalDpi   = 0u;
1935   TextAbstraction::FontClient fontClient    = TextAbstraction::FontClient::Get();
1936   fontClient.GetDpi(horizontalDpi, verticalDpi);
1937
1938   return (point * 72.f) / static_cast<float>(horizontalDpi);
1939 }
1940
1941 int UtcDaliToolkitTextlabelTextFit(void)
1942 {
1943   ToolkitTestApplication application;
1944   tet_infoline(" UtcDaliToolkitTextlabelTextFit");
1945   TextLabel label = TextLabel::New();
1946   Vector2   size(460.0f, 100.0f);
1947   label.SetProperty(Actor::Property::SIZE, size);
1948   label.SetProperty(TextLabel::Property::TEXT, "Hello world");
1949
1950   // connect to the text git changed signal.
1951   ConnectionTracker* testTracker = new ConnectionTracker();
1952   DevelTextLabel::TextFitChangedSignal(label).Connect(&TestTextFitChangedCallback);
1953   bool textFitChangedSignal = false;
1954   label.ConnectSignal(testTracker, "textFitChanged", CallbackFunctor(&textFitChangedSignal));
1955   gTextFitChangedCallBackCalled = false;
1956
1957   // check point size
1958   Property::Map textFitMapSet;
1959   textFitMapSet["enable"]       = true;
1960   textFitMapSet["minSize"]      = 10.f;
1961   textFitMapSet["maxSize"]      = 100.f;
1962   textFitMapSet["stepSize"]     = -1.f;
1963   textFitMapSet["fontSizeType"] = "pointSize";
1964
1965   label.SetProperty(Toolkit::DevelTextLabel::Property::TEXT_FIT, textFitMapSet);
1966   label.SetProperty(TextLabel::Property::POINT_SIZE, 120.f);
1967
1968   application.GetScene().Add(label);
1969
1970   application.SendNotification();
1971   application.Render();
1972
1973   const Vector3 EXPECTED_NATURAL_SIZE(450.0f, 96.0f, 0.0f);
1974   DALI_TEST_EQUALS(EXPECTED_NATURAL_SIZE, label.GetNaturalSize(), TEST_LOCATION);
1975
1976   DALI_TEST_CHECK(gTextFitChangedCallBackCalled);
1977   DALI_TEST_CHECK(textFitChangedSignal);
1978
1979   // check pixel size
1980   textFitMapSet.Clear();
1981   textFitMapSet["enable"]       = true;
1982   textFitMapSet["minSize"]      = ConvertPointToPixel(10.f);
1983   textFitMapSet["maxSize"]      = ConvertPointToPixel(100.f);
1984   textFitMapSet["stepSize"]     = ConvertPointToPixel(1.f);
1985   textFitMapSet["fontSizeType"] = "pixelSize";
1986
1987   label.SetProperty(Toolkit::DevelTextLabel::Property::TEXT_FIT, textFitMapSet);
1988
1989   application.SendNotification();
1990   application.Render();
1991
1992   DALI_TEST_EQUALS(EXPECTED_NATURAL_SIZE, label.GetNaturalSize(), TEST_LOCATION);
1993
1994   END_TEST;
1995 }
1996
1997 int UtcDaliToolkitTextlabelMaxTextureSet(void)
1998 {
1999   ToolkitTestApplication application;
2000   tet_infoline(" UtcDaliToolkitTextlabelMaxTextureSet");
2001
2002   DevelText::BitmapFontDescription fontDescription;
2003   fontDescription.name = "Digits";
2004   fontDescription.glyphs.push_back({TEST_RESOURCE_DIR "/fonts/bitmap/u0030.png", ":", 200.f, 0.f});
2005
2006   TextAbstraction::BitmapFont bitmapFont;
2007   DevelText::CreateBitmapFont(fontDescription, bitmapFont);
2008
2009   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
2010   fontClient.GetFontId(bitmapFont);
2011
2012   TextLabel label = TextLabel::New();
2013   label.SetProperty(TextLabel::Property::FONT_FAMILY, "Digits");
2014   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2015   label.SetProperty(TextLabel::Property::TEXT, ":This is a long sample text made to allow max texture size to be exceeded.");
2016   label.SetProperty(TextLabel::Property::POINT_SIZE, 200.f);
2017   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2018
2019   Property::Map underlineMapSet;
2020   underlineMapSet.Clear();
2021   underlineMapSet.Insert("enable", true);
2022   underlineMapSet.Insert("color", Color::RED);
2023   underlineMapSet.Insert("height", 1);
2024   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2025   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2026
2027   Property::Map strikethroughMapSet;
2028   strikethroughMapSet.Clear();
2029   strikethroughMapSet.Insert("enable", true);
2030   strikethroughMapSet.Insert("color", Color::RED);
2031   strikethroughMapSet.Insert("height", 2.0f);
2032   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
2033   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2034
2035   application.GetScene().Add(label);
2036
2037   application.SendNotification();
2038   application.Render();
2039
2040   const int maxTextureSize = Dali::GetMaxTextureSize();
2041   // Whether the rendered text is greater than maxTextureSize
2042   DALI_TEST_CHECK(label.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height > maxTextureSize);
2043
2044   // Check if the number of renderers is greater than 1.
2045   DALI_TEST_CHECK(label.GetRendererCount() > 1u);
2046
2047   //DASHED
2048   underlineMapSet.Clear();
2049   underlineMapSet.Insert("enable", false);
2050   underlineMapSet.Insert("color", Color::BLUE);
2051   underlineMapSet.Insert("height", 0);
2052   underlineMapSet.Insert("type", Text::Underline::DASHED);
2053   underlineMapSet.Insert("dashWidth", 2);
2054   underlineMapSet.Insert("dashGap", 1);
2055   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2056   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2057
2058   application.GetScene().Add(label);
2059
2060   application.SendNotification();
2061   application.Render();
2062
2063   // Whether the rendered text is greater than maxTextureSize
2064   DALI_TEST_CHECK(label.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height > maxTextureSize);
2065
2066   // Check if the number of renderers is greater than 1.
2067   DALI_TEST_CHECK(label.GetRendererCount() > 1u);
2068
2069   //DOUBLE
2070   underlineMapSet.Clear();
2071   underlineMapSet.Insert("enable", false);
2072   underlineMapSet.Insert("color", Color::BLUE);
2073   underlineMapSet.Insert("height", 0);
2074   underlineMapSet.Insert("type", Text::Underline::DOUBLE);
2075   underlineMapSet.Insert("dashWidth", 2);
2076   underlineMapSet.Insert("dashGap", 1);
2077   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2078   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2079
2080   application.GetScene().Add(label);
2081
2082   application.SendNotification();
2083   application.Render();
2084
2085   // Whether the rendered text is greater than maxTextureSize
2086   DALI_TEST_CHECK(label.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height > maxTextureSize);
2087
2088   // Check if the number of renderers is greater than 1.
2089   DALI_TEST_CHECK(label.GetRendererCount() > 1u);
2090
2091   // Coverage test for case of layoutSize is bigger than maxTextureSize
2092   float max_value = static_cast<float>(std::numeric_limits<uint16_t>::max());
2093   label.SetProperty(Actor::Property::SIZE, Vector2(max_value, 30.0f));
2094   application.SendNotification();
2095   application.Render();
2096
2097
2098   END_TEST;
2099 }
2100
2101 int UtcDaliToolkitTextlabelStrikethroughExceedsWidthAndHeight(void)
2102 {
2103   ToolkitTestApplication application;
2104   tet_infoline(" UtcDaliToolkitTextlabelStrikethroughExceedsWidthAndHeight");
2105
2106   TextLabel label = TextLabel::New();
2107   label.SetProperty(TextLabel::Property::TEXT, "Test");
2108   label.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2109   //Exeeding BufferWidth
2110   label.SetProperty(Actor::Property::SIZE, Vector2(200.f, 400.0f));
2111   label.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, HorizontalAlignment::RIGHT);
2112   label.SetProperty(TextLabel::Property::POINT_SIZE, 200.f);
2113
2114   application.GetScene().Add(label);
2115   application.SendNotification();
2116   application.Render();
2117
2118   Property::Map strikethroughMapSet;
2119   strikethroughMapSet.Clear();
2120   strikethroughMapSet.Insert("enable", true);
2121   strikethroughMapSet.Insert("color", Color::BLUE);
2122   strikethroughMapSet.Insert("height", 2.0f);
2123   label.SetProperty(TextLabel::Property::TEXT, "Test1");
2124   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
2125   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2126   application.GetScene().Add(label);
2127   application.SendNotification();
2128   application.Render();
2129   // Check if the number of renderers is 1.
2130   DALI_TEST_EQUALS(1, label.GetRendererCount(), TEST_LOCATION);
2131
2132   label = TextLabel::New();
2133   label.SetProperty(TextLabel::Property::TEXT, "Test");
2134   label.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2135
2136   //Exeeding BufferHeight
2137   label.SetProperty(Actor::Property::SIZE, Vector2(200.f, 100.0f));
2138   label.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, HorizontalAlignment::RIGHT);
2139   label.SetProperty(TextLabel::Property::POINT_SIZE, 200.f);
2140
2141   application.GetScene().Add(label);
2142   application.SendNotification();
2143   application.Render();
2144
2145   strikethroughMapSet.Clear();
2146   strikethroughMapSet.Insert("enable", true);
2147   strikethroughMapSet.Insert("color", Color::BLUE);
2148   strikethroughMapSet.Insert("height", 2.0f);
2149   label.SetProperty(TextLabel::Property::TEXT, "Test2");
2150   label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
2151   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2152   application.GetScene().Add(label);
2153   application.SendNotification();
2154   application.Render();
2155   // Check if the number of renderers is 1.
2156   DALI_TEST_EQUALS(1, label.GetRendererCount(), TEST_LOCATION);
2157
2158   END_TEST;
2159 }
2160
2161 int UtcDaliToolkitTextlabelUnderlineExceedsWidth(void)
2162 {
2163   ToolkitTestApplication application;
2164   tet_infoline(" UtcDaliToolkitTextlabelUnderlineExceedsWidth");
2165
2166   TextLabel label = TextLabel::New();
2167   label.SetProperty(TextLabel::Property::TEXT, "Test");
2168   label.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2169   //Exeeding BufferWidth
2170   label.SetProperty(Actor::Property::SIZE, Vector2(200.f, 400.0f));
2171   label.SetProperty(TextLabel::Property::HORIZONTAL_ALIGNMENT, HorizontalAlignment::RIGHT);
2172   label.SetProperty(TextLabel::Property::POINT_SIZE, 200.f);
2173
2174   application.GetScene().Add(label);
2175   application.SendNotification();
2176   application.Render();
2177
2178   Property::Map underlineMapSet;
2179
2180   //SOLID
2181   underlineMapSet.Clear();
2182   underlineMapSet.Insert("enable", true);
2183   underlineMapSet.Insert("color", Color::BLUE);
2184   underlineMapSet.Insert("height", 1);
2185   underlineMapSet.Insert("type", Text::Underline::SOLID);
2186   underlineMapSet.Insert("dashWidth", 2);
2187   underlineMapSet.Insert("dashGap", 1);
2188   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2189   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2190
2191   application.GetScene().Add(label);
2192
2193   application.SendNotification();
2194   application.Render();
2195
2196   // Check if the number of renderers is 1.
2197   DALI_TEST_EQUALS(1, label.GetRendererCount(), TEST_LOCATION);
2198
2199   //DASHED
2200   underlineMapSet.Clear();
2201   underlineMapSet.Insert("enable", true);
2202   underlineMapSet.Insert("color", Color::BLUE);
2203   underlineMapSet.Insert("height", 1);
2204   underlineMapSet.Insert("type", Text::Underline::DASHED);
2205   underlineMapSet.Insert("dashWidth", 2);
2206   underlineMapSet.Insert("dashGap", 1);
2207   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2208   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2209
2210   application.GetScene().Add(label);
2211
2212   application.SendNotification();
2213   application.Render();
2214
2215   // Check if the number of renderers is 1.
2216   DALI_TEST_EQUALS(1, label.GetRendererCount(), TEST_LOCATION);
2217
2218   //DOUBLE
2219   underlineMapSet.Clear();
2220   underlineMapSet.Insert("enable", true);
2221   underlineMapSet.Insert("color", Color::BLUE);
2222   underlineMapSet.Insert("height", 1);
2223   underlineMapSet.Insert("type", Text::Underline::DOUBLE);
2224   underlineMapSet.Insert("dashWidth", 2);
2225   underlineMapSet.Insert("dashGap", 1);
2226   label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
2227   label.SetProperty(Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLUE);
2228
2229   application.GetScene().Add(label);
2230
2231   application.SendNotification();
2232   application.Render();
2233
2234   // Check if the number of renderers is 1.
2235   DALI_TEST_EQUALS(1, label.GetRendererCount(), TEST_LOCATION);
2236
2237   END_TEST;
2238 }
2239
2240 int UtcDaliToolkitTextlabelLastCharacterIndex(void)
2241 {
2242   ToolkitTestApplication application;
2243   tet_infoline(" UtcDaliToolkitTextlabelLastCharacterIndex");
2244
2245   Vector2 size(300.0f, 100.0f);
2246
2247   Dali::Toolkit::DevelText::RendererParameters textParameters;
2248   textParameters.text              = "This is a sample text to get the last index.";
2249   textParameters.layout            = "multiLine";
2250   textParameters.fontSize          = 20.f;
2251   textParameters.textWidth         = 300u;
2252   textParameters.textHeight        = 100u;
2253   textParameters.ellipsisEnabled   = true;
2254   Dali::Property::Array indexArray = Dali::Toolkit::DevelText::GetLastCharacterIndex(textParameters);
2255
2256   DALI_TEST_CHECK(!indexArray.Empty());
2257   DALI_TEST_EQUALS(indexArray.GetElementAt(0).Get<int>(), 10, TEST_LOCATION);
2258
2259   END_TEST;
2260 }
2261
2262 int UtcDaliToolkitTextlabelFontSizeScale(void)
2263 {
2264   ToolkitTestApplication application;
2265   tet_infoline(" UtcDaliToolkitTextlabelFontSizeScale");
2266
2267   TextLabel label = TextLabel::New();
2268   label.SetProperty(TextLabel::Property::POINT_SIZE, 30.f);
2269   label.SetProperty(TextLabel::Property::TEXT, "Test");
2270   Vector3 nonScaledSize = label.GetNaturalSize();
2271
2272   TextLabel labelScaled = TextLabel::New();
2273   labelScaled.SetProperty(TextLabel::Property::POINT_SIZE, 15.f);
2274   labelScaled.SetProperty(Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE, 2.f);
2275   labelScaled.SetProperty(TextLabel::Property::TEXT, "Test");
2276   Vector3 scaledSize = labelScaled.GetNaturalSize();
2277
2278   DALI_TEST_EQUALS(nonScaledSize, scaledSize, TEST_LOCATION);
2279
2280   label.SetProperty(TextLabel::Property::PIXEL_SIZE, 30.f);
2281   label.SetProperty(TextLabel::Property::TEXT, "Test");
2282   nonScaledSize = label.GetNaturalSize();
2283
2284   labelScaled.SetProperty(TextLabel::Property::PIXEL_SIZE, 15.f);
2285   labelScaled.SetProperty(Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE, 2.f);
2286   labelScaled.SetProperty(TextLabel::Property::TEXT, "Test");
2287   scaledSize = labelScaled.GetNaturalSize();
2288
2289   DALI_TEST_EQUALS(nonScaledSize, scaledSize, TEST_LOCATION);
2290
2291   END_TEST;
2292 }
2293
2294 // Positive test for the anchorClicked signal.
2295 int UtcDaliToolkitTextlabelAnchorClicked(void)
2296 {
2297   ToolkitTestApplication application;
2298   tet_infoline(" UtcDaliToolkitTextlabelAnchorClicked");
2299   TextLabel label = TextLabel::New();
2300   DALI_TEST_CHECK(label);
2301
2302   application.GetScene().Add(label);
2303
2304   // connect to the anchor clicked signal.
2305   ConnectionTracker* testTracker = new ConnectionTracker();
2306   DevelTextLabel::AnchorClickedSignal(label).Connect(&TestAnchorClickedCallback);
2307   bool anchorClickedSignal = false;
2308   label.ConnectSignal(testTracker, "anchorClicked", CallbackFunctor(&anchorClickedSignal));
2309
2310   gAnchorClickedCallBackCalled = false;
2311   label.SetProperty(TextLabel::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
2312   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2313   label.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
2314   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2315   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2316
2317   application.SendNotification();
2318   application.Render();
2319
2320   // Create a tap event to touch the text label.
2321   TestGenerateTap(application, 5.0f, 25.0f, 100);
2322   application.SendNotification();
2323   application.Render();
2324
2325   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
2326   DALI_TEST_CHECK(anchorClickedSignal);
2327
2328   // reset
2329   gAnchorClickedCallBackCalled = false;
2330   anchorClickedSignal          = false;
2331   label.SetProperty(TextLabel::Property::TEXT, "");
2332   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, false);
2333
2334   application.SendNotification();
2335   application.Render();
2336
2337   // sets anchor text
2338   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2339   label.SetProperty(TextLabel::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
2340   label.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
2341   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2342   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2343
2344   application.SendNotification();
2345   application.Render();
2346
2347   // Create a tap event to touch the text label.
2348   TestGenerateTap(application, 5.0f, 25.0f, 200);
2349   application.SendNotification();
2350   application.Render();
2351
2352   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
2353   DALI_TEST_CHECK(anchorClickedSignal);
2354
2355   gAnchorClickedCallBackNotCalled = true;
2356   // Tap the outside of anchor, callback should not be called.
2357   TestGenerateTap(application, 150.f, 100.f, 300);
2358   application.SendNotification();
2359   application.Render();
2360
2361   DALI_TEST_CHECK(gAnchorClickedCallBackNotCalled);
2362
2363   END_TEST;
2364 }
2365
2366 int UtcDaliTextLabelAtlasLimitationIsEnabledForLargeFontPointSize(void)
2367 {
2368   ToolkitTestApplication application;
2369   tet_infoline(" UtcDaliTextLabelAtlasLimitationIsEnabledForLargeFontPointSize ");
2370
2371   //TextLabel is not using Atlas but this is to unify font-size on text-controllers
2372
2373   // +2: First one to handle the equal case. Second one to handle odd to even case of GetNaturalSize
2374   const uint32_t lessThanWidth  = TextAbstraction::FontClient::MAX_TEXT_ATLAS_WIDTH - TextAbstraction::FontClient::PADDING_TEXT_ATLAS_BLOCK + 2;
2375   const uint32_t lessThanHeight = TextAbstraction::FontClient::MAX_TEXT_ATLAS_HEIGHT - TextAbstraction::FontClient::PADDING_TEXT_ATLAS_BLOCK + 2;
2376
2377   // Create a text editor
2378   TextLabel textLabel = TextLabel::New();
2379   //Set size to avoid automatic eliding
2380   textLabel.SetProperty(Actor::Property::SIZE, Vector2(1025, 1025));
2381   //Set very large font-size using point-size
2382   textLabel.SetProperty(TextLabel::Property::POINT_SIZE, 1000);
2383   //Specify font-family
2384   textLabel.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2385   //Set text to check if appear or not
2386   textLabel.SetProperty(TextLabel::Property::TEXT, "A");
2387
2388   application.GetScene().Add(textLabel);
2389
2390   application.SendNotification();
2391   application.Render();
2392   //Use GetNaturalSize to verify that size of block does not exceed Atlas size
2393   Vector3 naturalSize = textLabel.GetNaturalSize();
2394
2395   DALI_TEST_GREATER(lessThanWidth, static_cast<uint32_t>(naturalSize.width), TEST_LOCATION);
2396   DALI_TEST_GREATER(lessThanHeight, static_cast<uint32_t>(naturalSize.height), TEST_LOCATION);
2397
2398   END_TEST;
2399 }
2400
2401 int UtcDaliTextLabelHyphenWrapMode(void)
2402 {
2403   ToolkitTestApplication application;
2404   tet_infoline(" UtcDaliTextLabelHyphenWrapMode ");
2405
2406   int       lineCount = 0;
2407   TextLabel label     = TextLabel::New();
2408   label.SetProperty(Actor::Property::SIZE, Vector2(150.0f, 300.f));
2409   label.SetProperty(TextLabel::Property::POINT_SIZE, 12.f);
2410   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2411   application.GetScene().Add(label);
2412   application.SendNotification();
2413   application.Render();
2414
2415   label.SetProperty(TextLabel::Property::TEXT, "Hi Experimen");
2416   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, DevelText::LineWrap::HYPHENATION);
2417   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(DevelText::LineWrap::HYPHENATION), TEST_LOCATION);
2418
2419   application.SendNotification();
2420   application.Render();
2421
2422   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
2423   /*
2424     text will be :
2425     Hi Exp-
2426     erimen
2427   */
2428   DALI_TEST_EQUALS(lineCount, 2, TEST_LOCATION);
2429
2430   label.SetProperty(TextLabel::Property::TEXT, "Hi Experimen");
2431   label.SetProperty(TextLabel::Property::LINE_WRAP_MODE, DevelText::LineWrap::MIXED);
2432   DALI_TEST_EQUALS(label.GetProperty<int>(TextLabel::Property::LINE_WRAP_MODE), static_cast<int>(DevelText::LineWrap::MIXED), TEST_LOCATION);
2433
2434   application.SendNotification();
2435   application.Render();
2436
2437   lineCount = label.GetProperty<int>(TextLabel::Property::LINE_COUNT);
2438   /*
2439     text will be :
2440     Hi
2441     Experi-
2442     men
2443   */
2444   DALI_TEST_EQUALS(lineCount, 3, TEST_LOCATION);
2445
2446   END_TEST;
2447 }
2448
2449 int utcDaliTextLabelGetHeightForWidthChangeLineCountWhenTextChanged(void)
2450 {
2451   ToolkitTestApplication application;
2452
2453   tet_infoline(" utcDaliTextLabelGetHeightForWidthChangeLineCountWhenTextChanged ");
2454
2455   int lineCountBefore = 0;
2456   int lineCountAfter  = 0;
2457
2458   // Create a text editor
2459   TextLabel textLabel = TextLabel::New();
2460   //Set very large font-size using point-size
2461   textLabel.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2462   //Specify font-family
2463   textLabel.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2464   //Specify size
2465   textLabel.SetProperty(Actor::Property::SIZE, Vector2(200.f, 100.f));
2466   //Set text longer than width of textLabel
2467   textLabel.SetProperty(TextLabel::Property::TEXT, "Short text");
2468   //Set line wrap mode Character
2469   textLabel.SetProperty(TextLabel::Property::LINE_WRAP_MODE, "CHARACTER");
2470   textLabel.SetProperty(TextLabel::Property::MULTI_LINE, true);
2471
2472   application.GetScene().Add(textLabel);
2473
2474   application.SendNotification();
2475   application.Render();
2476
2477   lineCountBefore = textLabel.GetProperty<int>(TextLabel::Property::LINE_COUNT);
2478
2479   textLabel.SetProperty(TextLabel::Property::TEXT, "This is very loooooooooooooooooooooooooooooooooooong text for test");
2480   lineCountAfter = textLabel.GetProperty<int>(TextLabel::Property::LINE_COUNT);
2481
2482   // When the text changed, the Line-count should be updated according to new text.
2483   // Because the GetHeightForWidth is called in Controller::GetLineCount(float width)
2484   DALI_TEST_EQUALS(lineCountBefore, 1, TEST_LOCATION);
2485   DALI_TEST_GREATER(lineCountAfter, 1, TEST_LOCATION);
2486
2487   END_TEST;
2488 }
2489
2490 int utcDaliTextLabelGeometryRTL(void)
2491 {
2492   ToolkitTestApplication application;
2493   tet_infoline(" utcDaliTextLabelGeometryRTL");
2494
2495   TextLabel label = TextLabel::New();
2496   DALI_TEST_CHECK(label);
2497
2498   application.GetScene().Add(label);
2499
2500   label.SetProperty(TextLabel::Property::POINT_SIZE, 7.f);
2501   label.SetProperty(Actor::Property::SIZE, Vector2(150.f, 100.f));
2502   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2503   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2504   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2505   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2506   label.SetProperty(TextLabel::Property::TEXT, "line1 \nline2\nline 3\nالاخيرالسطر");
2507
2508   // Avoid a crash when core load gl resources.
2509   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
2510
2511   // Render and notify
2512   application.SendNotification();
2513   application.Render();
2514
2515   unsigned int expectedCount = 4;
2516   unsigned int startIndex    = 3;
2517   unsigned int endIndex      = 24;
2518
2519   Vector<Vector2> positionsList = DevelTextLabel::GetTextPosition(label, startIndex, endIndex);
2520   Vector<Vector2> sizeList      = DevelTextLabel::GetTextSize(label, startIndex, endIndex);
2521
2522   DALI_TEST_EQUALS(positionsList.Size(), expectedCount, TEST_LOCATION);
2523   DALI_TEST_EQUALS(sizeList.Size(), expectedCount, TEST_LOCATION);
2524
2525   Vector<Vector2> expectedSizes;
2526   Vector<Vector2> expectedPositions;
2527
2528   expectedPositions.PushBack(Vector2(24, 0));
2529   expectedSizes.PushBack(Vector2(33, 25));
2530
2531   expectedPositions.PushBack(Vector2(-1, 25));
2532   expectedSizes.PushBack(Vector2(52, 25));
2533
2534   expectedPositions.PushBack(Vector2(-1, 50));
2535   expectedSizes.PushBack(Vector2(59, 25));
2536
2537   expectedPositions.PushBack(Vector2(73, 75));
2538   expectedSizes.PushBack(Vector2(37, 25));
2539
2540   TestTextGeometryUtils::CheckGeometryResult(positionsList, sizeList, expectedPositions, expectedSizes);
2541
2542   END_TEST;
2543 }
2544
2545 int utcDaliTextLabelGeometryGlyphMiddle(void)
2546 {
2547   ToolkitTestApplication application;
2548   tet_infoline(" utcDaliTextLabelGeometryGlyphMiddle");
2549
2550   TextLabel label = TextLabel::New();
2551   DALI_TEST_CHECK(label);
2552
2553   application.GetScene().Add(label);
2554
2555   label.SetProperty(TextLabel::Property::POINT_SIZE, 7.f);
2556   label.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2557   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2558   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2559   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2560   label.SetProperty(TextLabel::Property::TEXT, "لا تحتوي على لا");
2561
2562   // Avoid a crash when core load gl resources.
2563   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
2564
2565   // Render and notify
2566   application.SendNotification();
2567   application.Render();
2568
2569   unsigned int expectedCount = 1;
2570   unsigned int startIndex    = 1;
2571   unsigned int endIndex      = 13;
2572
2573   Vector<Vector2> positionsList = DevelTextLabel::GetTextPosition(label, startIndex, endIndex);
2574   Vector<Vector2> sizeList      = DevelTextLabel::GetTextSize(label, startIndex, endIndex);
2575
2576   DALI_TEST_EQUALS(positionsList.Size(), expectedCount, TEST_LOCATION);
2577   DALI_TEST_EQUALS(sizeList.Size(), expectedCount, TEST_LOCATION);
2578
2579   Vector<Vector2> expectedSizes;
2580   Vector<Vector2> expectedPositions;
2581
2582   expectedPositions.PushBack(Vector2(6, 0));
2583   expectedSizes.PushBack(Vector2(124, 25));
2584
2585   TestTextGeometryUtils::CheckGeometryResult(positionsList, sizeList, expectedPositions, expectedSizes);
2586
2587   END_TEST;
2588 }
2589
2590 int utcDaliTextLabelGeometryOneGlyph(void)
2591 {
2592   ToolkitTestApplication application;
2593   tet_infoline(" utcDaliTextLabelGeometryOneGlyph ");
2594
2595   TextLabel label = TextLabel::New();
2596   DALI_TEST_CHECK(label);
2597
2598   application.GetScene().Add(label);
2599
2600   label.SetProperty(TextLabel::Property::POINT_SIZE, 7.f);
2601   label.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2602   label.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2603   label.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2604   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2605   label.SetProperty(TextLabel::Property::TEXT, "H");
2606
2607   // Avoid a crash when core load gl resources.
2608   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
2609
2610   // Render and notify
2611   application.SendNotification();
2612   application.Render();
2613
2614   unsigned int expectedCount = 1;
2615   unsigned int startIndex    = 0;
2616   unsigned int endIndex      = 0;
2617
2618   Vector<Vector2> positionsList = DevelTextLabel::GetTextPosition(label, startIndex, endIndex);
2619   Vector<Vector2> sizeList      = DevelTextLabel::GetTextSize(label, startIndex, endIndex);
2620
2621   DALI_TEST_EQUALS(positionsList.Size(), expectedCount, TEST_LOCATION);
2622   DALI_TEST_EQUALS(sizeList.Size(), expectedCount, TEST_LOCATION);
2623
2624   Vector<Vector2> expectedSizes;
2625   Vector<Vector2> expectedPositions;
2626
2627   expectedPositions.PushBack(Vector2(-2, 0));
2628   expectedSizes.PushBack(Vector2(16, 25));
2629
2630   TestTextGeometryUtils::CheckGeometryResult(positionsList, sizeList, expectedPositions, expectedSizes);
2631
2632   END_TEST;
2633 }
2634
2635 int UtcDaliToolkitTextlabelEllipsisPositionProperty(void)
2636 {
2637   ToolkitTestApplication application;
2638   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty ");
2639   TextLabel textLabel = TextLabel::New();
2640
2641   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Default is END");
2642   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::END), TEST_LOCATION);
2643
2644   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to START");
2645   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, DevelText::EllipsisPosition::START);
2646   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::START), TEST_LOCATION);
2647
2648   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to MIDDLE");
2649   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, DevelText::EllipsisPosition::MIDDLE);
2650   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::MIDDLE), TEST_LOCATION);
2651
2652   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to END");
2653   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, DevelText::EllipsisPosition::END);
2654   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::END), TEST_LOCATION);
2655
2656   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to START using integer");
2657   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, 1);
2658   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::START), TEST_LOCATION);
2659
2660   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to MIDDLE using integer");
2661   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, 2);
2662   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::MIDDLE), TEST_LOCATION);
2663
2664   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to END using integer");
2665   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, 0);
2666   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::END), TEST_LOCATION);
2667
2668   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to START using string - uppercase");
2669   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "START");
2670   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::START), TEST_LOCATION);
2671
2672   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to MIDDLE using string - uppercase");
2673   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "MIDDLE");
2674   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::MIDDLE), TEST_LOCATION);
2675
2676   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to END using string - uppercase");
2677   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "END");
2678   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::END), TEST_LOCATION);
2679
2680   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to START using string - lowercase");
2681   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "start");
2682   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::START), TEST_LOCATION);
2683
2684   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to MIDDLE using string - lowercase");
2685   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "middle");
2686   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::MIDDLE), TEST_LOCATION);
2687
2688   tet_infoline(" UtcDaliToolkitTextlabelEllipsisPositionProperty - Change to END using string - lowercase");
2689   textLabel.SetProperty(DevelTextLabel::Property::ELLIPSIS_POSITION, "end");
2690   DALI_TEST_EQUALS(textLabel.GetProperty<int>(DevelTextLabel::Property::ELLIPSIS_POSITION), static_cast<int>(Toolkit::DevelText::EllipsisPosition::END), TEST_LOCATION);
2691
2692   END_TEST;
2693 }
2694
2695 int UtcDaliToolkitTextLabelStrikethroughGeneration(void)
2696 {
2697   ToolkitTestApplication application;
2698   tet_infoline(" UtcDaliToolkitTextLabelStrikethroughGeneration");
2699
2700   TextLabel textLabel = TextLabel::New();
2701   textLabel.SetProperty(TextLabel::Property::TEXT, "Test");
2702   textLabel.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 100.f));
2703   textLabel.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2704   textLabel.SetProperty(TextLabel::Property::FONT_FAMILY, "DejaVu Sans");
2705
2706   application.GetScene().Add(textLabel);
2707   application.SendNotification();
2708   application.Render();
2709
2710   Property::Map strikethroughMapSet;
2711   Property::Map strikethroughMapGet;
2712
2713   strikethroughMapSet.Insert("enable", true);
2714   strikethroughMapSet.Insert("color", Color::RED);
2715   strikethroughMapSet.Insert("height", 2.0f);
2716
2717   // Check the strikethrough property
2718   textLabel.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
2719   strikethroughMapGet = textLabel.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
2720   textLabel.SetProperty(TextLabel::Property::TEXT, "Test1");
2721   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
2722   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
2723
2724   // Render and notify
2725   application.SendNotification();
2726   application.Render();
2727
2728   strikethroughMapSet.Clear();
2729   strikethroughMapGet.Clear();
2730
2731   END_TEST;
2732 }
2733
2734 int UtcDaliToolkitTextLabelMarkupRelativeLineHeight(void)
2735 {
2736   ToolkitTestApplication application;
2737   tet_infoline(" UtcDaliToolkitTextLabelMarkupRelativeLineHeight");
2738
2739   TextLabel label = TextLabel::New();
2740   label.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 300.f));
2741   label.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2742   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2743   label.SetProperty(TextLabel::Property::TEXT, "line 1\nline 2\nline 3\nline 4\nline 5");
2744   label.SetProperty(DevelTextLabel::Property::RELATIVE_LINE_SIZE, 1.0f);
2745   label.SetProperty(TextLabel::Property::ELLIPSIS, false);
2746   label.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2747
2748   TextLabel labelSingleLineParagraph = TextLabel::New();
2749   labelSingleLineParagraph.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 300.f));
2750   labelSingleLineParagraph.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2751   labelSingleLineParagraph.SetProperty(TextLabel::Property::MULTI_LINE, true);
2752   labelSingleLineParagraph.SetProperty(TextLabel::Property::TEXT, "<p>line 1</p><p rel-line-height=0.5>line 2</p>line 3<p rel-line-height=3>line 4</p>line 5");
2753   labelSingleLineParagraph.SetProperty(DevelTextLabel::Property::RELATIVE_LINE_SIZE, 1.0f);
2754   labelSingleLineParagraph.SetProperty(TextLabel::Property::ELLIPSIS, false);
2755   labelSingleLineParagraph.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2756
2757   TextLabel labelMultiLineParagraph = TextLabel::New();
2758   labelMultiLineParagraph.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 300.f));
2759   labelMultiLineParagraph.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2760   labelMultiLineParagraph.SetProperty(TextLabel::Property::MULTI_LINE, true);
2761   labelMultiLineParagraph.SetProperty(TextLabel::Property::TEXT, "<p>line 1</p><p rel-line-height=0.5>line\n2</p>line 3<p rel-line-height=3>line\n4</p>line 5");
2762   labelMultiLineParagraph.SetProperty(DevelTextLabel::Property::RELATIVE_LINE_SIZE, 1.0f);
2763   labelMultiLineParagraph.SetProperty(TextLabel::Property::ELLIPSIS, false);
2764   labelMultiLineParagraph.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2765
2766   application.GetScene().Add(label);
2767   application.GetScene().Add(labelSingleLineParagraph);
2768   application.GetScene().Add(labelMultiLineParagraph);
2769   application.SendNotification();
2770   application.Render();
2771
2772   Vector3 naturalSize               = label.GetNaturalSize();
2773   Vector3 relativeSingleNaturalSize = labelSingleLineParagraph.GetNaturalSize();
2774   Vector3 relativeMultiNaturalSize  = labelMultiLineParagraph.GetNaturalSize();
2775
2776   float lineSize = naturalSize.y / 5.0f; //total size/number of lines
2777
2778   //no effect of relative line size for paragraph with single line
2779   DALI_TEST_EQUALS(naturalSize.y, relativeSingleNaturalSize.y, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
2780
2781   DALI_TEST_EQUALS(lineSize * 8.5f, relativeMultiNaturalSize.y, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
2782
2783   END_TEST;
2784 }
2785
2786 int UtcDaliToolkitTextLabelRelativeLineHeight(void)
2787 {
2788   ToolkitTestApplication application;
2789   tet_infoline(" UtcDaliToolkitTextLabelRelativeLineHeight");
2790
2791   TextLabel label = TextLabel::New();
2792   label.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 300.f));
2793   label.SetProperty(TextLabel::Property::POINT_SIZE, 10);
2794   label.SetProperty(TextLabel::Property::TEXT, "Hello\nWorld");
2795
2796   application.GetScene().Add(label);
2797   application.SendNotification();
2798   application.Render();
2799
2800   Vector3 naturalSize = label.GetNaturalSize();
2801
2802   label.SetProperty(DevelTextLabel::Property::RELATIVE_LINE_SIZE, 0.5f);
2803
2804   application.SendNotification();
2805   application.Render();
2806
2807   Vector3 relativeNaturalSize = label.GetNaturalSize();
2808
2809   DALI_TEST_EQUALS(naturalSize.y, relativeNaturalSize.y, TEST_LOCATION);
2810
2811   label.SetProperty(DevelTextLabel::Property::RELATIVE_LINE_SIZE, 2.0f);
2812
2813   application.SendNotification();
2814   application.Render();
2815
2816   relativeNaturalSize = label.GetNaturalSize();
2817
2818   DALI_TEST_EQUALS(naturalSize.y * 2, relativeNaturalSize.y, TEST_LOCATION);
2819   END_TEST;
2820 }
2821
2822 int UtcDaliTextLabelCharacterSpacing(void)
2823 {
2824   ToolkitTestApplication application;
2825   tet_infoline(" UtcDaliTextLabelCharacterSpacing ");
2826
2827   TextLabel textLabel = TextLabel::New();
2828
2829   textLabel.SetProperty(Actor::Property::SIZE, Vector2(150.0f, 300.f));
2830
2831   application.GetScene().Add(textLabel);
2832   application.SendNotification();
2833   application.Render();
2834
2835   textLabel.SetProperty(TextLabel::Property::TEXT, "Hi Experiment");
2836   textLabel.SetProperty(DevelTextLabel::Property::CHARACTER_SPACING, 10.f);
2837   DALI_TEST_EQUALS(textLabel.GetProperty<float>(DevelTextLabel::Property::CHARACTER_SPACING), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
2838
2839   application.SendNotification();
2840   application.Render();
2841
2842   END_TEST;
2843 }
2844
2845 int UtcDaliTextTextLabelSizeNegativeLineSpacing(void)
2846 {
2847   ToolkitTestApplication application;
2848   tet_infoline("UtcDaliTextTextLabelSizeNegativeLineSpacing");
2849
2850   TextLabel label = TextLabel::New();
2851
2852   float lineSpacing = -20.f;
2853
2854   label.SetProperty(Actor::Property::SIZE, Vector2(450.0f, 300.f));
2855   label.SetProperty(TextLabel::Property::POINT_SIZE, 10.f);
2856   label.SetProperty(DevelTextLabel::Property::LINE_SPACING, lineSpacing);
2857   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2858   label.SetProperty(TextLabel::Property::TEXT, "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
2859
2860   application.GetScene().Add(label);
2861   application.SendNotification();
2862   application.Render();
2863
2864   Vector<Vector2> positionsList = DevelTextLabel::GetTextPosition(label, 0, 123);
2865   Vector<Vector2> sizeList      = DevelTextLabel::GetTextSize(label, 0, 123);
2866
2867   Vector2 lastLinePos  = positionsList[positionsList.Size() - 1];
2868   Vector2 lastLineSize = sizeList[sizeList.Size() - 1];
2869
2870   DALI_TEST_EQUALS(sizeList[0].y * (sizeList.Size() - 1), lastLinePos.y, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
2871   DALI_TEST_EQUALS(sizeList[0].y - lineSpacing, lastLineSize.y, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
2872
2873   application.SendNotification();
2874   application.Render();
2875
2876   END_TEST;
2877 }
2878
2879 int UtcDaliTextLabelNegativeLineSpacingWithEllipsis(void)
2880 {
2881   ToolkitTestApplication application;
2882   tet_infoline("UtcDaliTextLabelNegativeLineSpacingWithEllipsis");
2883
2884   TextLabel label = TextLabel::New();
2885
2886   float lineSpacing = -20.f;
2887
2888   label.SetProperty(Actor::Property::SIZE, Vector2(480.0f, 100.f));
2889   label.SetProperty(TextLabel::Property::POINT_SIZE, 11.0f);
2890   label.SetProperty(DevelTextLabel::Property::LINE_SPACING, lineSpacing);
2891   label.SetProperty(TextLabel::Property::MULTI_LINE, true);
2892   label.SetProperty(TextLabel::Property::TEXT, "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
2893   label.SetProperty(TextLabel::Property::ELLIPSIS, true);
2894
2895   application.GetScene().Add(label);
2896   application.SendNotification();
2897   application.Render();
2898
2899   Vector<Vector2> sizeList = DevelTextLabel::GetTextSize(label, 0, 123);
2900
2901   int lineCount = sizeList.Size();
2902   DALI_TEST_EQUALS(4, lineCount, TEST_LOCATION);
2903
2904   application.SendNotification();
2905   application.Render();
2906
2907   END_TEST;
2908 }
2909
2910 int UtcDaliToolkitTextlabelParagraphTag(void)
2911 {
2912   ToolkitTestApplication application;
2913   tet_infoline(" UtcDaliToolkitTextlabelParagraphTag");
2914   TextLabel labelNewlineSeparator = TextLabel::New();
2915   TextLabel labelParagraphTag     = TextLabel::New();
2916   DALI_TEST_CHECK(labelNewlineSeparator);
2917   DALI_TEST_CHECK(labelParagraphTag);
2918
2919   application.GetScene().Add(labelNewlineSeparator);
2920   application.GetScene().Add(labelParagraphTag);
2921
2922   //Same utterance uses new-line to split paragraphs should give similar results for paragraph tag.
2923   labelNewlineSeparator.SetProperty(TextLabel::Property::MULTI_LINE, true);
2924   labelNewlineSeparator.SetProperty(TextLabel::Property::ELLIPSIS, false);
2925   labelNewlineSeparator.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2926   labelNewlineSeparator.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
2927   labelNewlineSeparator.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2928   labelNewlineSeparator.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2929   labelNewlineSeparator.SetProperty(TextLabel::Property::TEXT, "test paragraph tag \ntest paragraph tag \ntest paragraph tag ");
2930
2931   labelParagraphTag.SetProperty(TextLabel::Property::MULTI_LINE, true);
2932   labelParagraphTag.SetProperty(TextLabel::Property::ELLIPSIS, false);
2933   labelParagraphTag.SetProperty(TextLabel::Property::ENABLE_MARKUP, true);
2934   labelParagraphTag.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
2935   labelParagraphTag.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2936   labelParagraphTag.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2937   labelParagraphTag.SetProperty(TextLabel::Property::TEXT, "test paragraph tag <p>test paragraph tag </p>test paragraph tag ");
2938
2939   application.SendNotification();
2940   application.Render();
2941
2942   Vector3 textNaturalSizeNewlineSeparator = labelNewlineSeparator.GetNaturalSize();
2943   Vector3 textNaturalSizeParagraphTag     = labelParagraphTag.GetNaturalSize();
2944
2945   DALI_TEST_EQUALS(textNaturalSizeNewlineSeparator, textNaturalSizeParagraphTag, TEST_LOCATION);
2946
2947   application.SendNotification();
2948   application.Render();
2949
2950   END_TEST;
2951 }