automated-tests/src/dali-toolkit/utc-Dali-Visual.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 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <iostream>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali-toolkit/dali-toolkit.h>
  23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  24 #include <dali-toolkit/devel-api/controls/control-devel.h>
  25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
  26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
  29 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
  30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  34 #include <dali/devel-api/actors/actor-devel.h>
  35 #include <dali/devel-api/object/handle-devel.h>
  36 #include <dali/devel-api/text-abstraction/font-client.h>
  37 #include <toolkit-event-thread-callback.h>
  38
  39 #include "dummy-control.h"
  40
  41 using namespace Dali;
  42 using namespace Dali::Toolkit;
  43
  44 namespace
  45 {
  46 const char* TEST_GIF_FILE_NAME          = TEST_RESOURCE_DIR "/anim.gif";
  47 const char* TEST_IMAGE_FILE_NAME        = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  48 const char* TEST_NPATCH_FILE_NAME       = TEST_RESOURCE_DIR "/button-up.9.png";
  49 const char* TEST_SVG_FILE_NAME          = TEST_RESOURCE_DIR "/svg1.svg";
  50 const char* TEST_OBJ_FILE_NAME          = TEST_RESOURCE_DIR "/Cube.obj";
  51 const char* TEST_MTL_FILE_NAME          = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
  53 const char* TEST_RESOURCE_LOCATION      = TEST_RESOURCE_DIR "/";
  54
  55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
  56
  57 Property::Map DefaultTransform()
  58 {
  59   Property::Map transformMap;
  60   transformMap
  61     .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
  62     .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
  63     .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
  64     .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
  65     .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
  66     .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
  67   return transformMap;
  68 }
  69
  70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
  71 {
  72   if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
  73   {
  74     for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
  75     {
  76       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
  77
  78       Property::Value* valueSet = NULL;
  79       if(valueGet.first.type == Property::Key::INDEX)
  80       {
  81         valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
  82       }
  83       else
  84       {
  85         // Get Key is a string so searching Set Map for a string key
  86         valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
  87       }
  88
  89       if(NULL != valueSet)
  90       {
  91         if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
  92         {
  93           tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
  94           return false;
  95         }
  96         else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
  97         {
  98           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
  99           return false;
 100         }
 101         else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
 102         {
 103           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
 104           return false;
 105         }
 106         else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
 107         {
 108           tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
 109           return false;
 110         }
 111         else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
 112         {
 113           Vector2 vector2Get = valueGet.second.Get<Vector2>();
 114           Vector2 vector2Set = valueSet->Get<Vector2>();
 115           tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
 116           return false;
 117         }
 118         else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
 119         {
 120           Vector4 vector4Get = valueGet.second.Get<Vector4>();
 121           Vector4 vector4Set = valueSet->Get<Vector4>();
 122           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);
 123           return false;
 124         }
 125       }
 126       else
 127       {
 128         if(valueGet.first.type == Property::Key::INDEX)
 129         {
 130           tet_printf("  The key %d doesn't exist.", valueGet.first.indexKey);
 131         }
 132         else
 133         {
 134           tet_printf("  The key %s doesn't exist.", valueGet.first.stringKey.c_str());
 135         }
 136         return false;
 137       }
 138     }
 139   }
 140
 141   return true;
 142 }
 143
 144 void TestShaderCodeContainSubstrings(Control control, std::vector<std::pair<std::string, bool>> substringCheckList, const char* location)
 145 {
 146   Renderer        renderer = control.GetRendererAt(0);
 147   Shader          shader   = renderer.GetShader();
 148   Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
 149   Property::Map*  map      = value.GetMap();
 150   DALI_TEST_CHECK(map);
 151
 152   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
 153   DALI_TEST_CHECK(fragment);
 154   std::string fragmentShader;
 155   DALI_TEST_CHECK(fragment->Get(fragmentShader));
 156   for(const auto& checkPair : substringCheckList)
 157   {
 158     const auto& keyword = checkPair.first;
 159     const auto& expect  = checkPair.second;
 160     tet_printf("check [%s] %s exist in fragment shader\n", keyword.c_str(), expect ? "is" : "is not");
 161     DALI_TEST_EQUALS((fragmentShader.find(keyword.c_str()) != std::string::npos), expect, location);
 162   }
 163
 164   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
 165   std::string      vertexShader;
 166   DALI_TEST_CHECK(vertex->Get(vertexShader));
 167   for(const auto& checkPair : substringCheckList)
 168   {
 169     const auto& keyword = checkPair.first;
 170     const auto& expect  = checkPair.second;
 171     tet_printf("check [%s] %s exist in vertex shader\n", keyword.c_str(), expect ? "is" : "is not");
 172     DALI_TEST_EQUALS((vertexShader.find(keyword.c_str()) != std::string::npos), expect, location);
 173   }
 174 }
 175
 176 } //namespace
 177
 178 void dali_visual_startup(void)
 179 {
 180   test_return_value = TET_UNDEF;
 181 }
 182
 183 void dali_visual_cleanup(void)
 184 {
 185   test_return_value = TET_PASS;
 186 }
 187
 188 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
 189 {
 190   Property::Map map;
 191   visual.CreatePropertyMap(map);
 192   Property::Value* value = map.Find(mixColorIndex);
 193   DALI_TEST_CHECK(value);
 194   Vector3 mixColor1;
 195   DALI_TEST_CHECK(value->Get(mixColor1));
 196   DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
 197
 198   value = map.Find(Visual::Property::MIX_COLOR);
 199   DALI_TEST_CHECK(value);
 200   Vector4 mixColor2;
 201   DALI_TEST_CHECK(value->Get(mixColor2));
 202   DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
 203
 204   value = map.Find(Visual::Property::OPACITY);
 205   DALI_TEST_CHECK(value);
 206   float opacity;
 207   DALI_TEST_CHECK(value->Get(opacity));
 208   DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
 209 }
 210
 211 int UtcDaliVisualCopyAndAssignment(void)
 212 {
 213   ToolkitTestApplication application;
 214   tet_infoline("UtcDaliVisualCopyAndAssignment");
 215
 216   VisualFactory factory = VisualFactory::Get();
 217   Property::Map propertyMap;
 218   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 219   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 220   Visual::Base visual = factory.CreateVisual(propertyMap);
 221
 222   Visual::Base visualCopy(visual);
 223   DALI_TEST_CHECK(visual == visualCopy);
 224
 225   Visual::Base emptyVisual;
 226   Visual::Base emptyVisualCopy(emptyVisual);
 227   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 228
 229   Visual::Base visualEquals;
 230   visualEquals = visual;
 231   DALI_TEST_CHECK(visual == visualEquals);
 232
 233   Visual::Base emptyVisualEquals;
 234   emptyVisualEquals = emptyVisual;
 235   DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
 236
 237   //self assignment
 238   visual = visual;
 239   DALI_TEST_CHECK(visual = visualCopy);
 240
 241   END_TEST;
 242 }
 243
 244 int UtcDaliVisualSetName01(void)
 245 {
 246   ToolkitTestApplication application;
 247   tet_infoline("UtcDaliVisualSetName");
 248
 249   VisualFactory factory = VisualFactory::Get();
 250   Property::Map propertyMap;
 251   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 252   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 253   Visual::Base visual = factory.CreateVisual(propertyMap);
 254
 255   const char* visualName = "backgroundVisual";
 256   visual.SetName(visualName);
 257
 258   DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
 259
 260   END_TEST;
 261 }
 262
 263 int UtcDaliVisualSetGetDepthIndex(void)
 264 {
 265   ToolkitTestApplication application;
 266   tet_infoline("UtcDaliVisualSetDepthIndex");
 267
 268   VisualFactory factory = VisualFactory::Get();
 269   Property::Map propertyMap;
 270   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 271   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 272   Visual::Base visual = factory.CreateVisual(propertyMap);
 273
 274   visual.SetDepthIndex(1);
 275
 276   DummyControl        dummyControl = DummyControl::New(true);
 277   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 278   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 279
 280   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 281   application.GetScene().Add(dummyControl);
 282
 283   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
 284   DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
 285   DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
 286
 287   visual.SetDepthIndex(-1);
 288   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
 289   DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
 290   DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
 291
 292   END_TEST;
 293 }
 294
 295 int UtcDaliVisualSize(void)
 296 {
 297   ToolkitTestApplication application;
 298   tet_infoline("UtcDaliVisualSize");
 299
 300   VisualFactory factory = VisualFactory::Get();
 301   Vector2       controlSize(20.f, 30.f);
 302   Vector2       naturalSize;
 303
 304   // color colorVisual
 305   Dali::Property::Map map;
 306   map[Toolkit::Visual::Property::TYPE]  = Visual::COLOR;
 307   map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
 308
 309   Visual::Base colorVisual = factory.CreateVisual(map);
 310   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 311
 312   colorVisual.GetNaturalSize(naturalSize);
 313   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 314
 315   // image visual
 316   map.Clear();
 317   map[Toolkit::Visual::Property::TYPE]                = Toolkit::Visual::IMAGE;
 318   map[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_FILE_NAME;
 319   map[Toolkit::ImageVisual::Property::DESIRED_WIDTH]  = 100.0f;
 320   map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
 321   Visual::Base imageVisual                            = factory.CreateVisual(map);
 322   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 323
 324   imageVisual.GetNaturalSize(naturalSize);
 325   DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
 326
 327   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 328
 329   // border visual
 330   float borderSize = 5.f;
 331   map.Clear();
 332   map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
 333   map[BorderVisual::Property::COLOR]   = Color::RED;
 334   map[BorderVisual::Property::SIZE]    = borderSize;
 335   Visual::Base borderVisual            = factory.CreateVisual(map);
 336   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 337   borderVisual.GetNaturalSize(naturalSize);
 338   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 339
 340   // gradient gradientVisual
 341   Property::Map propertyMap;
 342   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 343   Vector2 start(-1.f, -1.f);
 344   Vector2 end(1.f, 1.f);
 345   propertyMap.Insert("mixColor", Color::MAGENTA);
 346   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
 347   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
 348   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
 349   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 350   Property::Array stopColors;
 351   stopColors.PushBack(Color::RED);
 352   stopColors.PushBack(Color::GREEN);
 353   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 354   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 355   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 356   gradientVisual.GetNaturalSize(naturalSize);
 357   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 358
 359   // animated gradient visual
 360   propertyMap.Clear();
 361   propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
 362   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
 363   animatedGradientVisual.GetNaturalSize(naturalSize);
 364   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 365   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 366
 367   // Text visual.
 368
 369   // Load some fonts to get the same metrics on different platforms.
 370   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 371   fontClient.SetDpi(96u, 96u);
 372
 373   char*             pathNamePtr = get_current_dir_name();
 374   const std::string pathName(pathNamePtr);
 375   free(pathNamePtr);
 376
 377   fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
 378
 379   // Create a TextVisual with a font size of 12 first
 380   propertyMap.Clear();
 381   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
 382   propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
 383   propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
 384   propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
 385
 386   Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
 387   Vector2      smallTextVisualNaturalSize;
 388   smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
 389
 390   // Then create a TextVisual with a font size of 20
 391   propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
 392   Visual::Base largeTextVisual            = factory.CreateVisual(propertyMap);
 393   Vector2      largeTextVisualNaturalSize;
 394   largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
 395
 396   // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
 397   DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
 398                   smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
 399
 400   // The height returned for a particular width should also be greater for the large text visual
 401   DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
 402
 403   //AnimatedImageVisual
 404   Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
 405   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 406   animatedImageVisual.GetNaturalSize(naturalSize);
 407   // TEST_GIF_FILE: anim.gif
 408   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 409   DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
 410
 411   END_TEST;
 412 }
 413
 414 int UtcDaliVisualSetOnOffScene(void)
 415 {
 416   ToolkitTestApplication application;
 417   tet_infoline("UtcDaliVisualSetOnOffScene");
 418
 419   VisualFactory factory = VisualFactory::Get();
 420   Property::Map propertyMap;
 421   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 422   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 423   Visual::Base visual = factory.CreateVisual(propertyMap);
 424
 425   DummyControl        actor     = DummyControl::New(true);
 426   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 427   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 428
 429   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 430
 431   application.SendNotification();
 432   application.Render(0);
 433   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 434
 435   application.GetScene().Add(actor);
 436
 437   application.SendNotification();
 438   application.Render(0);
 439   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 440
 441   application.GetScene().Remove(actor);
 442
 443   application.SendNotification();
 444   application.Render(0);
 445   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 446
 447   END_TEST;
 448 }
 449
 450 int UtcDaliVisualSetOnOffScene2(void)
 451 {
 452   ToolkitTestApplication application;
 453   tet_infoline("UtcDaliVisualSetOnOffScene2");
 454
 455   VisualFactory factory = VisualFactory::Get();
 456   Property::Map propertyMap;
 457   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
 458   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
 459   Visual::Base visual = factory.CreateVisual(propertyMap);
 460
 461   DummyControl        actor     = DummyControl::New(true);
 462   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 463   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 464
 465   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 466
 467   application.SendNotification();
 468   application.Render(0);
 469   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 470
 471   // First on/off
 472   application.GetScene().Add(actor);
 473
 474   application.SendNotification();
 475   application.Render(0);
 476
 477   // Wait for loading & rasterization
 478   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 479
 480   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 481   Renderer renderer = actor.GetRendererAt(0);
 482   auto     textures = renderer.GetTextures();
 483   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
 484
 485   application.GetScene().Remove(actor);
 486
 487   application.SendNotification();
 488   application.Render(0);
 489   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 490
 491   // Second on/off
 492   application.GetScene().Add(actor);
 493
 494   application.SendNotification();
 495   application.Render(0);
 496   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 497   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 498   renderer = actor.GetRendererAt(0);
 499   textures = renderer.GetTextures();
 500   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
 501
 502   application.GetScene().Remove(actor);
 503
 504   application.SendNotification();
 505   application.Render(0);
 506   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 507
 508   END_TEST;
 509 }
 510
 511 int UtcDaliVisualGetPropertyMap1(void)
 512 {
 513   ToolkitTestApplication application;
 514   tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
 515
 516   VisualFactory factory = VisualFactory::Get();
 517   Property::Map propertyMap;
 518   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 519   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
 520   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
 521   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
 522   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
 523   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
 524   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
 525   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
 526   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
 527
 528   Property::Map resultMap;
 529   colorVisual.CreatePropertyMap(resultMap);
 530
 531   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 532   DALI_TEST_CHECK(typeValue);
 533   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
 534
 535   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
 536   DALI_TEST_CHECK(colorValue);
 537   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
 538
 539   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 540   DALI_TEST_CHECK(cornerRadiusValue);
 541   DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
 542
 543   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
 544   DALI_TEST_CHECK(cornerRadiusPolicyValue);
 545   DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
 546
 547   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 548   DALI_TEST_CHECK(borderlineWidthValue);
 549   DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
 550
 551   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
 552   DALI_TEST_CHECK(borderlineColorValue);
 553   DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
 554
 555   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
 556   DALI_TEST_CHECK(borderlineOffsetValue);
 557   DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
 558
 559   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
 560   DALI_TEST_CHECK(blurRadiusValue);
 561   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
 562
 563   // change the blend color
 564   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 565   colorVisual                                   = factory.CreateVisual(propertyMap);
 566   colorVisual.CreatePropertyMap(resultMap);
 567
 568   colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
 569   DALI_TEST_CHECK(colorValue);
 570   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
 571
 572   // Test wrong values
 573   propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
 574
 575   colorVisual = factory.CreateVisual(propertyMap);
 576   colorVisual.CreatePropertyMap(resultMap);
 577
 578   blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
 579   DALI_TEST_CHECK(blurRadiusValue);
 580   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
 581
 582   END_TEST;
 583 }
 584
 585 int UtcDaliVisualGetPropertyMap2(void)
 586 {
 587   ToolkitTestApplication application;
 588   tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
 589
 590   VisualFactory factory = VisualFactory::Get();
 591   Property::Map propertyMap;
 592   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
 593   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
 594   propertyMap.Insert("borderColor", Color::BLUE);
 595   propertyMap.Insert("borderSize", 5.f);
 596   propertyMap.Insert("antiAliasing", true);
 597   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
 598
 599   Property::Map resultMap;
 600   borderVisual.CreatePropertyMap(resultMap);
 601
 602   // check the property values from the returned map from visual
 603   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 604   DALI_TEST_CHECK(typeValue);
 605   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
 606
 607   Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
 608   DALI_TEST_CHECK(colorValue);
 609   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
 610
 611   Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
 612   DALI_TEST_CHECK(sizeValue);
 613   DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
 614
 615   Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
 616   DALI_TEST_CHECK(AAValue);
 617   DALI_TEST_CHECK(AAValue->Get<bool>() == true);
 618
 619   Property::Map propertyMap1;
 620   propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
 621   propertyMap1[BorderVisual::Property::COLOR]   = Color::CYAN;
 622   propertyMap1[BorderVisual::Property::SIZE]    = 10.0f;
 623   borderVisual                                  = factory.CreateVisual(propertyMap1);
 624   borderVisual.CreatePropertyMap(resultMap);
 625
 626   typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 627   DALI_TEST_CHECK(typeValue);
 628   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
 629
 630   colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
 631   DALI_TEST_CHECK(colorValue);
 632   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
 633
 634   sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
 635   DALI_TEST_CHECK(sizeValue);
 636   DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
 637
 638   END_TEST;
 639 }
 640
 641 int UtcDaliVisualGetPropertyMap2N(void)
 642 {
 643   ToolkitTestApplication application;
 644   tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
 645
 646   VisualFactory factory = VisualFactory::Get();
 647   Property::Map propertyMap;
 648   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
 649   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
 650
 651   tet_infoline("Test that the visual is created, with a default renderer");
 652   DALI_TEST_CHECK(borderVisual);
 653
 654   DummyControl        dummyControl = DummyControl::New(true);
 655   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 656   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
 657   application.GetScene().Add(dummyControl);
 658
 659   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
 660
 661   END_TEST;
 662 }
 663
 664 int UtcDaliVisualGetPropertyMap3(void)
 665 {
 666   ToolkitTestApplication application;
 667   tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
 668
 669   VisualFactory factory = VisualFactory::Get();
 670   DALI_TEST_CHECK(factory);
 671
 672   Property::Map propertyMap;
 673   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 674
 675   Vector2 start(-1.f, -1.f);
 676   Vector2 end(1.f, 1.f);
 677   propertyMap.Insert("startPosition", start);
 678   propertyMap.Insert("endPosition", end);
 679   propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 680
 681   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
 682
 683   Property::Array stopColors;
 684   stopColors.PushBack(Color::RED);
 685   stopColors.PushBack(Color::GREEN);
 686   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 687
 688   float   borderlineWidth = 4.0f;
 689   Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
 690   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
 691   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
 692
 693   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 694
 695   Property::Map resultMap;
 696   gradientVisual.CreatePropertyMap(resultMap);
 697
 698   // check the property values from the returned map from visual
 699   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 700   DALI_TEST_CHECK(value);
 701   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
 702
 703   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
 704   DALI_TEST_CHECK(value);
 705   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
 706
 707   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
 708   DALI_TEST_CHECK(value);
 709   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
 710
 711   value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
 712   DALI_TEST_CHECK(value);
 713   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 714
 715   value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
 716   DALI_TEST_CHECK(value);
 717   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 718
 719   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 720   DALI_TEST_CHECK(value);
 721   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 722
 723   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 724   DALI_TEST_CHECK(value);
 725   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 726
 727   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
 728   DALI_TEST_CHECK(value);
 729   Property::Array* offsetArray = value->GetArray();
 730   DALI_TEST_CHECK(offsetArray->Count() == 2);
 731   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 732   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 733
 734   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
 735   DALI_TEST_CHECK(value);
 736   Property::Array* colorArray = value->GetArray();
 737   DALI_TEST_CHECK(colorArray->Count() == 2);
 738   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 739   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 740
 741   END_TEST;
 742 }
 743
 744 int UtcDaliVisualGetPropertyMap4(void)
 745 {
 746   ToolkitTestApplication application;
 747   tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
 748
 749   VisualFactory factory = VisualFactory::Get();
 750   DALI_TEST_CHECK(factory);
 751
 752   Property::Map propertyMap;
 753   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 754
 755   Vector2 center(100.f, 100.f);
 756   float   radius = 100.f;
 757   propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
 758   propertyMap.Insert(GradientVisual::Property::CENTER, center);
 759   propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
 760   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
 761
 762   Property::Array stopColors;
 763   stopColors.PushBack(Color::RED);
 764   stopColors.PushBack(Color::BLACK);
 765   stopColors.PushBack(Color::GREEN);
 766   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 767
 768   float   borderlineWidth = 8.0f;
 769   Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
 770   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
 771   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
 772
 773   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 774   DALI_TEST_CHECK(gradientVisual);
 775
 776   Property::Map resultMap;
 777   gradientVisual.CreatePropertyMap(resultMap);
 778
 779   // check the property values from the returned map from visual
 780   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 781   DALI_TEST_CHECK(value);
 782   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
 783
 784   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
 785   DALI_TEST_CHECK(value);
 786   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
 787
 788   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
 789   DALI_TEST_CHECK(value);
 790   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
 791
 792   value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
 793   DALI_TEST_CHECK(value);
 794   DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 795
 796   value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
 797   DALI_TEST_CHECK(value);
 798   DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 799
 800   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 801   DALI_TEST_CHECK(value);
 802   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 803
 804   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 805   DALI_TEST_CHECK(value);
 806   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 807
 808   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
 809   DALI_TEST_CHECK(value);
 810   Property::Array* offsetArray = value->GetArray();
 811   DALI_TEST_CHECK(offsetArray->Count() == 3);
 812   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 813   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 814   // any stop value will be clamped to [0.0, 1.0];
 815   DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 816
 817   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
 818   DALI_TEST_CHECK(value);
 819   Property::Array* colorArray = value->GetArray();
 820   DALI_TEST_CHECK(colorArray->Count() == 3);
 821   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 822   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 823   DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 824
 825   END_TEST;
 826 }
 827
 828 int UtcDaliVisualGetPropertyMap5(void)
 829 {
 830   ToolkitTestApplication application;
 831   tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
 832
 833   VisualFactory factory = VisualFactory::Get();
 834   Property::Map propertyMap;
 835   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
 836   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
 837   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
 838   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
 839   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
 840   propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
 841   propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
 842   propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
 843   propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
 844   propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
 845   propertyMap.Insert("synchronousLoading", true);
 846
 847   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 848   DALI_TEST_CHECK(imageVisual);
 849
 850   Property::Map resultMap;
 851   imageVisual.CreatePropertyMap(resultMap);
 852
 853   // check the property values from the returned map from visual
 854   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 855   DALI_TEST_CHECK(value);
 856   DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
 857
 858   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 859   DALI_TEST_CHECK(value);
 860   DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
 861
 862   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 863   DALI_TEST_CHECK(value);
 864   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 865
 866   value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
 867   DALI_TEST_CHECK(value);
 868   DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
 869
 870   value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
 871   DALI_TEST_CHECK(value);
 872   DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
 873
 874   value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
 875   DALI_TEST_CHECK(value);
 876   DALI_TEST_CHECK(value->Get<int>() == 20);
 877
 878   value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
 879   DALI_TEST_CHECK(value);
 880   DALI_TEST_CHECK(value->Get<int>() == 30);
 881
 882   value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
 883   DALI_TEST_CHECK(value);
 884   DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
 885
 886   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
 887   DALI_TEST_CHECK(value);
 888   DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
 889
 890   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
 891   DALI_TEST_CHECK(value);
 892   DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 893
 894   value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
 895   DALI_TEST_CHECK(value);
 896   DALI_TEST_CHECK(value->Get<bool>() == true);
 897
 898   END_TEST;
 899 }
 900
 901 int UtcDaliVisualGetPropertyMap6(void)
 902 {
 903   ToolkitTestApplication application;
 904   tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
 905
 906   Rect<int> border(1, 1, 1, 1);
 907
 908   VisualFactory factory = VisualFactory::Get();
 909   Property::Map propertyMap;
 910   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
 911   propertyMap.Insert("mixColor", Color::MAGENTA);
 912   propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
 913   propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
 914   propertyMap.Insert(ImageVisual::Property::BORDER, border);
 915   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
 916   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
 917   Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
 918
 919   Property::Map resultMap;
 920   nPatchVisual.CreatePropertyMap(resultMap);
 921
 922   // check the property values from the returned map from visual
 923   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 924   DALI_TEST_CHECK(value);
 925   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
 926
 927   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 928   DALI_TEST_CHECK(value);
 929   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 930
 931   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 932   DALI_TEST_CHECK(value);
 933   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
 934
 935   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
 936   DALI_TEST_CHECK(value);
 937   DALI_TEST_CHECK(value->Get<bool>());
 938
 939   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
 940   DALI_TEST_CHECK(value);
 941   DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
 942
 943   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
 944   DALI_TEST_CHECK(value);
 945   DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
 946
 947   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
 948   DALI_TEST_CHECK(value);
 949   DALI_TEST_CHECK(value->Get<float>() == 0.9f);
 950
 951   Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
 952
 953   Property::Map propertyMap1;
 954   propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
 955   propertyMap1.Insert("mixColor", Color::MAGENTA);
 956   propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
 957   propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
 958   propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
 959   nPatchVisual = factory.CreateVisual(propertyMap1);
 960
 961   nPatchVisual.CreatePropertyMap(resultMap);
 962
 963   // check the property values from the returned map from visual
 964   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 965   DALI_TEST_CHECK(value);
 966   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
 967
 968   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 969   DALI_TEST_CHECK(value);
 970   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 971
 972   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 973   DALI_TEST_CHECK(value);
 974   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
 975
 976   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
 977   DALI_TEST_CHECK(value);
 978   DALI_TEST_CHECK(value->Get<bool>());
 979
 980   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
 981   DALI_TEST_CHECK(value);
 982   DALI_TEST_CHECK(value->Get<Rect<int>>() == border);
 983
 984   END_TEST;
 985 }
 986
 987 int UtcDaliVisualGetPropertyMap7(void)
 988 {
 989   ToolkitTestApplication application;
 990   tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
 991
 992   // request SvgVisual with a property map
 993   VisualFactory factory = VisualFactory::Get();
 994   Property::Map propertyMap;
 995   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
 996   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
 997   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
 998   propertyMap.Insert(ImageVisual::Property::ATLASING, false);
 999   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
1000
1001   Property::Map resultMap;
1002   svgVisual.CreatePropertyMap(resultMap);
1003   // check the property values from the returned map from a visual
1004   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1005   DALI_TEST_CHECK(value);
1006   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1007
1008   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1009   DALI_TEST_CHECK(value);
1010   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1011
1012   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1013   DALI_TEST_CHECK(value);
1014   DALI_TEST_CHECK(value->Get<bool>() == false);
1015
1016   // request SvgVisual with a property map 2
1017   propertyMap.Clear();
1018   propertyMap["visualType"] = Visual::SVG;
1019   propertyMap["mixColor"]   = Color::WHITE;
1020   propertyMap["url"]        = TEST_SVG_FILE_NAME;
1021   propertyMap["atlasing"]   = true;
1022   Visual::Base svgVisual1   = factory.CreateVisual(propertyMap);
1023
1024   resultMap.Clear();
1025   svgVisual1.CreatePropertyMap(resultMap);
1026   // check the property values from the returned map from a visual
1027   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1028   DALI_TEST_CHECK(value);
1029   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1030
1031   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1032   DALI_TEST_CHECK(value);
1033   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1034
1035   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1036   DALI_TEST_CHECK(value);
1037   DALI_TEST_CHECK(value->Get<bool>() == true);
1038
1039   // request SvgVisual with an URL
1040   Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1041   resultMap.Clear();
1042   svgVisual2.CreatePropertyMap(resultMap);
1043   // check the property values from the returned map from a visual
1044   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1045   DALI_TEST_CHECK(value);
1046   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1047
1048   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1049   DALI_TEST_CHECK(value);
1050   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1051
1052   END_TEST;
1053 }
1054
1055 //Mesh visual
1056 int UtcDaliVisualGetPropertyMap8(void)
1057 {
1058   ToolkitTestApplication application;
1059   tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1060
1061   //Request MeshVisual using a property map.
1062   VisualFactory factory = VisualFactory::Get();
1063   Property::Map propertyMap;
1064   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1065   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1066   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1067   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1068   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1069   propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1070   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1071   Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1072
1073   Property::Map resultMap;
1074   meshVisual.CreatePropertyMap(resultMap);
1075   TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1076
1077   //Check values in the result map are identical to the initial map's values.
1078   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1079   DALI_TEST_CHECK(value);
1080   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1081
1082   value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1083   DALI_TEST_CHECK(value);
1084   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1085
1086   value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1087   DALI_TEST_CHECK(value);
1088   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1089
1090   value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1091   DALI_TEST_CHECK(value);
1092   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1093
1094   value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1095   DALI_TEST_CHECK(value);
1096   DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1097
1098   value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1099   DALI_TEST_CHECK(value);
1100   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1101
1102   END_TEST;
1103 }
1104
1105 //Primitive shape visual
1106 int UtcDaliVisualGetPropertyMap9(void)
1107 {
1108   ToolkitTestApplication application;
1109   tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1110
1111   static std::vector<UniformData> customUniforms =
1112     {
1113       UniformData("mixColor", Property::Type::VECTOR3),
1114     };
1115
1116   TestGraphicsController& graphics = application.GetGraphicsController();
1117   graphics.AddCustomUniforms(customUniforms);
1118
1119   Vector4 color      = Vector4(1.0, 0.8, 0.6, 1.0);
1120   Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1121
1122   //Request PrimitiveVisual using a property map.
1123   VisualFactory factory = VisualFactory::Get();
1124   Property::Map propertyMap;
1125   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1126   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1127   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1128   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1129   propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1130   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1131   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1132   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1133   propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1134   propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1135   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1136   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1137   propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1138   Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1139
1140   Property::Map resultMap;
1141   primitiveVisual.CreatePropertyMap(resultMap);
1142
1143   //Check values in the result map are identical to the initial map's values.
1144   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1145   DALI_TEST_CHECK(value);
1146   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1147
1148   value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1149   DALI_TEST_CHECK(value);
1150   DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1151
1152   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1153   DALI_TEST_CHECK(value);
1154   DALI_TEST_CHECK(value->Get<Vector4>() == color);
1155   DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1156
1157   value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1158   DALI_TEST_CHECK(value);
1159   DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1160
1161   value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1162   DALI_TEST_CHECK(value);
1163   DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1164
1165   value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1166   DALI_TEST_CHECK(value);
1167   DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1168
1169   value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1170   DALI_TEST_CHECK(value);
1171   DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1172
1173   value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1174   DALI_TEST_CHECK(value);
1175   DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1176
1177   value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1178   DALI_TEST_CHECK(value);
1179   DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1180
1181   value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1182   DALI_TEST_CHECK(value);
1183   DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1184
1185   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1186   DALI_TEST_CHECK(value);
1187   DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1188
1189   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1190   DALI_TEST_CHECK(value);
1191   DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1192
1193   value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1194   DALI_TEST_CHECK(value);
1195   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1196
1197   DummyControl        actor     = DummyControl::New(true);
1198   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1199   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1200   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1201   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1202   application.GetScene().Add(actor);
1203
1204   Animation animation = Animation::New(1.0f);
1205   animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1206   animation.Play();
1207   application.SendNotification();
1208   application.Render(0);
1209   application.Render(1000);
1210   application.SendNotification();
1211
1212   auto& gl = application.GetGlAbstraction();
1213   DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1214
1215   tet_infoline("Check property map after animation");
1216
1217   primitiveVisual.CreatePropertyMap(resultMap);
1218   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1219   DALI_TEST_CHECK(value);
1220   color = value->Get<Vector4>();
1221   // Ignore alpha part
1222   DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1223
1224   END_TEST;
1225 }
1226
1227 //Text shape visual
1228 int UtcDaliVisualGetPropertyMap10(void)
1229 {
1230   ToolkitTestApplication application;
1231   tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1232
1233   //Request PrimitiveVisual using a property map.
1234   VisualFactory factory = VisualFactory::Get();
1235
1236   Property::Map propertyMap;
1237   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1238   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1239   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1240   propertyMap.Insert("enableMarkup", false);
1241   propertyMap.Insert("text", "Hello world");
1242   propertyMap.Insert("fontFamily", "TizenSans");
1243
1244   Property::Map fontStyleMapSet;
1245   fontStyleMapSet.Insert("weight", "bold");
1246   propertyMap.Insert("fontStyle", fontStyleMapSet);
1247
1248   propertyMap.Insert("pointSize", 12.f);
1249   propertyMap.Insert("multiLine", true);
1250   propertyMap.Insert("horizontalAlignment", "CENTER");
1251   propertyMap.Insert("verticalAlignment", "CENTER");
1252   propertyMap.Insert("textColor", Color::RED);
1253
1254   Property::Map shadowMapSet;
1255   propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1256
1257   Property::Map underlineMapSet;
1258   propertyMap.Insert("underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1).Add("type", Text::Underline::Type::SOLID).Add("dashWidth", 2).Add("dashGap", 1));
1259
1260   Property::Map outlineMapSet;
1261   propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1262
1263   Property::Map backgroundMapSet;
1264   propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1265
1266   Visual::Base textVisual = factory.CreateVisual(propertyMap);
1267
1268   Property::Map resultMap;
1269   textVisual.CreatePropertyMap(resultMap);
1270
1271   //Check values in the result map are identical to the initial map's values.
1272   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1273   DALI_TEST_CHECK(value);
1274   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1275
1276   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1277   DALI_TEST_CHECK(value);
1278   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1279
1280   value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1281   DALI_TEST_CHECK(value);
1282   DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1283
1284   value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1285   DALI_TEST_CHECK(value);
1286   DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1287
1288   value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1289   DALI_TEST_CHECK(value);
1290
1291   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1292   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1293   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1294
1295   value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1296   DALI_TEST_CHECK(value);
1297   DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1298
1299   value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1300   DALI_TEST_CHECK(value);
1301   DALI_TEST_CHECK(value->Get<bool>());
1302
1303   value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1304   DALI_TEST_CHECK(value);
1305   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1306
1307   value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1308   DALI_TEST_CHECK(value);
1309   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1310
1311   value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1312   DALI_TEST_CHECK(value);
1313   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1314
1315   value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1316   DALI_TEST_CHECK(value);
1317   DALI_TEST_CHECK(!value->Get<bool>());
1318
1319   value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1320   DALI_TEST_CHECK(value);
1321
1322   Property::Map shadowMapGet = value->Get<Property::Map>();
1323   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1324   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1325
1326   value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1327   DALI_TEST_CHECK(value);
1328
1329   Property::Map underlineMapGet = value->Get<Property::Map>();
1330   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1331   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1332
1333   value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1334   DALI_TEST_CHECK(value);
1335
1336   Property::Map outlineMapGet = value->Get<Property::Map>();
1337   DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1338   DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1339
1340   value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1341   DALI_TEST_CHECK(value);
1342
1343   Property::Map backgroundMapGet = value->Get<Property::Map>();
1344   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1345   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1346
1347   END_TEST;
1348 }
1349
1350 int UtcDaliVisualGetPropertyMap11(void)
1351 {
1352   ToolkitTestApplication application;
1353   tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1354
1355   VisualFactory factory = VisualFactory::Get();
1356   DALI_TEST_CHECK(factory);
1357
1358   Property::Map propertyMap;
1359   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1360
1361   Vector2 start(-0.5f, 0.5f);
1362   Vector2 end(0.5f, -0.0f);
1363   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1364   Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1365   Vector2 rotate_center(0.0f, 0.4f);
1366   float   rotate_amount = 1.57f;
1367   float   offset        = 100.f;
1368
1369   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1370   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1371   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1372
1373   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1374   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1375   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1376   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1377   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1378   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1379   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1380
1381   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1382   DALI_TEST_CHECK(animatedGradientVisual);
1383
1384   Property::Map resultMap;
1385   animatedGradientVisual.CreatePropertyMap(resultMap);
1386
1387   // check the property values from the returned map from visual
1388   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1389   DALI_TEST_CHECK(value);
1390   DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1391
1392   value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1393   DALI_TEST_CHECK(value);
1394   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1395
1396   value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1397   DALI_TEST_CHECK(value);
1398   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1399
1400   value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1401   DALI_TEST_CHECK(value);
1402   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1403
1404   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1405   DALI_TEST_CHECK(value);
1406   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1407
1408   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1409   DALI_TEST_CHECK(value);
1410   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1411
1412   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1413   DALI_TEST_CHECK(value);
1414   DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1415
1416   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1417   DALI_TEST_CHECK(value);
1418   DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1419
1420   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1421   DALI_TEST_CHECK(value);
1422   DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1423
1424   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1425   DALI_TEST_CHECK(value);
1426   DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1427
1428   value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1429   DALI_TEST_CHECK(value);
1430   DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1431
1432   END_TEST;
1433 }
1434
1435 int UtcDaliVisualGetPropertyMap12(void)
1436 {
1437   ToolkitTestApplication application;
1438   tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1439
1440   // Case 1 : Set values by index
1441   {
1442     tet_printf(" - Set Values by Index\n");
1443     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1444     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1445     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1446     {
1447       tet_printf("test with delay [%f]\n", _delay);
1448       VisualFactory factory = VisualFactory::Get();
1449       DALI_TEST_CHECK(factory);
1450
1451       Property::Map propertyMap;
1452       Property::Map animationMap;
1453       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1454
1455       float duration     = 1.1f;
1456       float delay        = _delay;
1457       float repeat_delay = 0.4f;
1458
1459       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1460       int loop_count = 5;
1461       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1462       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1463
1464       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1465         animationMap.Clear();
1466         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1467         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1468         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1469         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1470         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1471         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1472         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1473         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1474         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1475
1476         return animationMap;
1477       };
1478
1479       Vector2 start1(-0.5f, 0.5f);
1480       Vector2 end1(0.5f, -0.5f);
1481       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1482       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1483       Vector2 rotate_center1(0.0f, 0.4f);
1484       float   rotate_amount1 = 0.0f;
1485       float   offset1        = 0.f;
1486
1487       Vector2 start2(-0.5f, -0.5f);
1488       Vector2 end2(0.5f, 0.5f);
1489       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1490       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1491       Vector2 rotate_center2(0.0f, -0.4f);
1492       float   rotate_amount2 = 6.2832f;
1493       float   offset2        = 2.f;
1494
1495       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1496       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1497       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1498
1499       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1500       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1501       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1502       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1503       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1504       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1505       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1506
1507       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1508       DALI_TEST_CHECK(animatedGradientVisual);
1509
1510       Property::Map resultMap;
1511       animatedGradientVisual.CreatePropertyMap(resultMap);
1512
1513       // check the property values from the returned map from visual
1514       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1515       DALI_TEST_CHECK(value);
1516       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1517
1518       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1519       DALI_TEST_CHECK(value);
1520       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1521
1522       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1523       DALI_TEST_CHECK(value);
1524       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1525
1526       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1527       DALI_TEST_CHECK(value);
1528       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1529
1530       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1531         tet_printf("Check value at %d\n", line_num);
1532         value = resultMap.Find(index, Property::MAP);
1533         DALI_TEST_CHECK(value);
1534         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1535         Property::Map* temp_map = value->GetMap();
1536         DALI_TEST_CHECK(temp_map);
1537
1538         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1539           Property::Value* res = temp_map->Find(index);
1540           DALI_TEST_CHECK(res);
1541           return *res;
1542         };
1543
1544         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1545         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1546         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1547         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1548         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1549         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1550         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1551         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1552         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1553       };
1554
1555       // check the animation map data is good
1556       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1557       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1558       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1559       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1560       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1561       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1562       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1563     }
1564   }
1565
1566   // Case 2 : Set values by string
1567   {
1568     tet_printf(" - Set Values by String\n");
1569     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1570     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1571     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1572     {
1573       tet_printf("test with delay [%f]\n", _delay);
1574       VisualFactory factory = VisualFactory::Get();
1575       DALI_TEST_CHECK(factory);
1576
1577       Property::Map propertyMap;
1578       Property::Map animationMap;
1579       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1580
1581       float duration     = 1.1f;
1582       float delay        = _delay;
1583       float repeat_delay = 0.4f;
1584
1585       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1586       int loop_count = 5;
1587       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1588       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1589
1590       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1591         animationMap.Clear();
1592         animationMap.Insert("startValue", start);
1593         animationMap.Insert("targetValue", target);
1594         animationMap.Insert("directionType", "BACKWARD");
1595         animationMap.Insert("duration", duration);
1596         animationMap.Insert("delay", delay);
1597         animationMap.Insert("repeat", loop_count);
1598         animationMap.Insert("repeatDelay", repeat_delay);
1599         animationMap.Insert("motionType", "MIRROR");
1600         animationMap.Insert("easingType", "IN_OUT");
1601
1602         return animationMap;
1603       };
1604
1605       Vector2 start1(-0.5f, 0.5f);
1606       Vector2 end1(0.5f, -0.5f);
1607       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1608       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1609       Vector2 rotate_center1(0.0f, 0.4f);
1610       float   rotate_amount1 = 0.0f;
1611       float   offset1        = 0.f;
1612
1613       Vector2 start2(-0.5f, -0.5f);
1614       Vector2 end2(0.5f, 0.5f);
1615       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1616       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1617       Vector2 rotate_center2(0.0f, -0.4f);
1618       float   rotate_amount2 = 6.2832f;
1619       float   offset2        = 2.f;
1620
1621       // For test mix the type string/index key and string/index value works well.
1622       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1623       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1624       propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1625
1626       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1627       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1628       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1629       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1630       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1631       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1632       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1633
1634       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1635       DALI_TEST_CHECK(animatedGradientVisual);
1636
1637       Property::Map resultMap;
1638       animatedGradientVisual.CreatePropertyMap(resultMap);
1639
1640       // check the property values from the returned map from visual
1641       // Note : resultMap from CreatePropertyMap only contain indexKey
1642       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1643       DALI_TEST_CHECK(value);
1644       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1645
1646       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1647       DALI_TEST_CHECK(value);
1648       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1649
1650       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1651       DALI_TEST_CHECK(value);
1652       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1653
1654       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1655       DALI_TEST_CHECK(value);
1656       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1657
1658       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1659         tet_printf("Check value at %d\n", line_num);
1660         value = resultMap.Find(index, Property::MAP);
1661         DALI_TEST_CHECK(value);
1662         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1663         Property::Map* temp_map = value->GetMap();
1664         DALI_TEST_CHECK(temp_map);
1665
1666         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1667           Property::Value* res = temp_map->Find(index);
1668           DALI_TEST_CHECK(res);
1669           return *res;
1670         };
1671
1672         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1673         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1674         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1675         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1676         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1677         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1678         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1679         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1680         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1681       };
1682
1683       // check the animation map data is good
1684       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1685       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1686       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1687       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1688       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1689       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1690       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1691     }
1692   }
1693
1694   END_TEST;
1695 }
1696 int UtcDaliVisualGetPropertyMap13(void)
1697 {
1698   ToolkitTestApplication application;
1699   tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1700
1701   for(int _direction = 0; _direction <= 1; ++_direction)
1702   {
1703     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1704     {
1705       tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1706       VisualFactory factory = VisualFactory::Get();
1707       DALI_TEST_CHECK(factory);
1708
1709       Property::Map propertyMap;
1710       Property::Map animationMap;
1711       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1712
1713       float duration     = 1.0f;
1714       float delay        = _delay;
1715       float repeat_delay = 0.5f;
1716
1717       int direction  = _direction;
1718       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1719       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1720       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1721
1722       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1723         animationMap.Clear();
1724         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1725         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1726         if(direction == 0)
1727           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1728         else
1729           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1730         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1731         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1732         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1733         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1734         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1735         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1736         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1737
1738         return animationMap;
1739       };
1740
1741       Vector2 start1(-0.5f, 0.5f);
1742       Vector2 end1(0.5f, -0.5f);
1743       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1744       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1745       Vector2 rotate_center1(1.0f, 0.4f);
1746       float   rotate_amount1 = 2.0f;
1747       float   offset1        = 1.f;
1748
1749       Vector2 start2(-0.5f, -0.5f);
1750       Vector2 end2(0.5f, 0.5f);
1751       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1752       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1753       Vector2 rotate_center2(1.0f, -0.4f);
1754       float   rotate_amount2 = 1.0f;
1755       float   offset2        = 3.f;
1756
1757       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1758       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1759       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1760
1761       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1762       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1763       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1764       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1765       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1766       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1767       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1768
1769       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1770       DALI_TEST_CHECK(animatedGradientVisual);
1771
1772       Property::Map resultMap;
1773       animatedGradientVisual.CreatePropertyMap(resultMap);
1774
1775       // check the property values from the returned map from visual
1776       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1777       DALI_TEST_CHECK(value);
1778       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1779
1780       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1781       DALI_TEST_CHECK(value);
1782       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1783
1784       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1785       DALI_TEST_CHECK(value);
1786       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1787
1788       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1789       DALI_TEST_CHECK(value);
1790       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1791
1792       // If loop_count = 0, Animation doesn't created.
1793       // Optimized resultMap only have one value, which is target value
1794       // Note: target value will be changed by direction option.
1795       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1796       DALI_TEST_CHECK(value);
1797       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1798
1799       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1800       DALI_TEST_CHECK(value);
1801       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1802
1803       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1804       DALI_TEST_CHECK(value);
1805       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1806
1807       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1808       DALI_TEST_CHECK(value);
1809       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1810
1811       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1812       DALI_TEST_CHECK(value);
1813       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1814
1815       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1816       DALI_TEST_CHECK(value);
1817       DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1818
1819       value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1820       DALI_TEST_CHECK(value);
1821       DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1822     }
1823   }
1824
1825   END_TEST;
1826 }
1827
1828 int UtcDaliVisualAnimateBorderVisual01(void)
1829 {
1830   ToolkitTestApplication application;
1831   tet_infoline("UtcDaliAnimateBorderVisual Color");
1832
1833   static std::vector<UniformData> customUniforms =
1834     {
1835       UniformData("borderColor", Property::Type::VECTOR4),
1836       UniformData("mixColor", Property::Type::VECTOR3),
1837     };
1838
1839   TestGraphicsController& graphics = application.GetGraphicsController();
1840   graphics.AddCustomUniforms(customUniforms);
1841
1842   VisualFactory factory = VisualFactory::Get();
1843   Property::Map propertyMap;
1844   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1845   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1846   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1847   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1848   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1849
1850   Property::Map map;
1851   map["target"]      = "testVisual";
1852   map["property"]    = "mixColor";
1853   map["targetValue"] = Vector4(1, 1, 1, 0.1);
1854   map["animator"]    = Property::Map()
1855                       .Add("alphaFunction", "LINEAR")
1856                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1857
1858   Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1859
1860   DummyControl        actor     = DummyControl::New(true);
1861   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1862   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1863   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1864   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1865   application.GetScene().Add(actor);
1866
1867   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1868
1869   Renderer        renderer         = actor.GetRendererAt(0);
1870   Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1871   Property::Index mixColorIndex    = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1872
1873   Animation animation = dummyImpl.CreateTransition(transition);
1874
1875   // Animate the mix color through the transition, and the border color through
1876   // programmatic method.
1877   animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1878   animation.Play();
1879
1880   application.SendNotification();
1881   application.Render(0);
1882   application.Render(2000u); // halfway point between blue and white
1883
1884   Vector4 color     = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1885   Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1886   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1887   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1888
1889   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1890   testColor = Vector4(1, 1, 1, 0.45f);
1891   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1892   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1893
1894   Vector4 uColor;
1895   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1896   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1897
1898   application.Render(2000u);
1899
1900   color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1901   DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1902   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1903
1904   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1905   testColor = Vector4(1, 1, 1, 0.1);
1906   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1907   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1908
1909   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1910   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1911
1912   END_TEST;
1913 }
1914
1915 int UtcDaliVisualAnimateBorderVisual02(void)
1916 {
1917   ToolkitTestApplication application;
1918   tet_infoline("UtcDaliAnimateBorderVisual Size");
1919
1920   static std::vector<UniformData> customUniforms =
1921     {
1922       UniformData("borderSize", Property::Type::FLOAT),
1923     };
1924
1925   TestGraphicsController& graphics = application.GetGraphicsController();
1926   graphics.AddCustomUniforms(customUniforms);
1927
1928   VisualFactory factory = VisualFactory::Get();
1929   Property::Map propertyMap;
1930   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1931   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1932   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1933   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1934
1935   DummyControl        actor     = DummyControl::New(true);
1936   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1937   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1938   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1939   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1940   application.GetScene().Add(actor);
1941
1942   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1943
1944   Renderer        renderer = actor.GetRendererAt(0);
1945   Property::Index index    = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1946
1947   Animation animation = Animation::New(4.0f);
1948   animation.AnimateTo(Property(renderer, index), 9.0f);
1949   animation.Play();
1950
1951   application.SendNotification();
1952   application.Render(0);
1953   application.Render(2000u); // halfway point
1954
1955   float size = renderer.GetCurrentProperty<float>(index);
1956   DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1957   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1958
1959   application.Render(2000u); // halfway point between blue and white
1960
1961   size = renderer.GetCurrentProperty<float>(index);
1962   DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1963   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1964
1965   END_TEST;
1966 }
1967
1968 int UtcDaliVisualAnimateColorVisual(void)
1969 {
1970   ToolkitTestApplication application;
1971   tet_infoline("UtcDaliAnimateColorVisual mixColor");
1972
1973   static std::vector<UniformData> customUniforms =
1974     {
1975       UniformData("mixColor", Property::Type::VECTOR3),
1976     };
1977
1978   TestGraphicsController& graphics = application.GetGraphicsController();
1979   graphics.AddCustomUniforms(customUniforms);
1980
1981   VisualFactory factory = VisualFactory::Get();
1982   Property::Map propertyMap;
1983   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1984   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1985   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1986
1987   DummyControl        actor     = DummyControl::New(true);
1988   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1989   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1990   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1991   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1992   application.GetScene().Add(actor);
1993
1994   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1995
1996   Renderer        renderer      = actor.GetRendererAt(0);
1997   Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1998
1999   Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
2000   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2001
2002   Animation animation = Animation::New(4.0f);
2003   animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
2004   animation.Play();
2005
2006   application.SendNotification();
2007   application.Render(0);
2008   application.Render(2000u); // halfway point
2009
2010   Vector3 color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2011   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2012   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2013
2014   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2015
2016   application.Render(2000u); // halfway point between blue and white
2017
2018   color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2019   DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2020
2021   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2022
2023   blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2024   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2025
2026   END_TEST;
2027 }
2028
2029 int UtcDaliVisualAnimatePrimitiveVisual(void)
2030 {
2031   ToolkitTestApplication application;
2032   tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2033
2034   static std::vector<UniformData> customUniforms =
2035     {
2036       UniformData("mixColor", Property::Type::VECTOR3),
2037     };
2038
2039   TestGraphicsController& graphics = application.GetGraphicsController();
2040   graphics.AddCustomUniforms(customUniforms);
2041
2042   {
2043     VisualFactory factory = VisualFactory::Get();
2044     Property::Map propertyMap;
2045     propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2046     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2047     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2048     Visual::Base visual = factory.CreateVisual(propertyMap);
2049
2050     DummyControl        actor     = DummyControl::New(true);
2051     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2052     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2053     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2054     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2055     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2056     application.GetScene().Add(actor);
2057
2058     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2059
2060     Renderer renderer = actor.GetRendererAt(0);
2061
2062     const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2063     const Vector4 TARGET_MIX_COLOR(Color::RED);
2064
2065     Property::Map map;
2066     map["target"]       = "testVisual";
2067     map["property"]     = "mixColor";
2068     map["initialValue"] = INITIAL_MIX_COLOR;
2069     map["targetValue"]  = TARGET_MIX_COLOR;
2070     map["animator"]     = Property::Map()
2071                         .Add("alphaFunction", "LINEAR")
2072                         .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2073
2074     Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2075
2076     Animation animation = dummyImpl.CreateTransition(transition);
2077     animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2078     animation.Play();
2079
2080     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2081     glAbstraction.EnableEnableDisableCallTrace(true);
2082     TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
2083     std::ostringstream blendStr;
2084     blendStr << std::hex << GL_BLEND;
2085
2086     application.SendNotification();
2087     application.Render(0);
2088     application.Render(2000u); // halfway point
2089     application.SendNotification();
2090
2091     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2092     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2093     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2094
2095     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2096
2097     glEnableStack.Reset();
2098
2099     application.Render(2001u);      // go past end
2100     application.SendNotification(); // Trigger signals
2101
2102     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2103     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2104     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2105
2106     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2107
2108     actor.Unparent();
2109   }
2110
2111   END_TEST;
2112 }
2113
2114 int UtcDaliVisualAnimatedGradientVisual01(void)
2115 {
2116   ToolkitTestApplication application;
2117   tet_infoline("UtcDaliAnimatedGradientVisual with default");
2118
2119   static std::vector<UniformData> customUniforms =
2120     {
2121       UniformData("start_point", Property::Type::VECTOR2),
2122       UniformData("end_point", Property::Type::VECTOR2),
2123       UniformData("start_color", Property::Type::VECTOR4),
2124       UniformData("end_color", Property::Type::VECTOR4),
2125       UniformData("rotate_center", Property::Type::VECTOR2),
2126       UniformData("rotate_angle", Property::Type::FLOAT),
2127       UniformData("gradient_offset", Property::Type::FLOAT),
2128     };
2129
2130   TestGraphicsController& graphics = application.GetGraphicsController();
2131   graphics.AddCustomUniforms(customUniforms);
2132
2133   {
2134     VisualFactory factory = VisualFactory::Get();
2135     Property::Map propertyMap;
2136     propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2137     Visual::Base visual = factory.CreateVisual(propertyMap);
2138
2139     DummyControl        actor     = DummyControl::New(true);
2140     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2141     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2142     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2143     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2144     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2145     application.GetScene().Add(actor);
2146
2147     application.SendNotification();
2148     application.Render(0);
2149     application.SendNotification();
2150
2151     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2152
2153     for(int step_iter = 0; step_iter < 3; step_iter++)
2154     {
2155       application.SendNotification();
2156       application.Render(0);
2157       application.Render(750u); // step i/4
2158       application.SendNotification();
2159
2160       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2161       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2162       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2163       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2164       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2165       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2166       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2167     }
2168
2169     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2170     application.Render(750u); // go to end
2171     application.SendNotification();
2172
2173     application.Render(10u); // finish
2174     application.SendNotification();
2175
2176     actor.Unparent();
2177     application.SendNotification();
2178     application.Render(0u);
2179     application.SendNotification();
2180   }
2181
2182   END_TEST;
2183 }
2184
2185 int UtcDaliVisualAnimatedGradientVisual02(void)
2186 {
2187   ToolkitTestApplication application;
2188   tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2189
2190   static std::vector<UniformData> customUniforms =
2191     {
2192       UniformData("start_point", Property::Type::VECTOR2),
2193       UniformData("end_point", Property::Type::VECTOR2),
2194       UniformData("start_color", Property::Type::VECTOR4),
2195       UniformData("end_color", Property::Type::VECTOR4),
2196       UniformData("rotate_center", Property::Type::VECTOR2),
2197       UniformData("rotate_angle", Property::Type::FLOAT),
2198       UniformData("gradient_offset", Property::Type::FLOAT),
2199     };
2200
2201   TestGraphicsController& graphics = application.GetGraphicsController();
2202   graphics.AddCustomUniforms(customUniforms);
2203
2204   {
2205     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2206     int   _direction[2]  = {0, 1};
2207     int   _loop_count[3] = {-1, 0, 1};
2208     int   _motion[2]     = {0, 1};
2209     int   _easing[4]     = {0, 1, 2, 3};
2210
2211     int test_case_max = 4 * 2 * 3 * 2 * 4;
2212     int test_case     = 0;
2213     int test_case_d   = 7; // 7 is the number of animated properties.
2214
2215     float _duration     = 0.4f;
2216     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2217     float noise_maker   = 0.0f;
2218     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2219     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2220     {
2221       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2222
2223       VisualFactory factory = VisualFactory::Get();
2224       Property::Map propertyMap;
2225       Property::Map animationMap;
2226       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2227
2228       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2229       int unit_type     = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2230       int spread_type   = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2231
2232       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2233         int tc         = (test_case + tc_offset);
2234         int idx_easing = tc % 4;
2235         tc /= 4;
2236         int idx_motion = tc % 2;
2237         tc /= 2;
2238         int idx_loop_count = tc % 3;
2239         tc /= 3;
2240         int idx_direction = tc % 2;
2241         tc /= 2;
2242         int idx_delay = tc % 4;
2243         tc /= 4;
2244
2245         float duration     = _duration - _repeat_delay;
2246         float repeat_delay = _repeat_delay;
2247         float delay        = _delay[idx_delay] * _duration;
2248         int   direction    = _direction[idx_direction];
2249         int   loop_count   = _loop_count[idx_loop_count];
2250         int   motion       = _motion[idx_motion];
2251         int   easing       = _easing[idx_easing];
2252
2253         animationMap.Clear();
2254         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2255         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2256         if(direction == 0)
2257         {
2258           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2259         }
2260         else
2261         {
2262           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2263         }
2264         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2265         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2266         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2267         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2268         if(motion == 0)
2269         {
2270           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2271         }
2272         else
2273         {
2274           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2275         }
2276         if(easing == 0)
2277         {
2278           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2279         }
2280         else if(easing == 1)
2281         {
2282           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2283         }
2284         else if(easing == 2)
2285         {
2286           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2287         }
2288         else
2289         {
2290           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2291         }
2292
2293         return animationMap;
2294       };
2295
2296       // Give different values for debuging
2297       noise_maker += 1.0f;
2298       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2299       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2300       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2301       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2302       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2303       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2304       float   offset1        = 0.f + noise_maker * 0.1f;
2305
2306       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2307       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2308       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2309       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2310       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2311       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2312       float   offset2        = 2.f + noise_maker * 0.1f;
2313
2314       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2315       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2316       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2317
2318       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2319       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2320       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2321       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2322       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2323       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2324       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2325
2326       Visual::Base visual = factory.CreateVisual(propertyMap);
2327
2328       DummyControl        actor     = DummyControl::New(true);
2329       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2330       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2331       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2332       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2333       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2334       application.GetScene().Add(actor);
2335
2336       application.SendNotification();
2337       application.Render(0);
2338       application.SendNotification();
2339
2340       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2341
2342       application.SendNotification();
2343
2344       //Compare between CPU calculated value and Shader Visual calculated value
2345       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2346         int tc         = (test_case + tc_offset);
2347         int idx_easing = tc % 4;
2348         tc /= 4;
2349         int idx_motion = tc % 2;
2350         tc /= 2;
2351         int idx_loop_count = tc % 3;
2352         tc /= 3;
2353         int idx_direction = tc % 2;
2354         tc /= 2;
2355         int idx_delay = tc % 4;
2356         tc /= 4;
2357
2358         float duration     = _duration - _repeat_delay;
2359         float repeat_delay = _repeat_delay;
2360         float delay        = _delay[idx_delay] * _duration;
2361         int   direction    = _direction[idx_direction];
2362         int   loop_count   = _loop_count[idx_loop_count];
2363         int   motion       = _motion[idx_motion];
2364         int   easing       = _easing[idx_easing];
2365
2366         progress -= delay / _duration;
2367
2368         Property::Value s = start;
2369         Property::Value t = target;
2370         if(direction == 1)
2371         {
2372           s = target;
2373           t = start;
2374         }
2375         float x; ///< Animator progress value
2376         if(loop_count == 0)
2377         {
2378           x = 1.0f;
2379         }
2380         else if(loop_count > 0 && progress + 0.01f > loop_count)
2381         {
2382           x = (motion == 0) ? 1.0f : 0.0f;
2383         }
2384         else
2385         {
2386           if(progress < 0.0f)
2387           {
2388             progress = 0.0f;
2389           }
2390           progress = fmodf(progress, 1.0f);
2391           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2392
2393           x = progress;
2394           if(motion == 1)
2395           {
2396             x = progress * 2.0f;
2397             if(x > 1.0f)
2398             {
2399               x = 2.0f - x;
2400             }
2401           }
2402
2403           if(easing == 1) // EASE_IN
2404           {
2405             x = x * x;
2406           }
2407           else if(easing == 2) // EASE_OUT
2408           {
2409             x = 2.0f * x - x * x;
2410           }
2411           else if(easing == 3) // EASE_IN_OUT
2412           {
2413             x = x * x * (3.0f - 2.0f * x);
2414           }
2415         }
2416         if(value_type == 0) // result type is Float
2417         {
2418           float res;
2419           float cur;
2420           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2421           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2422           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2423         }
2424         else if(value_type == 1) // result type is Vector2
2425         {
2426           Vector2 res;
2427           Vector2 cur;
2428           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2429           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2430           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2431         }
2432         else if(value_type == 2) // result type is Vector3
2433         {
2434           Vector3 res;
2435           Vector3 cur;
2436           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2437           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2438           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2439         }
2440         else // result type is Vector4
2441         {
2442           Vector4 res;
2443           Vector4 cur;
2444           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2445           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2446           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2447         }
2448       };
2449
2450       float step = 0.0f;
2451       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2452       {
2453         for(int step_iter = 0; step_iter < 3; step_iter++)
2454         {
2455           application.SendNotification();
2456           application.Render(_duration * 250.f); // step i/4
2457           application.SendNotification();
2458           step += 0.25f;
2459
2460           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2461           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2462           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2463           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2464           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2465           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2466           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2467         }
2468         application.SendNotification();
2469         application.Render(_duration * 250.f); // step 4/4 will not test
2470         application.SendNotification();
2471         step += 0.25f;
2472       }
2473
2474       application.SendNotification();
2475       actor.Unparent();
2476       application.SendNotification();
2477       application.Render(10.f); // tempral time
2478       application.SendNotification();
2479     }
2480   }
2481
2482   END_TEST;
2483 }
2484
2485 int UtcDaliVisualAnimatedGradientVisual03(void)
2486 {
2487   ToolkitTestApplication application;
2488   tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2489
2490   static std::vector<UniformData> customUniforms =
2491     {
2492       UniformData("start_point", Property::Type::VECTOR2),
2493       UniformData("end_point", Property::Type::VECTOR2),
2494       UniformData("start_color", Property::Type::VECTOR4),
2495       UniformData("end_color", Property::Type::VECTOR4),
2496       UniformData("rotate_center", Property::Type::VECTOR2),
2497       UniformData("rotate_angle", Property::Type::FLOAT),
2498       UniformData("gradient_offset", Property::Type::FLOAT),
2499     };
2500
2501   TestGraphicsController& graphics = application.GetGraphicsController();
2502   graphics.AddCustomUniforms(customUniforms);
2503
2504   {
2505     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2506     int   _direction[2]  = {0, 1};
2507     int   _loop_count[3] = {-1, 0, 1};
2508     int   _motion[2]     = {0, 1};
2509     int   _easing[4]     = {0, 1, 2, 3};
2510
2511     int test_case_max = 4 * 2 * 3 * 2 * 4;
2512     int test_case     = 0;
2513     int test_case_d   = 7; // 7 is the number of animated properties.
2514
2515     float _duration     = 0.4f;
2516     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2517     float noise_maker   = 0.2f;
2518     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2519     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2520     {
2521       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2522
2523       VisualFactory factory = VisualFactory::Get();
2524       Property::Map propertyMap;
2525       Property::Map animationMap;
2526       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2527
2528       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2529         int tc         = (test_case + tc_offset);
2530         int idx_easing = tc % 4;
2531         tc /= 4;
2532         int idx_motion = tc % 2;
2533         tc /= 2;
2534         int idx_loop_count = tc % 3;
2535         tc /= 3;
2536         int idx_direction = tc % 2;
2537         tc /= 2;
2538         int idx_delay = tc % 4;
2539         tc /= 4;
2540
2541         float duration     = _duration - _repeat_delay;
2542         float repeat_delay = _repeat_delay;
2543         float delay        = _delay[idx_delay] * _duration;
2544         int   direction    = _direction[idx_direction];
2545         int   loop_count   = _loop_count[idx_loop_count];
2546         int   motion       = _motion[idx_motion];
2547         int   easing       = _easing[idx_easing];
2548
2549         animationMap.Clear();
2550         animationMap.Insert("startValue", start);
2551         animationMap.Insert("targetValue", target);
2552         if(direction == 0)
2553         {
2554           animationMap.Insert("directionType", "FORWARD");
2555         }
2556         else
2557         {
2558           animationMap.Insert("directionType", "BACKWARD");
2559         }
2560         animationMap.Insert("duration", duration);
2561         animationMap.Insert("delay", delay);
2562         animationMap.Insert("repeat", loop_count);
2563         animationMap.Insert("repeatDelay", repeat_delay);
2564         if(motion == 0)
2565         {
2566           animationMap.Insert("motionType", "LOOP");
2567         }
2568         else
2569         {
2570           animationMap.Insert("motionType", "MIRROR");
2571         }
2572         if(easing == 0)
2573         {
2574           animationMap.Insert("easingType", "LINEAR");
2575         }
2576         else if(easing == 1)
2577         {
2578           animationMap.Insert("easingType", "IN");
2579         }
2580         else if(easing == 2)
2581         {
2582           animationMap.Insert("easingType", "OUT");
2583         }
2584         else
2585         {
2586           animationMap.Insert("easingType", "IN_OUT");
2587         }
2588
2589         return animationMap;
2590       };
2591
2592       // Give different values for debuging
2593       noise_maker += 0.8f;
2594       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2595       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2596       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2597       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2598       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2599       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2600       float   offset1        = 0.f + noise_maker * 0.1f;
2601
2602       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2603       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2604       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2605       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2606       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2607       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2608       float   offset2        = 2.f + noise_maker * 0.1f;
2609
2610       propertyMap.Insert("gradientType", "LINEAR");
2611       propertyMap.Insert("unitType", "USER_SPACE");
2612       propertyMap.Insert("spreadType", "CLAMP");
2613
2614       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2615       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2616       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2617       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2618       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2619       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2620       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2621
2622       Visual::Base visual = factory.CreateVisual(propertyMap);
2623
2624       DummyControl        actor     = DummyControl::New(true);
2625       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2626       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2627       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2628       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2629       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2630       application.GetScene().Add(actor);
2631
2632       application.SendNotification();
2633       application.Render(0);
2634       application.SendNotification();
2635
2636       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2637
2638       application.SendNotification();
2639
2640       //Compare between CPU calculated value and Shader Visual calculated value
2641       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2642         int tc         = (test_case + tc_offset);
2643         int idx_easing = tc % 4;
2644         tc /= 4;
2645         int idx_motion = tc % 2;
2646         tc /= 2;
2647         int idx_loop_count = tc % 3;
2648         tc /= 3;
2649         int idx_direction = tc % 2;
2650         tc /= 2;
2651         int idx_delay = tc % 4;
2652         tc /= 4;
2653
2654         float duration     = _duration - _repeat_delay;
2655         float repeat_delay = _repeat_delay;
2656         float delay        = _delay[idx_delay] * _duration;
2657         int   direction    = _direction[idx_direction];
2658         int   loop_count   = _loop_count[idx_loop_count];
2659         int   motion       = _motion[idx_motion];
2660         int   easing       = _easing[idx_easing];
2661
2662         progress -= delay / _duration;
2663
2664         Property::Value s = start;
2665         Property::Value t = target;
2666         if(direction == 1)
2667         {
2668           s = target;
2669           t = start;
2670         }
2671         float x; ///< Animator progress value
2672         if(loop_count == 0)
2673         {
2674           x = 1.0f;
2675         }
2676         else if(loop_count > 0 && progress + 0.01f > loop_count)
2677         {
2678           x = (motion == 0) ? 1.0f : 0.0f;
2679         }
2680         else
2681         {
2682           if(progress < 0.0f)
2683           {
2684             progress = 0.0f;
2685           }
2686           progress = fmodf(progress, 1.0f);
2687           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2688
2689           x = progress;
2690           if(motion == 1)
2691           {
2692             x = progress * 2.0f;
2693             if(x > 1.0f)
2694             {
2695               x = 2.0f - x;
2696             }
2697           }
2698
2699           if(easing == 1) // EASE_IN
2700           {
2701             x = x * x;
2702           }
2703           else if(easing == 2) // EASE_OUT
2704           {
2705             x = 2.0f * x - x * x;
2706           }
2707           else if(easing == 3) // EASE_IN_OUT
2708           {
2709             x = x * x * (3.0f - 2.0f * x);
2710           }
2711         }
2712         if(value_type == 0) // result type is Float
2713         {
2714           float res;
2715           float cur;
2716           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2717           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2718           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2719         }
2720         else if(value_type == 1) // result type is Vector2
2721         {
2722           Vector2 res;
2723           Vector2 cur;
2724           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2725           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2726           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2727         }
2728         else if(value_type == 2) // result type is Vector3
2729         {
2730           Vector3 res;
2731           Vector3 cur;
2732           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2733           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2734           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2735         }
2736         else // result type is Vector4
2737         {
2738           Vector4 res;
2739           Vector4 cur;
2740           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2741           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2742           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2743         }
2744       };
2745
2746       float step = 0.0f;
2747       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2748       {
2749         for(int step_iter = 0; step_iter < 3; step_iter++)
2750         {
2751           application.SendNotification();
2752           application.Render(_duration * 250.f); // step i/4
2753           application.SendNotification();
2754           step += 0.25f;
2755
2756           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2757           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2758           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2759           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2760           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2761           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2762           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2763         }
2764         application.SendNotification();
2765         application.Render(_duration * 250.f); // step 4/4 will not test
2766         application.SendNotification();
2767         step += 0.25f;
2768       }
2769
2770       application.SendNotification();
2771       actor.Unparent();
2772       application.SendNotification();
2773       application.Render(10.f); // tempral time
2774       application.SendNotification();
2775     }
2776   }
2777
2778   END_TEST;
2779 }
2780
2781 int UtcDaliVisualWireframeVisual(void)
2782 {
2783   ToolkitTestApplication application;
2784
2785   VisualFactory factory = VisualFactory::Get();
2786   Property::Map propertyMap;
2787   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2788
2789   // Create the visual.
2790   Visual::Base visual = factory.CreateVisual(propertyMap);
2791
2792   DALI_TEST_CHECK(visual);
2793
2794   Property::Map resultMap;
2795   visual.CreatePropertyMap(resultMap);
2796
2797   // Check the property values from the returned map from visual
2798   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2799   DALI_TEST_CHECK(value);
2800   DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2801
2802   END_TEST;
2803 }
2804
2805 int UtcDaliVisualGetTransform(void)
2806 {
2807   ToolkitTestApplication application;
2808   tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2809
2810   VisualFactory factory = VisualFactory::Get();
2811   Property::Map propertyMap;
2812   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2813   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2814   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2815
2816   Dali::Property::Map visualMap;
2817   colorVisual.CreatePropertyMap(visualMap);
2818   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2819   Dali::Property::Map* map   = value->GetMap();
2820   DALI_TEST_CHECK(map);
2821
2822   //Test default values
2823   {
2824     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2825     DALI_TEST_CHECK(typeValue);
2826     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2827   }
2828   {
2829     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2830     DALI_TEST_CHECK(typeValue);
2831     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2832   }
2833   {
2834     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2835     DALI_TEST_CHECK(typeValue);
2836     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2837   }
2838   {
2839     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2840     DALI_TEST_CHECK(typeValue);
2841     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2842   }
2843   {
2844     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2845     DALI_TEST_CHECK(typeValue);
2846     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2847   }
2848   {
2849     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2850     DALI_TEST_CHECK(typeValue);
2851     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2852   }
2853   {
2854     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2855     DALI_TEST_CHECK(typeValue);
2856     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2857   }
2858
2859   END_TEST;
2860 }
2861
2862 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2863 {
2864   Property::Map transform;
2865   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2866   transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2867   transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2868   transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2869   transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2870   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2871
2872   visual.SetTransformAndSize(transform, Vector2(100, 100));
2873
2874   Dali::Property::Map visualMap;
2875   visual.CreatePropertyMap(visualMap);
2876   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2877   Dali::Property::Map* map   = value->GetMap();
2878   DALI_TEST_CHECK(map);
2879
2880   {
2881     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2882     DALI_TEST_CHECK(typeValue);
2883     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2884   }
2885   {
2886     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2887     DALI_TEST_CHECK(typeValue);
2888     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2889   }
2890   {
2891     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2892     DALI_TEST_CHECK(typeValue);
2893     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2894   }
2895   {
2896     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2897     DALI_TEST_CHECK(typeValue);
2898     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2899   }
2900   {
2901     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2902     DALI_TEST_CHECK(typeValue);
2903     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2904   }
2905   {
2906     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2907     DALI_TEST_CHECK(typeValue);
2908     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2909   }
2910   {
2911     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2912     DALI_TEST_CHECK(typeValue);
2913     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2914   }
2915
2916   //Put the visual on the stage
2917   DummyControl        actor     = DummyControl::New(true);
2918   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2919   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2920   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2921   application.GetScene().Add(actor);
2922
2923   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2924   dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2925
2926   application.SendNotification();
2927   application.Render(0);
2928   Renderer renderer(actor.GetRendererAt(0));
2929
2930   Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2931   DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2932
2933   Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2934   DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2935
2936   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2937   DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2938
2939   Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2940   DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2941
2942   Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2943   DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2944
2945   Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2946   DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2947
2948   //Set a new transform
2949   transform.Clear();
2950   transform = DefaultTransform();
2951   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2952   transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2953   transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2954   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2955   visual.SetTransformAndSize(transform, Vector2(100, 100));
2956   application.SendNotification();
2957   application.Render(0);
2958
2959   //Check that the values have changed in the renderer
2960   offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2961   DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2962
2963   size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2964   DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2965
2966   offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2967   DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2968
2969   //Parent origin and anchor point should have the default values
2970   parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2971   DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2972
2973   anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2974   DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2975
2976   extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2977   DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2978 }
2979
2980 int UtcDaliVisualSetTransform01(void)
2981 {
2982   ToolkitTestApplication application;
2983   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2984
2985   VisualFactory factory = VisualFactory::Get();
2986   Property::Map propertyMap;
2987   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2988   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2989   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2990   Visual::Base visual = factory.CreateVisual(propertyMap);
2991   TestTransform(application, visual);
2992   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2993
2994   END_TEST;
2995 }
2996
2997 int UtcDaliVisualSetTransform0(void)
2998 {
2999   ToolkitTestApplication application;
3000   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
3001
3002   VisualFactory factory = VisualFactory::Get();
3003   Property::Map propertyMap;
3004   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3005   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3006   Visual::Base visual = factory.CreateVisual(propertyMap);
3007   TestTransform(application, visual);
3008   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3009
3010   END_TEST;
3011 }
3012
3013 int UtcDaliVisualSetTransform1(void)
3014 {
3015   ToolkitTestApplication application;
3016   tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3017
3018   VisualFactory factory = VisualFactory::Get();
3019   Property::Map propertyMap;
3020   propertyMap[Toolkit::Visual::Property::TYPE]      = Visual::PRIMITIVE;
3021   propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3022   propertyMap[PrimitiveVisual::Property::SHAPE]     = PrimitiveVisual::Shape::SPHERE;
3023   propertyMap[PrimitiveVisual::Property::SLICES]    = 10;
3024   propertyMap[PrimitiveVisual::Property::STACKS]    = 10;
3025   Visual::Base visual                               = factory.CreateVisual(propertyMap);
3026   TestTransform(application, visual);
3027   TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3028
3029   END_TEST;
3030 }
3031
3032 int UtcDaliVisualSetTransform2(void)
3033 {
3034   ToolkitTestApplication application;
3035   tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3036
3037   VisualFactory factory = VisualFactory::Get();
3038   Property::Map propertyMap;
3039   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3040   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3041
3042   Property::Array stopOffsets;
3043   stopOffsets.PushBack(0.0f);
3044   stopOffsets.PushBack(0.3f);
3045   stopOffsets.PushBack(0.6f);
3046   stopOffsets.PushBack(0.8f);
3047   stopOffsets.PushBack(1.0f);
3048   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3049
3050   Property::Array stopColors;
3051   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3052   stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3053   stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3054   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3055   stopColors.PushBack(Color::YELLOW);
3056   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3057   propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3058   propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3059   Visual::Base visual = factory.CreateVisual(propertyMap);
3060   TestTransform(application, visual);
3061   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3062
3063   END_TEST;
3064 }
3065
3066 int UtcDaliVisualSetTransform3(void)
3067 {
3068   ToolkitTestApplication application;
3069   tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3070
3071   VisualFactory factory = VisualFactory::Get();
3072   Property::Map propertyMap;
3073   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3074   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3075   propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3076   propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3077   Visual::Base visual = factory.CreateVisual(propertyMap);
3078   TestTransform(application, visual);
3079   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3080
3081   END_TEST;
3082 }
3083
3084 int UtcDaliVisualSetTransform4(void)
3085 {
3086   ToolkitTestApplication application;
3087   tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3088
3089   VisualFactory factory = VisualFactory::Get();
3090   Property::Map propertyMap;
3091   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3092   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3093
3094   propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3095   propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3096   propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3097   propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3098   propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3099   Visual::Base visual = factory.CreateVisual(propertyMap);
3100   TestTransform(application, visual);
3101   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3102
3103   END_TEST;
3104 }
3105
3106 int UtcDaliVisualSetTransform5(void)
3107 {
3108   ToolkitTestApplication application;
3109   tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3110
3111   VisualFactory factory = VisualFactory::Get();
3112   Property::Map propertyMap;
3113   propertyMap[Toolkit::Visual::Property::TYPE]                     = Toolkit::Visual::IMAGE;
3114   propertyMap[Visual::Property::MIX_COLOR]                         = Color::YELLOW;
3115   propertyMap[Toolkit::ImageVisual::Property::URL]                 = TEST_IMAGE_FILE_NAME;
3116   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH]       = 100.0f;
3117   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT]      = 100.0f;
3118   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE]        = FittingMode::SCALE_TO_FILL;
3119   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE]       = SamplingMode::BOX_THEN_LINEAR;
3120   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3121   Visual::Base visual                                              = factory.CreateVisual(propertyMap);
3122   TestTransform(application, visual);
3123   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3124
3125   END_TEST;
3126 }
3127
3128 int UtcDaliVisualSetTransform6(void)
3129 {
3130   ToolkitTestApplication application;
3131   tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3132
3133   VisualFactory factory = VisualFactory::Get();
3134   Property::Map propertyMap;
3135   propertyMap[Toolkit::Visual::Property::TYPE]                     = Toolkit::Visual::IMAGE;
3136   propertyMap[Toolkit::ImageVisual::Property::URL]                 = TEST_NPATCH_FILE_NAME;
3137   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3138   Visual::Base visual                                              = factory.CreateVisual(propertyMap);
3139   TestTransform(application, visual);
3140   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3141
3142   END_TEST;
3143 }
3144
3145 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3146 {
3147   ToolkitTestApplication application;
3148   tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3149
3150   VisualFactory factory = VisualFactory::Get();
3151   Property::Map propertyMap;
3152   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3153   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3154   Visual::Base visual = factory.CreateVisual(propertyMap);
3155
3156   Property::Map transform;
3157   transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3158   transform["sizePolicy"]   = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3159   visual.SetTransformAndSize(transform, Vector2(100, 100));
3160
3161   Dali::Property::Map visualMap;
3162   visual.CreatePropertyMap(visualMap);
3163   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3164   Dali::Property::Map* map   = value->GetMap();
3165   DALI_TEST_CHECK(map);
3166
3167   {
3168     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3169     DALI_TEST_CHECK(typeValue);
3170     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3171   }
3172   {
3173     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3174     DALI_TEST_CHECK(typeValue);
3175     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3176   }
3177
3178   END_TEST;
3179 }
3180
3181 int UtcDaliNPatchVisualCustomShader(void)
3182 {
3183   ToolkitTestApplication application;
3184   tet_infoline("NPatchVisual with custom shader");
3185
3186   VisualFactory     factory = VisualFactory::Get();
3187   Property::Map     properties;
3188   Property::Map     shader;
3189   const std::string vertexShader                                   = "Foobar";
3190   const std::string fragmentShader                                 = "Foobar";
3191   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3192   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
3193
3194   Property::Map transformMap;
3195   transformMap["size"]                    = Vector2(0.5f, 0.5f);
3196   transformMap["offset"]                  = Vector2(20.0f, 0.0f);
3197   transformMap["offsetPolicy"]            = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3198   transformMap["anchorPoint"]             = Align::CENTER;
3199   transformMap["origin"]                  = Align::CENTER;
3200   transformMap["extraSize"]               = Vector2(0.0f, 50.0f);
3201   properties[Visual::Property::TRANSFORM] = transformMap;
3202
3203   properties[Visual::Property::TYPE]                     = Visual::IMAGE;
3204   properties[Visual::Property::MIX_COLOR]                = Color::BLUE;
3205   properties[Visual::Property::SHADER]                   = shader;
3206   properties[ImageVisual::Property::URL]                 = TEST_NPATCH_FILE_NAME;
3207   properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3208
3209   Visual::Base visual = factory.CreateVisual(properties);
3210   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3211
3212   // trigger creation through setting on stage
3213   DummyControl        dummy     = DummyControl::New(true);
3214   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3215   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3216   dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3217   dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3218   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3219   application.GetScene().Add(dummy);
3220   application.SendNotification();
3221
3222   Renderer        renderer = dummy.GetRendererAt(0);
3223   Shader          shader2  = renderer.GetShader();
3224   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
3225   Property::Map*  map      = value.GetMap();
3226   DALI_TEST_CHECK(map);
3227
3228   Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3229   DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3230
3231   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3232   DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3233
3234   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3235   DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3236
3237   Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3238   DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3239
3240   END_TEST;
3241 }
3242
3243 int UtcDaliGradientVisualBlendMode(void)
3244 {
3245   ToolkitTestApplication application;
3246   VisualFactory          factory = VisualFactory::Get();
3247
3248   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3249     Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Color::GREEN)));
3250
3251   Visual::Base alphaGradientVisual = factory.CreateVisual(
3252     Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3253
3254   DummyControl control = DummyControl::New(true);
3255   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3256   application.GetScene().Add(control);
3257
3258   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3259   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3260   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3261
3262   application.SendNotification();
3263   application.Render();
3264
3265   // Control should have two renderers, the first one is opaque so our blending mode should be off, the second one has some alpha so should be set to automatic
3266   DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3267   DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3268   DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3269
3270   END_TEST;
3271 }
3272
3273 int UtcDaliVisualRendererRemovalAndReAddition(void)
3274 {
3275   ToolkitTestApplication application;
3276   tet_infoline("UtcDaliVisualRendererRemoval");
3277
3278   VisualFactory factory = VisualFactory::Get();
3279   Property::Map propertyMap;
3280   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3281   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3282   Visual::Base visual = factory.CreateVisual(propertyMap);
3283
3284   visual.SetDepthIndex(1);
3285
3286   DummyControl        dummyControl = DummyControl::New(true);
3287   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3288   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3289   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3290
3291   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3292   tet_infoline("Add control with visual to stage and check renderer count is 1");
3293
3294   application.GetScene().Add(dummyControl);
3295
3296   application.SendNotification();
3297   application.Render();
3298
3299   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3300
3301   tet_infoline("Remove control with visual from stage and check renderer count is 0");
3302   application.GetScene().Remove(dummyControl);
3303   application.SendNotification();
3304   application.Render();
3305
3306   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3307
3308   tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3309
3310   application.GetScene().Add(dummyControl);
3311
3312   application.SendNotification();
3313   application.Render();
3314
3315   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3316
3317   END_TEST;
3318 }
3319
3320 int UtcDaliVisualTextVisualRender(void)
3321 {
3322   ToolkitTestApplication application;
3323   tet_infoline("UtcDaliVisualTextVisualRender");
3324
3325   VisualFactory factory = VisualFactory::Get();
3326   Property::Map propertyMap;
3327   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3328   propertyMap.Insert("mixColor", Color::WHITE);
3329   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3330   propertyMap.Insert("enableMarkup", false);
3331   propertyMap.Insert("text", "Hello world");
3332   propertyMap.Insert("fontFamily", "TizenSans");
3333
3334   Property::Map fontStyleMapSet;
3335   fontStyleMapSet.Insert("weight", "bold");
3336   propertyMap.Insert("fontStyle", fontStyleMapSet);
3337
3338   propertyMap.Insert("pointSize", 12.f);
3339   propertyMap.Insert("multiLine", true);
3340   propertyMap.Insert("horizontalAlignment", "CENTER");
3341   propertyMap.Insert("verticalAlignment", "CENTER");
3342   propertyMap.Insert("textColor", Color::RED);
3343   Visual::Base textVisual = factory.CreateVisual(propertyMap);
3344   textVisual.SetDepthIndex(1);
3345
3346   DummyControl        dummyControl = DummyControl::New(true);
3347   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3348   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3349   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3350
3351   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3352   dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3353
3354   application.GetScene().Add(dummyControl);
3355   application.SendNotification();
3356   application.Render();
3357
3358   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3359   propertyMap.Clear();
3360   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3361   propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3362   propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3363   propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3364
3365   Property::Map transformMap;
3366   transformMap.Insert("size", Vector2(0.5f, 0.5f));
3367   propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3368
3369   textVisual = factory.CreateVisual(propertyMap);
3370   textVisual.SetDepthIndex(1);
3371
3372   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3373   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3374
3375   application.SendNotification(); // force process events to ensure text visual
3376   // adds renderer to the dummy control in OnRelayout
3377   application.Render();
3378
3379   Renderer        renderer = dummyControl.GetRendererAt(0u);
3380   Property::Index index    = renderer.GetPropertyIndex("transformSize");
3381
3382   tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3383   DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3384
3385   END_TEST;
3386 }
3387
3388 int UtcDaliVisualTextVisualDisableEnable(void)
3389 {
3390   ToolkitTestApplication application;
3391   tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3392
3393   VisualFactory factory = VisualFactory::Get();
3394   Property::Map propertyMap;
3395   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3396   propertyMap.Insert("mixColor", Color::WHITE);
3397   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3398   propertyMap.Insert("enableMarkup", false);
3399   propertyMap.Insert("text", "Hello world");
3400   propertyMap.Insert("fontFamily", "TizenSans");
3401
3402   Property::Map fontStyleMapSet;
3403   fontStyleMapSet.Insert("weight", "bold");
3404   propertyMap.Insert("fontStyle", fontStyleMapSet);
3405
3406   propertyMap.Insert("pointSize", 12.f);
3407   propertyMap.Insert("multiLine", true);
3408   propertyMap.Insert("horizontalAlignment", "CENTER");
3409   propertyMap.Insert("verticalAlignment", "CENTER");
3410   propertyMap.Insert("textColor", Color::RED);
3411   Visual::Base textVisual = factory.CreateVisual(propertyMap);
3412   textVisual.SetDepthIndex(1);
3413
3414   DummyControl        dummyControl = DummyControl::New(true);
3415   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3416   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3417   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3418
3419   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3420   dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3421
3422   application.GetScene().Add(dummyControl);
3423   application.SendNotification();
3424   application.Render();
3425
3426   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3427
3428   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3429
3430   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3431
3432   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3433
3434   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3435
3436   END_TEST;
3437 }
3438
3439 int UtcDaliVisualPremultipliedAlpha(void)
3440 {
3441   ToolkitTestApplication application;
3442   tet_infoline("UtcDaliVisualPremultipliedAlpha");
3443
3444   VisualFactory factory = VisualFactory::Get();
3445
3446   // image visual, test default value ( true )
3447   {
3448     Visual::Base imageVisual = factory.CreateVisual(
3449       Property::Map()
3450         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3451         .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3452
3453     Dali::Property::Map visualMap;
3454     imageVisual.CreatePropertyMap(visualMap);
3455     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3456
3457     // test values
3458     DALI_TEST_CHECK(value);
3459     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3460   }
3461
3462   // image visual, override premultiplied
3463   {
3464     Visual::Base imageVisual = factory.CreateVisual(
3465       Property::Map()
3466         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3467         .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3468         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3469
3470     Dali::Property::Map visualMap;
3471     imageVisual.CreatePropertyMap(visualMap);
3472     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3473
3474     // test values
3475     DALI_TEST_CHECK(value);
3476     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3477   }
3478
3479   // svg visual ( premultiplied alpha by default is true, and cannot change value )
3480   {
3481     Visual::Base imageVisual = factory.CreateVisual(
3482       Property::Map()
3483         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3484         .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3485
3486     Dali::Property::Map visualMap;
3487     imageVisual.CreatePropertyMap(visualMap);
3488     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3489
3490     // test values
3491     DALI_TEST_CHECK(value);
3492     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3493   }
3494   {
3495     Visual::Base imageVisual = factory.CreateVisual(
3496       Property::Map()
3497         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3498         .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3499         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3500
3501     Dali::Property::Map visualMap;
3502     imageVisual.CreatePropertyMap(visualMap);
3503     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3504
3505     // test values
3506     DALI_TEST_CHECK(value);
3507     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3508   }
3509
3510   // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3511   {
3512     Visual::Base imageVisual = factory.CreateVisual(
3513       Property::Map()
3514         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3515         .Add(ImageVisual::Property::URL, "something.json"));
3516
3517     Dali::Property::Map visualMap;
3518     imageVisual.CreatePropertyMap(visualMap);
3519     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3520
3521     // test values
3522     DALI_TEST_CHECK(value);
3523     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3524   }
3525   {
3526     Visual::Base imageVisual = factory.CreateVisual(
3527       Property::Map()
3528         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3529         .Add(ImageVisual::Property::URL, "something.json")
3530         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3531
3532     Dali::Property::Map visualMap;
3533     imageVisual.CreatePropertyMap(visualMap);
3534     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3535
3536     // test values
3537     DALI_TEST_CHECK(value);
3538     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3539   }
3540
3541   // text visual ( premultiplied alpha by default is true, and cannot change value )
3542   {
3543     Visual::Base textVisual = factory.CreateVisual(
3544       Property::Map()
3545         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3546         .Add(TextVisual::Property::TEXT, "Text"));
3547
3548     Dali::Property::Map visualMap;
3549     textVisual.CreatePropertyMap(visualMap);
3550     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3551
3552     // test values
3553     DALI_TEST_CHECK(value);
3554     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3555   }
3556   {
3557     Visual::Base textVisual = factory.CreateVisual(
3558       Property::Map()
3559         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3560         .Add(TextVisual::Property::TEXT, "Text")
3561         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3562
3563     Dali::Property::Map visualMap;
3564     textVisual.CreatePropertyMap(visualMap);
3565     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3566
3567     // test values
3568     DALI_TEST_CHECK(value);
3569     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3570   }
3571
3572   // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3573   {
3574     Visual::Base gradientVisual = factory.CreateVisual(
3575       Property::Map()
3576         .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3577         .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3578         .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3579         .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3580
3581     Dali::Property::Map visualMap;
3582     gradientVisual.CreatePropertyMap(visualMap);
3583     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3584
3585     // test values
3586     DALI_TEST_CHECK(value);
3587     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3588   }
3589   {
3590     Visual::Base gradientVisual = factory.CreateVisual(
3591       Property::Map()
3592         .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3593         .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3594         .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3595         .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3596         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3597
3598     Dali::Property::Map visualMap;
3599     gradientVisual.CreatePropertyMap(visualMap);
3600     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3601
3602     // test values
3603     DALI_TEST_CHECK(value);
3604     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3605   }
3606
3607   // color visual ( premultiplied alpha by default is false, and cannot change value )
3608   {
3609     Visual::Base colorVisual = factory.CreateVisual(
3610       Property::Map()
3611         .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3612         .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3613
3614     Dali::Property::Map visualMap;
3615     colorVisual.CreatePropertyMap(visualMap);
3616     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3617
3618     // test values
3619     DALI_TEST_CHECK(value);
3620     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3621   }
3622   {
3623     Visual::Base colorVisual = factory.CreateVisual(
3624       Property::Map()
3625         .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3626         .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3627         .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3628
3629     Dali::Property::Map visualMap;
3630     colorVisual.CreatePropertyMap(visualMap);
3631     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3632
3633     // test values
3634     DALI_TEST_CHECK(value);
3635     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3636   }
3637
3638   END_TEST;
3639 }
3640
3641 int UtcDaliRegisterVisualOrder(void)
3642 {
3643   ToolkitTestApplication application;
3644   tet_infoline("Register Visual Order");
3645
3646   DummyControl        dummyControl = DummyControl::New(true);
3647   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3648
3649   VisualFactory factory = VisualFactory::Get();
3650   Property::Map propertyMap;
3651   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3652   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3653
3654   tet_infoline("Register visual, should have depth index of 0.0f");
3655   Visual::Base testVisual = factory.CreateVisual(propertyMap);
3656   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3657   DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3658
3659   tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3660
3661   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3662   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3663   DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3664
3665   Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3666   dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3667   DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3668
3669   Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3670   dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3671   DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3672
3673   tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3674   Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3675   labelVisual.SetDepthIndex(-2000);
3676   dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3677   DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3678
3679   tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3680   const int    testVisual2DepthIndex  = testVisual2.GetDepthIndex();
3681   Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3682   DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3683   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3684   DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3685
3686   tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3687   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3688   anotherTestVisual2Replacement.SetDepthIndex(2000);
3689   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3690   DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3691
3692   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3693   application.GetScene().Add(dummyControl);
3694
3695   END_TEST;
3696 }
3697
3698 int UtcDaliRegisterVisualOrder02(void)
3699 {
3700   ToolkitTestApplication application;
3701   tet_infoline("Register Visual Order with Background Set");
3702
3703   DummyControl        dummyControl = DummyControl::New(true);
3704   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3705
3706   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3707
3708   VisualFactory factory = VisualFactory::Get();
3709   Property::Map propertyMap;
3710   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3711   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3712
3713   tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3714
3715   dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3716
3717   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3718   tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3719   Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3720   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3721   DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3722
3723   tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3724   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3725   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3726   DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3727
3728   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3729   application.GetScene().Add(dummyControl);
3730
3731   END_TEST;
3732 }
3733
3734 int UtcDaliRegisterVisualWithDepthIndex(void)
3735 {
3736   ToolkitTestApplication application;
3737   tet_infoline("Register a Visual With Depth Index");
3738
3739   DummyControl        dummyControl = DummyControl::New(true);
3740   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3741
3742   VisualFactory factory = VisualFactory::Get();
3743   Property::Map propertyMap;
3744   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3745   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3746
3747   tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3748   Visual::Base testVisual = factory.CreateVisual(propertyMap);
3749   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3750   DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3751   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3752
3753   tet_infoline("Register another visual with a depth index and it disabled");
3754   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3755   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3756   DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3757   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3758
3759   tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3760   Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3761   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3762   DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3763   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3764
3765   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3766   application.GetScene().Add(dummyControl);
3767
3768   END_TEST;
3769 }
3770
3771 int UtcDaliSvgVisualCustomShader(void)
3772 {
3773   ToolkitTestApplication application;
3774   tet_infoline("SvgVisual with custom shader");
3775
3776   VisualFactory     factory = VisualFactory::Get();
3777   Property::Map     properties;
3778   Property::Map     shader;
3779   const std::string vertexShader                                   = "Foobar";
3780   const std::string fragmentShader                                 = "Foobar";
3781   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3782   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
3783
3784   properties[Visual::Property::TYPE]     = Visual::IMAGE;
3785   properties[Visual::Property::SHADER]   = shader;
3786   properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3787
3788   Visual::Base visual = factory.CreateVisual(properties);
3789
3790   // trigger creation through setting on stage
3791   DummyControl        dummy     = DummyControl::New(true);
3792   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3793   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3794
3795   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3796   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3797   application.GetScene().Add(dummy);
3798
3799   application.SendNotification();
3800   application.Render();
3801
3802   // Wait for loading & rasterization
3803   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3804
3805   Renderer        renderer = dummy.GetRendererAt(0);
3806   Shader          shader2  = renderer.GetShader();
3807   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
3808   Property::Map*  map      = value.GetMap();
3809   DALI_TEST_CHECK(map);
3810
3811   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3812   DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3813
3814   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3815   DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3816
3817   END_TEST;
3818 }
3819
3820 int UtcDaliVisualRoundedCorner(void)
3821 {
3822   tet_infoline("UtcDaliVisualRoundedCorner");
3823
3824   static std::vector<UniformData> customUniforms =
3825     {
3826       UniformData("cornerRadius", Property::Type::VECTOR4),
3827       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3828     };
3829
3830   // image visual
3831   {
3832     ToolkitTestApplication  application;
3833     TestGraphicsController& graphics = application.GetGraphicsController();
3834     graphics.AddCustomUniforms(customUniforms);
3835
3836     VisualFactory factory = VisualFactory::Get();
3837     Property::Map properties;
3838     float         cornerRadius = 30.0f;
3839
3840     properties[Visual::Property::TYPE]               = Visual::IMAGE;
3841     properties[ImageVisual::Property::URL]           = TEST_IMAGE_FILE_NAME;
3842     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3843
3844     Visual::Base visual = factory.CreateVisual(properties);
3845
3846     // trigger creation through setting on stage
3847     DummyControl        dummy     = DummyControl::New(true);
3848     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3849     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3850
3851     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3852     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3853     application.GetScene().Add(dummy);
3854
3855     application.SendNotification();
3856     application.Render();
3857
3858     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3859
3860     application.SendNotification();
3861     application.Render();
3862
3863     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3864     // Default corner radius policy is absolute.
3865     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3866   }
3867
3868   // color visual 1
3869   {
3870     ToolkitTestApplication  application;
3871     TestGraphicsController& graphics = application.GetGraphicsController();
3872     graphics.AddCustomUniforms(customUniforms);
3873
3874     VisualFactory factory = VisualFactory::Get();
3875     Property::Map properties;
3876     float         cornerRadius = 30.0f;
3877
3878     properties[Visual::Property::TYPE]           = Visual::COLOR;
3879     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3880     properties["cornerRadius"]                   = cornerRadius;
3881     properties["cornerRadiusPolicy"]             = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3882
3883     Visual::Base visual = factory.CreateVisual(properties);
3884
3885     // trigger creation through setting on stage
3886     DummyControl        dummy     = DummyControl::New(true);
3887     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3888     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3889
3890     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3891     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3892     application.GetScene().Add(dummy);
3893
3894     application.SendNotification();
3895     application.Render();
3896
3897     application.SendNotification();
3898     application.Render();
3899
3900     // Currently test with multiple program doesn't work well. will fix another day
3901     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3902     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3903   }
3904
3905   // color visual 2
3906   {
3907     ToolkitTestApplication  application;
3908     TestGraphicsController& graphics = application.GetGraphicsController();
3909     graphics.AddCustomUniforms(customUniforms);
3910
3911     VisualFactory factory = VisualFactory::Get();
3912     Property::Map properties;
3913     Vector4       cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3914
3915     properties[Visual::Property::TYPE]                      = Visual::COLOR;
3916     properties[ColorVisual::Property::MIX_COLOR]            = Color::BLUE;
3917     properties[DevelVisual::Property::CORNER_RADIUS]        = cornerRadius;
3918     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3919
3920     Visual::Base visual = factory.CreateVisual(properties);
3921
3922     // trigger creation through setting on stage
3923     DummyControl        dummy     = DummyControl::New(true);
3924     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3925     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3926
3927     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3928     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3929     application.GetScene().Add(dummy);
3930
3931     application.SendNotification();
3932     application.Render();
3933
3934     application.SendNotification();
3935     application.Render();
3936
3937     // Currently test with multiple program doesn't work well. will fix another day
3938     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3939     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3940   }
3941
3942   // color visual 3 - invalid value
3943   {
3944     ToolkitTestApplication  application;
3945     TestGraphicsController& graphics = application.GetGraphicsController();
3946     graphics.AddCustomUniforms(customUniforms);
3947
3948     VisualFactory factory = VisualFactory::Get();
3949     Property::Map properties;
3950     Vector4       cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3951
3952     properties[Visual::Property::TYPE]                      = Visual::COLOR;
3953     properties[ColorVisual::Property::MIX_COLOR]            = Color::BLUE;
3954     properties[DevelVisual::Property::CORNER_RADIUS]        = cornerRadius;
3955     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3956
3957     Visual::Base visual = factory.CreateVisual(properties);
3958
3959     // trigger creation through setting on stage
3960     DummyControl        dummy     = DummyControl::New(true);
3961     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3962     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3963
3964     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3965     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3966     application.GetScene().Add(dummy);
3967
3968     application.SendNotification();
3969     application.Render();
3970
3971     application.SendNotification();
3972     application.Render();
3973
3974     // Currently test with multiple program doesn't work well. will fix another day
3975     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3976     // Default corner radius policy is absolute.
3977     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3978   }
3979
3980   // gradient visual
3981   {
3982     ToolkitTestApplication  application;
3983     TestGraphicsController& graphics = application.GetGraphicsController();
3984     graphics.AddCustomUniforms(customUniforms);
3985
3986     VisualFactory factory = VisualFactory::Get();
3987     Property::Map properties;
3988     float         cornerRadius = 30.0f;
3989
3990     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
3991     properties[ColorVisual::Property::MIX_COLOR]         = Color::BLUE;
3992     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
3993     properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3994     properties[GradientVisual::Property::END_POSITION]   = Vector2(-0.5f, -0.5f);
3995     properties[GradientVisual::Property::UNITS]          = GradientVisual::Units::USER_SPACE;
3996
3997     Property::Array stopOffsets;
3998     stopOffsets.PushBack(0.0f);
3999     stopOffsets.PushBack(0.6f);
4000     stopOffsets.PushBack(1.0f);
4001     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4002
4003     Property::Array stopColors;
4004     stopColors.PushBack(Color::RED);
4005     stopColors.PushBack(Color::YELLOW);
4006     stopColors.PushBack(Color::GREEN);
4007     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4008
4009     Visual::Base visual = factory.CreateVisual(properties);
4010
4011     // trigger creation through setting on stage
4012     DummyControl        dummy     = DummyControl::New(true);
4013     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4014     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4015
4016     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4017     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4018     application.GetScene().Add(dummy);
4019
4020     application.SendNotification();
4021     application.Render();
4022
4023     application.SendNotification();
4024     application.Render();
4025
4026     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4027     // Default corner radius policy is absolute.
4028     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4029   }
4030
4031   // animated image visual
4032   {
4033     ToolkitTestApplication  application;
4034     TestGraphicsController& graphics = application.GetGraphicsController();
4035     graphics.AddCustomUniforms(customUniforms);
4036
4037     VisualFactory factory = VisualFactory::Get();
4038     Property::Map properties;
4039     Vector4       cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
4040
4041     properties[Visual::Property::TYPE]               = Visual::ANIMATED_IMAGE;
4042     properties[ImageVisual::Property::URL]           = TEST_GIF_FILE_NAME;
4043     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4044     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4045     properties["cornerRadiusPolicy"]                 = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4046
4047     Visual::Base visual = factory.CreateVisual(properties);
4048
4049     // trigger creation through setting on stage
4050     DummyControl        dummy     = DummyControl::New(true);
4051     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4052     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4053
4054     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4055     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4056     application.GetScene().Add(dummy);
4057
4058     application.SendNotification();
4059     application.Render();
4060
4061     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4062
4063     application.SendNotification();
4064     application.Render();
4065
4066     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4067     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4068   }
4069
4070   // vector image visual
4071   {
4072     ToolkitTestApplication  application;
4073     TestGraphicsController& graphics = application.GetGraphicsController();
4074     graphics.AddCustomUniforms(customUniforms);
4075
4076     VisualFactory factory = VisualFactory::Get();
4077     Property::Map properties;
4078     Vector4       cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4079
4080     properties[Visual::Property::TYPE]               = Visual::SVG;
4081     properties[ImageVisual::Property::URL]           = TEST_SVG_FILE_NAME;
4082     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4083
4084     Visual::Base visual = factory.CreateVisual(properties);
4085
4086     // trigger creation through setting on stage
4087     DummyControl        dummy     = DummyControl::New(true);
4088     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4089     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4090
4091     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4092     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4093     application.GetScene().Add(dummy);
4094
4095     application.SendNotification();
4096     application.Render();
4097
4098     // Wait for loading & rasterization
4099     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4100
4101     application.SendNotification();
4102     application.Render();
4103
4104     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4105     // Default corner radius policy is absolute.
4106     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4107   }
4108
4109   // animated vector image visual
4110   {
4111     ToolkitTestApplication  application;
4112     TestGraphicsController& graphics = application.GetGraphicsController();
4113     graphics.AddCustomUniforms(customUniforms);
4114
4115     VisualFactory factory = VisualFactory::Get();
4116     Property::Map properties;
4117     float         cornerRadius = 1.3f;
4118
4119     properties[Visual::Property::TYPE]                      = DevelVisual::ANIMATED_VECTOR_IMAGE;
4120     properties[ImageVisual::Property::URL]                  = TEST_VECTOR_IMAGE_FILE_NAME;
4121     properties["cornerRadius"]                              = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4122     properties["cornerRadius"]                              = cornerRadius;
4123     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4124
4125     Visual::Base visual = factory.CreateVisual(properties);
4126
4127     // trigger creation through setting on stage
4128     DummyControl        dummy     = DummyControl::New(true);
4129     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4130     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4131
4132     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4133     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4134     application.GetScene().Add(dummy);
4135
4136     application.SendNotification();
4137     application.Render();
4138
4139     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4140
4141     application.SendNotification();
4142     application.Render();
4143
4144     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4145     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4146   }
4147
4148   END_TEST;
4149 }
4150
4151 int UtcDaliVisualBorderline(void)
4152 {
4153   tet_infoline("UtcDaliVisualBorderline");
4154
4155   static std::vector<UniformData> customUniforms =
4156     {
4157       UniformData("cornerRadius", Property::Type::VECTOR4),
4158       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4159       UniformData("borderlineWidth", Property::Type::FLOAT),
4160       UniformData("borderlineColor", Property::Type::VECTOR4),
4161       UniformData("borderlineOffset", Property::Type::FLOAT),
4162     };
4163
4164   // image visual
4165   {
4166     ToolkitTestApplication  application;
4167     TestGraphicsController& graphics = application.GetGraphicsController();
4168     graphics.AddCustomUniforms(customUniforms);
4169
4170     VisualFactory factory = VisualFactory::Get();
4171     Property::Map properties;
4172     float         cornerRadius    = 5.0f;
4173     float         borderlineWidth = 30.0f;
4174     Vector4       borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4175     float         borderlineOffset = 1.0f;
4176
4177     properties[Visual::Property::TYPE]                   = Visual::IMAGE;
4178     properties[ImageVisual::Property::URL]               = TEST_IMAGE_FILE_NAME;
4179     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4180     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4181     properties[DevelVisual::Property::BORDERLINE_COLOR]  = borderlineColor;
4182     properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4183
4184     Visual::Base visual = factory.CreateVisual(properties);
4185
4186     // trigger creation through setting on stage
4187     DummyControl        dummy     = DummyControl::New(true);
4188     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4189     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4190
4191     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4192     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4193     application.GetScene().Add(dummy);
4194
4195     application.SendNotification();
4196     application.Render();
4197
4198     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4199
4200     application.SendNotification();
4201     application.Render();
4202
4203     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4204     // Default corner radius policy is absolute.
4205     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4206     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4207     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4208     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4209   }
4210
4211   // color visual 1
4212   {
4213     ToolkitTestApplication  application;
4214     TestGraphicsController& graphics = application.GetGraphicsController();
4215     graphics.AddCustomUniforms(customUniforms);
4216
4217     VisualFactory factory = VisualFactory::Get();
4218     Property::Map properties;
4219     Vector4       cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4220     float         borderlineWidth = 30.0f;
4221     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4222     float         borderlineOffset = -0.4f;
4223
4224     properties[Visual::Property::TYPE]           = Visual::COLOR;
4225     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4226     properties["cornerRadius"]                   = cornerRadius;
4227     properties["borderlineWidth"]                = borderlineWidth;
4228     properties["borderlineColor"]                = borderlineColor;
4229     properties["borderlineOffset"]               = borderlineOffset;
4230
4231     Visual::Base visual = factory.CreateVisual(properties);
4232
4233     // trigger creation through setting on stage
4234     DummyControl        dummy     = DummyControl::New(true);
4235     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4236     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4237
4238     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4239     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4240     application.GetScene().Add(dummy);
4241
4242     application.SendNotification();
4243     application.Render();
4244
4245     application.SendNotification();
4246     application.Render();
4247
4248     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4249     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4250     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4251     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4252   }
4253
4254   // color visual 2, default color, default offset
4255   {
4256     ToolkitTestApplication  application;
4257     TestGraphicsController& graphics = application.GetGraphicsController();
4258     graphics.AddCustomUniforms(customUniforms);
4259
4260     VisualFactory factory = VisualFactory::Get();
4261     Property::Map properties;
4262     float         borderlineWidth = 30.0f;
4263
4264     properties[Visual::Property::TYPE]                  = Visual::COLOR;
4265     properties[ColorVisual::Property::MIX_COLOR]        = Color::BLUE;
4266     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4267
4268     Visual::Base visual = factory.CreateVisual(properties);
4269
4270     // trigger creation through setting on stage
4271     DummyControl        dummy     = DummyControl::New(true);
4272     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4273     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4274
4275     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4276     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4277     application.GetScene().Add(dummy);
4278
4279     application.SendNotification();
4280     application.Render();
4281
4282     application.SendNotification();
4283     application.Render();
4284
4285     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4286     // Default borderline color is BLACK.
4287     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4288     // Default borderline offset is 0.0f.
4289     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4290   }
4291
4292   // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4293   {
4294     ToolkitTestApplication  application;
4295     TestGraphicsController& graphics = application.GetGraphicsController();
4296     graphics.AddCustomUniforms(customUniforms);
4297
4298     VisualFactory factory = VisualFactory::Get();
4299     Property::Map properties;
4300     float         borderlineWidth = 30.0f;
4301     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4302     float         borderlineOffset = 37.4f;
4303
4304     properties[Visual::Property::TYPE]           = Visual::COLOR;
4305     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4306     properties["borderlineWidth"]                = borderlineWidth;
4307     properties["borderlineColor"]                = borderlineColor;
4308     properties["borderlineOffset"]               = borderlineOffset;
4309
4310     Visual::Base visual = factory.CreateVisual(properties);
4311
4312     // trigger creation through setting on stage
4313     DummyControl        dummy     = DummyControl::New(true);
4314     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4315     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4316
4317     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4318     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4319     application.GetScene().Add(dummy);
4320
4321     application.SendNotification();
4322     application.Render();
4323
4324     application.SendNotification();
4325     application.Render();
4326
4327     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4328     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4329     // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4330     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4331   }
4332
4333   // gradient visual
4334   {
4335     ToolkitTestApplication  application;
4336     TestGraphicsController& graphics = application.GetGraphicsController();
4337     graphics.AddCustomUniforms(customUniforms);
4338
4339     VisualFactory factory = VisualFactory::Get();
4340     Property::Map properties;
4341     float         borderlineWidth = 30.0f;
4342     float         cornerRadius    = 70.0f;
4343
4344     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4345     properties[ColorVisual::Property::MIX_COLOR]         = Color::BLUE;
4346     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4347     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4348     properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4349     properties[GradientVisual::Property::END_POSITION]   = Vector2(-0.5f, -0.5f);
4350     properties[GradientVisual::Property::UNITS]          = GradientVisual::Units::USER_SPACE;
4351
4352     Property::Array stopOffsets;
4353     stopOffsets.PushBack(0.0f);
4354     stopOffsets.PushBack(0.6f);
4355     stopOffsets.PushBack(1.0f);
4356     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4357
4358     Property::Array stopColors;
4359     stopColors.PushBack(Color::RED);
4360     stopColors.PushBack(Color::YELLOW);
4361     stopColors.PushBack(Color::GREEN);
4362     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4363
4364     Visual::Base visual = factory.CreateVisual(properties);
4365
4366     // trigger creation through setting on stage
4367     DummyControl        dummy     = DummyControl::New(true);
4368     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4369     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4370
4371     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4372     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4373     application.GetScene().Add(dummy);
4374
4375     application.SendNotification();
4376     application.Render();
4377
4378     application.SendNotification();
4379     application.Render();
4380
4381     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4382     // Default corner radius policy is absolute.
4383     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4384     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4385     // Default borderline color is BLACK.
4386     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4387     // Default borderline offset is 0.0f.
4388     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4389   }
4390
4391   // animated image visual
4392   {
4393     ToolkitTestApplication  application;
4394     TestGraphicsController& graphics = application.GetGraphicsController();
4395     graphics.AddCustomUniforms(customUniforms);
4396
4397     VisualFactory factory = VisualFactory::Get();
4398     Property::Map properties;
4399     float         borderlineWidth  = 24.0f;
4400     float         borderlineOffset = -1.0f;
4401
4402     properties[Visual::Property::TYPE]                  = Visual::ANIMATED_IMAGE;
4403     properties[ImageVisual::Property::URL]              = TEST_GIF_FILE_NAME;
4404     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4405     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4406     properties["borderlineOffset"]                      = borderlineOffset;
4407
4408     Visual::Base visual = factory.CreateVisual(properties);
4409
4410     // trigger creation through setting on stage
4411     DummyControl        dummy     = DummyControl::New(true);
4412     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4413     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4414
4415     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4416     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4417     application.GetScene().Add(dummy);
4418
4419     application.SendNotification();
4420     application.Render();
4421
4422     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4423
4424     application.SendNotification();
4425     application.Render();
4426
4427     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4428     // Default borderline color is BLACK.
4429     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4430     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4431   }
4432
4433   // vector image visual
4434   {
4435     ToolkitTestApplication  application;
4436     TestGraphicsController& graphics = application.GetGraphicsController();
4437     graphics.AddCustomUniforms(customUniforms);
4438
4439     VisualFactory factory = VisualFactory::Get();
4440     Property::Map properties;
4441     Vector4       cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4442     float         borderlineWidth = 27.0f;
4443     Vector4       borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4444
4445     properties[Visual::Property::TYPE]                  = Visual::SVG;
4446     properties[ImageVisual::Property::URL]              = TEST_SVG_FILE_NAME;
4447     properties[DevelVisual::Property::CORNER_RADIUS]    = cornerRadius;
4448     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4449     properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4450
4451     Visual::Base visual = factory.CreateVisual(properties);
4452
4453     // trigger creation through setting on stage
4454     DummyControl        dummy     = DummyControl::New(true);
4455     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4456     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4457
4458     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4459     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4460     application.GetScene().Add(dummy);
4461
4462     application.SendNotification();
4463     application.Render();
4464
4465     // Wait for loading & rasterization
4466     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4467
4468     application.SendNotification();
4469     application.Render();
4470
4471     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4472     // Default corner radius policy is absolute.
4473     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4474     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4475     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4476     // Default borderline offset is 0.0.
4477     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4478   }
4479
4480   // animated vector image visual
4481   {
4482     ToolkitTestApplication  application;
4483     TestGraphicsController& graphics = application.GetGraphicsController();
4484     graphics.AddCustomUniforms(customUniforms);
4485
4486     VisualFactory factory = VisualFactory::Get();
4487     Property::Map properties;
4488     Vector4       cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4489     float         borderlineWidth = 13.0f;
4490     Vector4       borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4491     float         borderlineOffset = 13.0f;
4492
4493     properties[Visual::Property::TYPE]                      = DevelVisual::ANIMATED_VECTOR_IMAGE;
4494     properties[ImageVisual::Property::URL]                  = TEST_VECTOR_IMAGE_FILE_NAME;
4495     properties["cornerRadius"]                              = cornerRadius;
4496     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4497     properties[DevelVisual::Property::BORDERLINE_WIDTH]     = borderlineWidth;
4498     properties["borderlineColor"]                           = borderlineColor;
4499     properties[DevelVisual::Property::BORDERLINE_OFFSET]    = borderlineOffset;
4500
4501     Visual::Base visual = factory.CreateVisual(properties);
4502
4503     // trigger creation through setting on stage
4504     DummyControl        dummy     = DummyControl::New(true);
4505     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4506     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4507
4508     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4509     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4510     application.GetScene().Add(dummy);
4511
4512     application.SendNotification();
4513     application.Render();
4514
4515     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4516
4517     application.SendNotification();
4518     application.Render();
4519
4520     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4521     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4522     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4523     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4524     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4525   }
4526
4527   END_TEST;
4528 }
4529
4530 int UtcDaliVisualBorderlineBlendModeTest(void)
4531 {
4532   ToolkitTestApplication application;
4533   tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4534   VisualFactory factory = VisualFactory::Get();
4535
4536   // Case 1 : Test which doesn't support borderline feature.
4537   {
4538     tet_printf("Test Unsupported visual type\n");
4539     Property::Map propertyMap;
4540     propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4541     propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4542     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4543     Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4544
4545     DummyControl        actor     = DummyControl::New(true);
4546     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4547     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4548     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4549     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4550     application.GetScene().Add(actor);
4551
4552     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4553
4554     Renderer renderer = actor.GetRendererAt(0);
4555
4556     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4557     // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4558     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4559
4560     application.GetScene().Remove(actor);
4561   }
4562
4563   // Case 2 : Test which support borderline feature.
4564   {
4565     tet_printf("Test normal case\n");
4566     Property::Map propertyMap;
4567     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4568     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4569     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4570     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4571
4572     DummyControl        actor     = DummyControl::New(true);
4573     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4574     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4575     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4576     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4577     application.GetScene().Add(actor);
4578
4579     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4580
4581     Renderer renderer = actor.GetRendererAt(0);
4582
4583     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4584     // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4585     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4586
4587     application.GetScene().Remove(actor);
4588   }
4589
4590   // Case 3 : Test which animated borderline.
4591   {
4592     tet_printf("Test borderline animate case\n");
4593     Property::Map propertyMap;
4594     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4595     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4596     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4597
4598     DummyControl        actor     = DummyControl::New(true);
4599     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4600     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4601     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4602     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4603     application.GetScene().Add(actor);
4604
4605     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4606
4607     Renderer renderer = actor.GetRendererAt(0);
4608
4609     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4610     // BlendMode is AUTO.
4611     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4612
4613     Animation animation = Animation::New(0.1f);
4614     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4615     animation.Play();
4616
4617     application.SendNotification();
4618     application.Render();
4619     application.Render(101u); // End of animation
4620
4621     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4622     // BlendMode is ON_WITHOUT_CULL.
4623     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4624
4625     Animation revanimation = Animation::New(0.1f);
4626     revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4627     revanimation.Play();
4628
4629     application.SendNotification();
4630     application.Render();
4631     application.Render(101u); // End of animation
4632
4633     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4634     // BlendMode is still ON_WITHOUT_CULL.
4635     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4636
4637     application.GetScene().Remove(actor);
4638   }
4639
4640   // Case 4 : Test which animated corner radius occur.
4641   {
4642     tet_printf("Test borderline animate case\n");
4643     Property::Map propertyMap;
4644     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4645     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4646     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4647     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4648
4649     DummyControl        actor     = DummyControl::New(true);
4650     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4651     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4652     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4653     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4654     application.GetScene().Add(actor);
4655
4656     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4657
4658     Renderer renderer = actor.GetRendererAt(0);
4659
4660     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4661     // BlendMode is ON_WITHOUT_CULL.
4662     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4663
4664     Animation animation = Animation::New(0.1f);
4665     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4666     animation.Play();
4667
4668     application.SendNotification();
4669     application.Render();
4670     application.Render(101u); // End of animation
4671
4672     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4673     // BlendMode is ON_WITHOUT_CULL.
4674     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4675
4676     application.GetScene().Remove(actor);
4677   }
4678
4679   END_TEST;
4680 }
4681
4682 int UtcDaliVisualBorderlineColorAnimateTest(void)
4683 {
4684   ToolkitTestApplication application;
4685   tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4686
4687   TestGraphicsController&         graphics = application.GetGraphicsController();
4688   static std::vector<UniformData> customUniforms =
4689     {
4690       UniformData("mixColor", Property::Type::VECTOR3),
4691       UniformData("cornerRadius", Property::Type::VECTOR4),
4692       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4693       UniformData("borderlineWidth", Property::Type::FLOAT),
4694       UniformData("borderlineColor", Property::Type::VECTOR4),
4695       UniformData("borderlineOffset", Property::Type::FLOAT),
4696     };
4697   graphics.AddCustomUniforms(customUniforms);
4698
4699   {
4700     const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4701     const float   INITIAL_MIX_OPACITY(0.5f);
4702     const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4703     const float   INITIAL_ACTOR_OPACITY(1.0f);
4704     const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4705     const float   TARGET_MIX_OPACITY(0.8f);
4706     const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4707     const float   TARGET_ACTOR_OPACITY(0.5f);
4708
4709     VisualFactory factory = VisualFactory::Get();
4710     Property::Map propertyMap;
4711     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4712     propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4713     propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4714     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4715     propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4716     Visual::Base visual = factory.CreateVisual(propertyMap);
4717
4718     DummyControl        actor     = DummyControl::New(true);
4719     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4720     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4721     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4722     actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4723     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4724     application.GetScene().Add(actor);
4725
4726     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4727
4728     Animation animation = Animation::New(4.0f);
4729     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4730     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4731     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4732     animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4733     animation.Play();
4734
4735     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4736
4737     application.SendNotification();
4738     application.Render(0);
4739     application.Render(2000u); // halfway point
4740     application.SendNotification();
4741
4742     Vector3 halfwayMixColor        = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4743     float   halfwayMixOpacity      = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4744     Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4745     float   halfwayActorOpacity    = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4746     halfwayMixOpacity *= halfwayActorOpacity;
4747     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4748     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4749     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4750     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4751
4752     application.Render(2001u);      // go past end
4753     application.SendNotification(); // Trigger signals
4754
4755     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4756     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4757     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4758     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4759     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4760
4761     actor.Unparent();
4762   }
4763
4764   END_TEST;
4765 }
4766
4767 int UtcDaliColorVisualBlurRadius(void)
4768 {
4769   ToolkitTestApplication application;
4770   tet_infoline("UtcDaliColorVisualBlurRadius");
4771
4772   static std::vector<UniformData> customUniforms =
4773     {
4774       UniformData("blurRadius", Property::Type::FLOAT),
4775     };
4776
4777   TestGraphicsController& graphics = application.GetGraphicsController();
4778   graphics.AddCustomUniforms(customUniforms);
4779
4780   VisualFactory factory = VisualFactory::Get();
4781   Property::Map properties;
4782   float         blurRadius = 20.0f;
4783
4784   properties[Visual::Property::TYPE]           = Visual::COLOR;
4785   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4786   properties["blurRadius"]                     = blurRadius;
4787
4788   Visual::Base visual = factory.CreateVisual(properties);
4789
4790   // trigger creation through setting on stage
4791   DummyControl        dummy     = DummyControl::New(true);
4792   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4793   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4794
4795   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4796   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4797   application.GetScene().Add(dummy);
4798
4799   application.SendNotification();
4800   application.Render();
4801
4802   application.SendNotification();
4803   application.Render();
4804
4805   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4806
4807   END_TEST;
4808 }
4809
4810 int UtcDaliVisualGetType(void)
4811 {
4812   ToolkitTestApplication application;
4813   tet_infoline("UtcDaliVisualGetType");
4814
4815   VisualFactory factory = VisualFactory::Get();
4816
4817   {
4818     Property::Map properties;
4819     properties[Visual::Property::TYPE] = Visual::BORDER;
4820     Visual::Base visual                = factory.CreateVisual(properties);
4821
4822     DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4823   }
4824
4825   {
4826     Property::Map properties;
4827     properties[Visual::Property::TYPE] = Visual::COLOR;
4828     Visual::Base visual                = factory.CreateVisual(properties);
4829
4830     DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4831   }
4832
4833   {
4834     Property::Map properties;
4835     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4836     properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4837     properties[GradientVisual::Property::END_POSITION]   = Vector2(1.f, 1.f);
4838     properties[GradientVisual::Property::STOP_OFFSET]    = Vector2(0.f, 1.f);
4839     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4840     Property::Array stopColors;
4841     stopColors.PushBack(Color::RED);
4842     stopColors.PushBack(Color::GREEN);
4843     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4844     Visual::Base visual                              = factory.CreateVisual(properties);
4845
4846     DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4847   }
4848
4849   {
4850     Property::Map properties;
4851     properties[Visual::Property::TYPE] = Visual::IMAGE;
4852     properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4853     Visual::Base visual = factory.CreateVisual(properties);
4854
4855     DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4856   }
4857
4858   {
4859     Property::Map properties;
4860     properties[Visual::Property::TYPE] = Visual::MESH;
4861     Visual::Base visual                = factory.CreateVisual(properties);
4862
4863     DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4864   }
4865
4866   {
4867     Property::Map properties;
4868     properties[Visual::Property::TYPE]           = Visual::PRIMITIVE;
4869     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4870     Visual::Base visual                          = factory.CreateVisual(properties);
4871
4872     DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4873   }
4874
4875   {
4876     Property::Map properties;
4877     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4878     Visual::Base visual                = factory.CreateVisual(properties);
4879
4880     DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4881   }
4882
4883   {
4884     Property::Map properties;
4885     properties[Visual::Property::TYPE] = Visual::TEXT;
4886     Visual::Base visual                = factory.CreateVisual(properties);
4887
4888     DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4889   }
4890
4891   {
4892     Property::Map properties;
4893     properties[Visual::Property::TYPE]     = Visual::N_PATCH;
4894     properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4895     Visual::Base visual                    = factory.CreateVisual(properties);
4896
4897     DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4898   }
4899
4900   {
4901     Property::Map properties;
4902     properties[Visual::Property::TYPE]     = Visual::SVG;
4903     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4904     Visual::Base visual                    = factory.CreateVisual(properties);
4905
4906     DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4907   }
4908
4909   {
4910     Property::Map properties;
4911     properties[Visual::Property::TYPE]     = Visual::ANIMATED_IMAGE;
4912     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4913     Visual::Base visual                    = factory.CreateVisual(properties);
4914
4915     DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4916   }
4917
4918   {
4919     Property::Map properties;
4920     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4921     Visual::Base visual                = factory.CreateVisual(properties);
4922
4923     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4924   }
4925
4926   {
4927     Property::Map properties;
4928     properties[Visual::Property::TYPE]     = DevelVisual::ANIMATED_VECTOR_IMAGE;
4929     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4930     Visual::Base visual                    = factory.CreateVisual(properties);
4931
4932     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4933   }
4934
4935   {
4936     Property::Map properties;
4937     properties[Visual::Property::TYPE] = DevelVisual::ARC;
4938     Visual::Base visual                = factory.CreateVisual(properties);
4939
4940     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4941   }
4942
4943   END_TEST;
4944 }
4945
4946 int UtcDaliVisualGetVisualProperty01(void)
4947 {
4948   ToolkitTestApplication application;
4949   tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4950
4951   static std::vector<UniformData> customUniforms =
4952     {
4953       UniformData("mixColor", Property::Type::VECTOR3),
4954       UniformData("offset", Property::Type::VECTOR2),
4955       UniformData("size", Property::Type::VECTOR2),
4956       UniformData("cornerRadius", Property::Type::VECTOR4),
4957       UniformData("blurRadius", Property::Type::FLOAT),
4958       UniformData("borderlineWidth", Property::Type::FLOAT),
4959       UniformData("borderlineColor", Property::Type::VECTOR4),
4960       UniformData("borderlineOffset", Property::Type::FLOAT)};
4961
4962   TestGraphicsController& graphics = application.GetGraphicsController();
4963   graphics.AddCustomUniforms(customUniforms);
4964
4965   VisualFactory factory = VisualFactory::Get();
4966   Property::Map propertyMap;
4967   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4968   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4969   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4970   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4971   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4972   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4973   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4974   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4975   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4976
4977   DummyControl        dummyControl = DummyControl::New(true);
4978   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4979   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4980   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4981   application.GetScene().Add(dummyControl);
4982
4983   application.SendNotification();
4984   application.Render();
4985
4986   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4987   Vector2 targetOffset(0.05f, 0.05f);
4988   Vector2 targetSize(1.1f, 1.1f);
4989   float   targetOpacity = 0.5f;
4990   Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4991   float   targetBlurRadius      = 10.0f;
4992   float   targetBorderlineWidth = 25.0f;
4993   Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4994   float   targetBorderlineOffset = -1.0f;
4995
4996   Animation animation = Animation::New(1.0f);
4997   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4998   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4999   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5000   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5001   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5002   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5003   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5004   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5005   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5006   animation.Play();
5007
5008   application.SendNotification();
5009   application.Render();
5010   application.Render(1001u); // End of animation
5011
5012   Property::Map resultMap;
5013   colorVisual.CreatePropertyMap(resultMap);
5014
5015   // Test property values: they should be updated
5016   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5017   DALI_TEST_CHECK(colorValue);
5018   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5019
5020   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5021   Dali::Property::Map* transformMap   = transformValue->GetMap();
5022   DALI_TEST_CHECK(transformMap);
5023
5024   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5025   DALI_TEST_CHECK(offsetValue);
5026   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5027
5028   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5029   DALI_TEST_CHECK(sizeValue);
5030   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5031
5032   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5033   DALI_TEST_CHECK(cornerRadiusValue);
5034   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5035
5036   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5037   DALI_TEST_CHECK(blurRadiusValue);
5038   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5039
5040   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5041   DALI_TEST_CHECK(borderlineWidthValue);
5042   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5043
5044   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5045   DALI_TEST_CHECK(borderlineColorValue);
5046   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5047
5048   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5049   DALI_TEST_CHECK(borderlineOffsetValue);
5050   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5051
5052   // Test uniform values
5053   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5054   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5055   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5056   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5057   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5058   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5059   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5060   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5061
5062   // Test unregistered visual
5063   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5064   DALI_TEST_CHECK(!property3.object);
5065   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5066
5067   END_TEST;
5068 }
5069
5070 int UtcDaliVisualGetVisualProperty02(void)
5071 {
5072   ToolkitTestApplication application;
5073   tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5074
5075   static std::vector<UniformData> customUniforms =
5076     {
5077       UniformData("mixColor", Property::Type::VECTOR3),
5078       UniformData("offset", Property::Type::VECTOR2),
5079       UniformData("size", Property::Type::VECTOR2),
5080       UniformData("cornerRadius", Property::Type::VECTOR4),
5081       UniformData("borderlineWidth", Property::Type::FLOAT),
5082       UniformData("borderlineCOlor", Property::Type::VECTOR4),
5083       UniformData("borderlineOffset", Property::Type::FLOAT),
5084       UniformData("blurRadius", Property::Type::FLOAT),
5085     };
5086
5087   TestGraphicsController& graphics = application.GetGraphicsController();
5088   graphics.AddCustomUniforms(customUniforms);
5089
5090   VisualFactory factory = VisualFactory::Get();
5091   Property::Map propertyMap;
5092   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5093   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5094
5095   DummyControl        dummyControl = DummyControl::New(true);
5096   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5097   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5098   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5099   application.GetScene().Add(dummyControl);
5100
5101   application.SendNotification();
5102   application.Render();
5103
5104   Vector3 targetColor(1.0f, 1.0f, 1.0f);
5105   Vector2 targetOffset(0.05f, 0.05f);
5106   Vector2 targetSize(1.1f, 1.1f);
5107   float   targetOpacity = 0.5f;
5108   Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5109   float   targetBorderlineWidth = 77.7f;
5110   Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5111   float   targetBorderlineOffset = 1.0f;
5112   float   targetBlurRadius       = 10.0f;
5113
5114   // Should work when the properties are not set before
5115   Animation animation = Animation::New(1.0f);
5116   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5117   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5118   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5119   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5120   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5121   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5122   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5123   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5124   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5125   animation.Play();
5126
5127   application.SendNotification();
5128   application.Render();
5129   application.Render(1001u); // End of animation
5130
5131   Property::Map resultMap;
5132   colorVisual.CreatePropertyMap(resultMap);
5133
5134   // Test property values: they should be updated
5135   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5136   DALI_TEST_CHECK(colorValue);
5137   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5138
5139   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5140   Dali::Property::Map* transformMap   = transformValue->GetMap();
5141   DALI_TEST_CHECK(transformMap);
5142
5143   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5144   DALI_TEST_CHECK(offsetValue);
5145   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5146
5147   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5148   DALI_TEST_CHECK(sizeValue);
5149   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5150
5151   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5152   DALI_TEST_CHECK(cornerRadiusValue);
5153   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5154
5155   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5156   DALI_TEST_CHECK(borderlineWidthValue);
5157   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5158
5159   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5160   DALI_TEST_CHECK(borderlineColorValue);
5161   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5162
5163   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5164   DALI_TEST_CHECK(borderlineOffsetValue);
5165   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5166
5167   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5168   DALI_TEST_CHECK(blurRadiusValue);
5169   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5170
5171   // Test uniform values
5172   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5173   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5174   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5175   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5176   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5177
5178   END_TEST;
5179 }
5180
5181 int UtcDaliVisualGetVisualProperty03(void)
5182 {
5183   ToolkitTestApplication application;
5184   tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5185
5186   static std::vector<UniformData> customUniforms =
5187     {
5188       UniformData("cornerRadius", Property::Type::VECTOR4),
5189       UniformData("borderlineWidth", Property::Type::FLOAT),
5190       UniformData("borderlineColor", Property::Type::VECTOR4),
5191       UniformData("borderlineOffset", Property::Type::FLOAT),
5192     };
5193
5194   TestGraphicsController& graphics = application.GetGraphicsController();
5195   graphics.AddCustomUniforms(customUniforms);
5196
5197   VisualFactory factory = VisualFactory::Get();
5198   Property::Map propertyMap;
5199   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5200   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5201
5202   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5203
5204   DummyControl        dummyControl = DummyControl::New(true);
5205   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5206   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5207   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5208   application.GetScene().Add(dummyControl);
5209
5210   // Wait for image loading
5211   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5212
5213   application.SendNotification();
5214   application.Render();
5215
5216   float   targetOpacity = 0.5f;
5217   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5218   float   targetBorderlineWidth = 10.0f;
5219   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5220   float   targetBorderlineOffset = -1.5f;
5221
5222   Animation animation = Animation::New(1.0f);
5223   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5224   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5225   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5226   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5227   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5228   animation.Play();
5229
5230   application.SendNotification();
5231   application.Render();
5232   application.Render(1001u); // End of animation
5233
5234   Property::Map resultMap;
5235   imageVisual.CreatePropertyMap(resultMap);
5236
5237   // Test property values: they should be updated
5238   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5239   DALI_TEST_CHECK(colorValue);
5240   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5241
5242   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5243   DALI_TEST_CHECK(cornerRadiusValue);
5244   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5245
5246   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5247   DALI_TEST_CHECK(borderlineWidthValue);
5248   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5249
5250   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5251   DALI_TEST_CHECK(borderlineColorValue);
5252   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5253
5254   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5255   DALI_TEST_CHECK(borderlineOffsetValue);
5256   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5257
5258   // Test uniform value
5259   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5260   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5261   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5262   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5263
5264   END_TEST;
5265 }
5266
5267 int UtcDaliVisualGetVisualProperty04(void)
5268 {
5269   ToolkitTestApplication application;
5270   tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5271
5272   static std::vector<UniformData> customUniforms =
5273     {
5274       UniformData("cornerRadius", Property::Type::VECTOR4),
5275     };
5276
5277   TestGraphicsController& graphics = application.GetGraphicsController();
5278   graphics.AddCustomUniforms(customUniforms);
5279
5280   Vector2         start(-1.f, -1.f);
5281   Vector2         end(1.f, 1.f);
5282   Property::Array stopColors;
5283   stopColors.PushBack(Color::RED);
5284   stopColors.PushBack(Color::GREEN);
5285
5286   VisualFactory factory = VisualFactory::Get();
5287   Property::Map propertyMap;
5288   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5289   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5290   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5291   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5292   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5293   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5294   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5295
5296   DummyControl        dummyControl = DummyControl::New(true);
5297   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5298   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5299   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5300   application.GetScene().Add(dummyControl);
5301
5302   application.SendNotification();
5303   application.Render();
5304
5305   float   targetOpacity = 0.5f;
5306   Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5307
5308   Animation animation = Animation::New(1.0f);
5309   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5310   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5311   animation.Play();
5312
5313   application.SendNotification();
5314   application.Render();
5315   application.Render(1001u); // End of animation
5316
5317   Property::Map resultMap;
5318   gradientVisual.CreatePropertyMap(resultMap);
5319
5320   // Test property values: they should be updated
5321   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5322   DALI_TEST_CHECK(colorValue);
5323   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5324
5325   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5326   DALI_TEST_CHECK(cornerRadiusValue);
5327   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5328
5329   // Test uniform value
5330   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5331
5332   END_TEST;
5333 }
5334
5335 int UtcDaliVisualGetVisualProperty05(void)
5336 {
5337   ToolkitTestApplication application;
5338   tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5339
5340   static std::vector<UniformData> customUniforms =
5341     {
5342       UniformData("cornerRadius", Property::Type::VECTOR4),
5343       UniformData("borderlineWidth", Property::Type::FLOAT),
5344       UniformData("borderlineColor", Property::Type::VECTOR4),
5345       UniformData("borderlineOffset", Property::Type::FLOAT),
5346     };
5347
5348   TestGraphicsController& graphics = application.GetGraphicsController();
5349   graphics.AddCustomUniforms(customUniforms);
5350
5351   VisualFactory factory = VisualFactory::Get();
5352   Property::Map propertyMap;
5353   propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5354   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5355
5356   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5357
5358   DummyControl        dummyControl = DummyControl::New(true);
5359   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5360   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5361   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5362   application.GetScene().Add(dummyControl);
5363
5364   application.SendNotification();
5365   application.Render();
5366
5367   // Wait for loading & rasterization
5368   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5369
5370   application.SendNotification();
5371   application.Render();
5372
5373   float   targetOpacity = 0.5f;
5374   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5375   float   targetBorderlineWidth = 10.0f;
5376   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5377   float   targetBorderlineOffset = -1.5f;
5378
5379   Animation animation = Animation::New(1.0f);
5380   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5381   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5382   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5383   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5384   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5385   animation.Play();
5386
5387   application.SendNotification();
5388   application.Render();
5389   application.Render(1001u); // End of animation
5390
5391   Property::Map resultMap;
5392   svgVisual.CreatePropertyMap(resultMap);
5393
5394   // Test property values: they should be updated
5395   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5396   DALI_TEST_CHECK(colorValue);
5397   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5398
5399   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5400   DALI_TEST_CHECK(cornerRadiusValue);
5401   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5402
5403   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5404   DALI_TEST_CHECK(borderlineWidthValue);
5405   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5406
5407   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5408   DALI_TEST_CHECK(borderlineColorValue);
5409   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5410
5411   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5412   DALI_TEST_CHECK(borderlineOffsetValue);
5413   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5414
5415   // Currently test with multiple program doesn't work well. will fix another day
5416   // Test uniform value
5417   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5418   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5419   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5420   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5421
5422   END_TEST;
5423 }
5424
5425 int UtcDaliVisualGetVisualProperty06(void)
5426 {
5427   ToolkitTestApplication application;
5428   tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5429
5430   static std::vector<UniformData> customUniforms =
5431     {
5432       UniformData("cornerRadius", Property::Type::VECTOR4),
5433       UniformData("borderlineWidth", Property::Type::FLOAT),
5434       UniformData("borderlineColor", Property::Type::VECTOR4),
5435       UniformData("borderlineOffset", Property::Type::FLOAT),
5436     };
5437
5438   TestGraphicsController& graphics = application.GetGraphicsController();
5439   graphics.AddCustomUniforms(customUniforms);
5440
5441   VisualFactory factory = VisualFactory::Get();
5442   Property::Map propertyMap;
5443   propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5444   propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5445
5446   Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5447
5448   DummyControl        dummyControl = DummyControl::New(true);
5449   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5450   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5451   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5452   application.GetScene().Add(dummyControl);
5453
5454   application.SendNotification();
5455   application.Render();
5456
5457   // Wait for image loading
5458   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5459
5460   application.SendNotification();
5461   application.Render();
5462
5463   float   targetOpacity = 0.5f;
5464   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5465   float   targetBorderlineWidth = 10.0f;
5466   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5467   float   targetBorderlineOffset = -1.5f;
5468
5469   Animation animation = Animation::New(1.0f);
5470   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5471   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5472   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5473   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5474   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5475   animation.Play();
5476
5477   application.SendNotification();
5478   application.Render();
5479   application.Render(1001u); // End of animation
5480
5481   Property::Map resultMap;
5482   animatedImageVisual.CreatePropertyMap(resultMap);
5483
5484   // Test property values: they should be updated
5485   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5486   DALI_TEST_CHECK(colorValue);
5487   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5488
5489   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5490   DALI_TEST_CHECK(cornerRadiusValue);
5491   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5492
5493   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5494   DALI_TEST_CHECK(borderlineWidthValue);
5495   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5496
5497   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5498   DALI_TEST_CHECK(borderlineColorValue);
5499   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5500
5501   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5502   DALI_TEST_CHECK(borderlineOffsetValue);
5503   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5504
5505   // Currently test with multiple program doesn't work well. will fix another day
5506   // Test uniform value
5507   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5508   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5509   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5510   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5511
5512   END_TEST;
5513 }
5514
5515 int UtcDaliVisualGetVisualProperty07(void)
5516 {
5517   ToolkitTestApplication application;
5518   tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5519
5520   static std::vector<UniformData> customUniforms =
5521     {
5522       UniformData("cornerRadius", Property::Type::VECTOR4),
5523       UniformData("borderlineWidth", Property::Type::FLOAT),
5524       UniformData("borderlineColor", Property::Type::VECTOR4),
5525       UniformData("borderlineOffset", Property::Type::FLOAT),
5526     };
5527
5528   TestGraphicsController& graphics = application.GetGraphicsController();
5529   graphics.AddCustomUniforms(customUniforms);
5530
5531   VisualFactory factory = VisualFactory::Get();
5532   Property::Map propertyMap;
5533   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5534   propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5535
5536   Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5537
5538   DummyControl        dummyControl = DummyControl::New(true);
5539   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5540   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5541   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5542   application.GetScene().Add(dummyControl);
5543
5544   application.SendNotification();
5545   application.Render();
5546
5547   // Wait for image loading
5548   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5549
5550   application.SendNotification();
5551   application.Render();
5552
5553   float   targetOpacity = 0.5f;
5554   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5555   float   targetBorderlineWidth = 10.0f;
5556   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5557   float   targetBorderlineOffset = -1.5f;
5558
5559   Animation animation = Animation::New(1.0f);
5560   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5561   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5562   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5563   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5564   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5565   animation.Play();
5566
5567   application.SendNotification();
5568   application.Render();
5569   application.Render(1001u); // End of animation
5570
5571   Property::Map resultMap;
5572   animatedVectorVisual.CreatePropertyMap(resultMap);
5573
5574   // Test property values: they should be updated
5575   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5576   DALI_TEST_CHECK(colorValue);
5577   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5578
5579   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5580   DALI_TEST_CHECK(cornerRadiusValue);
5581   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5582
5583   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5584   DALI_TEST_CHECK(borderlineWidthValue);
5585   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5586
5587   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5588   DALI_TEST_CHECK(borderlineColorValue);
5589   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5590
5591   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5592   DALI_TEST_CHECK(borderlineOffsetValue);
5593   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5594
5595   // Currently test with multiple program doesn't work well. will fix another day
5596   // Test uniform value
5597   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5598   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5599   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5600   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5601
5602   END_TEST;
5603 }
5604
5605 int UtcDaliVisualUpdateProperty(void)
5606 {
5607   ToolkitTestApplication application;
5608   tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5609
5610   VisualFactory factory = VisualFactory::Get();
5611   Property::Map propertyMap;
5612   propertyMap[Visual::Property::TYPE]                     = Visual::Type::IMAGE;
5613   propertyMap[ImageVisual::Property::URL]                 = TEST_IMAGE_FILE_NAME;
5614   propertyMap[Visual::Property::MIX_COLOR]                = Color::BLUE;
5615   propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5616
5617   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5618
5619   DummyControl        dummyControl = DummyControl::New(true);
5620   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5621   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5622   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5623   application.GetScene().Add(dummyControl);
5624
5625   application.SendNotification();
5626   application.Render();
5627
5628   // Wait for image loading
5629   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5630
5631   application.SendNotification();
5632   application.Render();
5633
5634   Property::Map originalMap;
5635   imageVisual.CreatePropertyMap(originalMap);
5636
5637   float                    targetOpacity            = 0.5f;
5638   Vector3                  targetMixColor           = Vector3(1.0f, 0.4f, 0.2f);
5639   bool                     targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5640   DevelVisual::FittingMode targetVisualFittingMode  = DevelVisual::CENTER;
5641
5642   Property::Map targetPropertyMap;
5643   targetPropertyMap[Visual::Property::OPACITY]                  = targetOpacity;
5644   targetPropertyMap[ImageVisual::Property::URL]                 = "foobar";
5645   targetPropertyMap[Visual::Property::MIX_COLOR]                = targetMixColor;
5646   targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA]      = targetPreMultipliedAlpha;
5647   targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5648
5649   // Update Properties
5650   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5651
5652   Property::Map resultMap;
5653   imageVisual.CreatePropertyMap(resultMap);
5654
5655   // Test property values: they should be updated
5656   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5657   DALI_TEST_CHECK(colorValue);
5658   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5659
5660   Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5661   DALI_TEST_CHECK(urlValue);
5662   // NOTE : ImageVisual URL must NOT changed.
5663   DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5664
5665   Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5666   DALI_TEST_CHECK(preMultipliedValue);
5667   DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5668
5669   Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5670   DALI_TEST_CHECK(visualFittingModeValue);
5671   DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5672
5673   END_TEST;
5674 }
5675
5676 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5677 {
5678   ToolkitTestApplication application;
5679   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5680
5681   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5682
5683   VisualFactory factory = VisualFactory::Get();
5684   Property::Map propertyMap;
5685   // Case ImageVisual
5686   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
5687   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5688
5689   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5690
5691   DummyControl        dummyControl = DummyControl::New(true);
5692   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5693   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5694   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5695   application.GetScene().Add(dummyControl);
5696
5697   application.SendNotification();
5698   application.Render();
5699
5700   // Wait for image loading
5701   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5702
5703   application.SendNotification();
5704   application.Render();
5705
5706   TestShaderCodeContainSubstrings(
5707     dummyControl,
5708     {
5709       {"#define IS_REQUIRED_BORDERLINE", false},
5710       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5711     },
5712     TEST_LOCATION);
5713
5714   callStack.Reset();
5715   callStack.Enable(true);
5716
5717   Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5718
5719   Property::Map targetPropertyMap;
5720   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]        = targetCornerRadius;
5721   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5722
5723   // Update Properties with CornerRadius
5724   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5725
5726   Property::Map resultMap;
5727   imageVisual.CreatePropertyMap(resultMap);
5728
5729   // Test property values: they should be updated
5730   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5731   DALI_TEST_CHECK(cornerRadiusValue);
5732   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5733
5734   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5735   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5736   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5737
5738   TestShaderCodeContainSubstrings(
5739     dummyControl,
5740     {
5741       {"#define IS_REQUIRED_BORDERLINE", false},
5742       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
5743     },
5744     TEST_LOCATION);
5745
5746   // Send shader compile signal
5747   application.SendNotification();
5748   application.Render();
5749
5750   callStack.Enable(false);
5751   // Shader changed
5752   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5753   callStack.Reset();
5754   callStack.Enable(true);
5755
5756   float   targetBorderlineWidth  = 10.0f;
5757   Vector4 targetBorderlineColor  = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5758   float   targetBorderlineOffset = -0.3f;
5759
5760   Property::Map targetPropertyMap2;
5761   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
5762   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5763   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]     = targetBorderlineWidth;
5764   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]     = targetBorderlineColor;
5765   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET]    = targetBorderlineOffset;
5766
5767   // Update Properties with Borderline
5768   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5769
5770   Property::Map resultMap2;
5771   imageVisual.CreatePropertyMap(resultMap2);
5772
5773   // Test property values: they should be updated
5774   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5775   DALI_TEST_CHECK(cornerRadiusValue);
5776   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5777
5778   cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5779   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5780   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5781
5782   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5783   DALI_TEST_CHECK(borderlineWidthValue);
5784   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5785
5786   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5787   DALI_TEST_CHECK(borderlineColorValue);
5788   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5789
5790   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5791   DALI_TEST_CHECK(borderlineOffsetValue);
5792   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5793
5794   TestShaderCodeContainSubstrings(
5795     dummyControl,
5796     {
5797       {"#define IS_REQUIRED_BORDERLINE", true},
5798       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
5799     },
5800     TEST_LOCATION);
5801
5802   // Send shader compile signal
5803   application.SendNotification();
5804   application.Render();
5805
5806   callStack.Enable(false);
5807   // Shader changed
5808   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5809   callStack.Reset();
5810   callStack.Enable(true);
5811
5812   Property::Map targetPropertyMap3;
5813   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
5814   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5815   targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH]     = 0.0f;
5816   targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR]     = Vector4::ZERO;
5817   targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET]    = 0.0f;
5818
5819   // Update Properties into zero
5820   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5821
5822   Property::Map resultMap3;
5823   imageVisual.CreatePropertyMap(resultMap3);
5824
5825   // Test property values: they should be updated
5826   cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5827   DALI_TEST_CHECK(cornerRadiusValue);
5828   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5829
5830   cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5831   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5832   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5833
5834   borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5835   DALI_TEST_CHECK(borderlineWidthValue);
5836   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5837
5838   borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5839   DALI_TEST_CHECK(borderlineColorValue);
5840   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5841
5842   borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5843   DALI_TEST_CHECK(borderlineOffsetValue);
5844   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5845
5846   TestShaderCodeContainSubstrings(
5847     dummyControl,
5848     {
5849       {"#define IS_REQUIRED_BORDERLINE", true},     // Note : mAlwaysUsingBorderline is true.
5850       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
5851     },
5852     TEST_LOCATION);
5853
5854   // Send shader compile signal
5855   application.SendNotification();
5856   application.Render();
5857
5858   callStack.Enable(false);
5859   // Shader not changed
5860   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5861
5862   END_TEST;
5863 }
5864
5865 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5866 {
5867   ToolkitTestApplication application;
5868   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5869
5870   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5871
5872   VisualFactory factory = VisualFactory::Get();
5873   Property::Map propertyMap;
5874   // Case ImageVisual
5875   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
5876   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5877
5878   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5879
5880   DummyControl        dummyControl = DummyControl::New(true);
5881   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5882   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5883   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5884   application.GetScene().Add(dummyControl);
5885
5886   application.SendNotification();
5887   application.Render();
5888
5889   // Wait for image loading
5890   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5891
5892   application.SendNotification();
5893   application.Render();
5894
5895   TestShaderCodeContainSubstrings(
5896     dummyControl,
5897     {
5898       {"#define IS_REQUIRED_BORDERLINE", false},
5899       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5900     },
5901     TEST_LOCATION);
5902
5903   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5904
5905   Property::Map targetPropertyMap;
5906   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5907
5908   callStack.Reset();
5909   callStack.Enable(true);
5910
5911   // Update Properties with CornerRadius
5912   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5913
5914   Property::Map resultMap;
5915   imageVisual.CreatePropertyMap(resultMap);
5916
5917   // Test property values: they should be updated
5918   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5919   DALI_TEST_CHECK(cornerRadiusValue);
5920   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5921
5922   TestShaderCodeContainSubstrings(
5923     dummyControl,
5924     {
5925       {"#define IS_REQUIRED_BORDERLINE", false},
5926       {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
5927     },
5928     TEST_LOCATION);
5929
5930   // Send shader compile signal
5931   application.SendNotification();
5932   application.Render();
5933
5934   callStack.Enable(false);
5935
5936   // Shader doesn't changed
5937   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5938   callStack.Reset();
5939   callStack.Enable(true);
5940
5941   float   targetBorderlineWidth  = 0.0f;
5942   Vector4 targetBorderlineColor  = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5943   float   targetBorderlineOffset = -1.0f;
5944
5945   Property::Map targetPropertyMap2;
5946   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]  = targetBorderlineWidth;
5947   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]  = targetBorderlineColor;
5948   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5949
5950   // Update Properties with Borderline
5951   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5952
5953   Property::Map resultMap2;
5954   imageVisual.CreatePropertyMap(resultMap2);
5955
5956   // Test property values: they should be updated
5957   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5958   DALI_TEST_CHECK(borderlineWidthValue);
5959   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5960
5961   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5962   DALI_TEST_CHECK(borderlineColorValue);
5963   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5964
5965   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5966   DALI_TEST_CHECK(borderlineOffsetValue);
5967   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5968
5969   TestShaderCodeContainSubstrings(
5970     dummyControl,
5971     {
5972       {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
5973       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5974     },
5975     TEST_LOCATION);
5976
5977   // Send shader compile signal
5978   application.SendNotification();
5979   application.Render();
5980
5981   callStack.Enable(false);
5982
5983   // Shader doesn't changed
5984   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5985
5986   END_TEST;
5987 }
5988
5989 int UtcDaliVisualUpdatePropertyChangeShader03(void)
5990 {
5991   ToolkitTestApplication application;
5992   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
5993
5994   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5995
5996   VisualFactory factory = VisualFactory::Get();
5997   Property::Map propertyMap;
5998   // Case ImageVisual
5999   propertyMap[Visual::Property::TYPE]           = Visual::Type::COLOR;
6000   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6001
6002   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6003
6004   DummyControl        dummyControl = DummyControl::New(true);
6005   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6006   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6007   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6008   application.GetScene().Add(dummyControl);
6009
6010   application.SendNotification();
6011   application.Render();
6012
6013   application.SendNotification();
6014   application.Render();
6015
6016   TestShaderCodeContainSubstrings(
6017     dummyControl,
6018     {
6019       {"#define IS_REQUIRED_BLUR", false},
6020       {"#define IS_REQUIRED_BORDERLINE", false},
6021       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6022     },
6023     TEST_LOCATION);
6024
6025   float   targetBlurRadius   = 15.0f;
6026   Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6027
6028   Property::Map targetPropertyMap;
6029   targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6030   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]    = targetCornerRadius;
6031   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6032
6033   callStack.Reset();
6034   callStack.Enable(true);
6035
6036   // Update Properties with CornerRadius
6037   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6038
6039   Property::Map resultMap;
6040   imageVisual.CreatePropertyMap(resultMap);
6041
6042   // Test property values: they should be updated
6043   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6044   DALI_TEST_CHECK(blurRadiusValue);
6045   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6046
6047   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6048   DALI_TEST_CHECK(cornerRadiusValue);
6049   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6050
6051   TestShaderCodeContainSubstrings(
6052     dummyControl,
6053     {
6054       {"#define IS_REQUIRED_BLUR", true},
6055       {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6056       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6057     },
6058     TEST_LOCATION);
6059
6060   // Send shader compile signal
6061   application.SendNotification();
6062   application.Render();
6063
6064   callStack.Enable(false);
6065
6066   // Shader changed
6067   DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6068   callStack.Reset();
6069   callStack.Enable(true);
6070
6071   Property::Map targetPropertyMap2;
6072   targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6073   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]    = Vector4::ZERO;
6074   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6075
6076   // Update Properties with CornerRadius
6077   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6078
6079   Property::Map resultMap2;
6080   imageVisual.CreatePropertyMap(resultMap2);
6081
6082   // Test property values: they should be updated
6083   blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6084   DALI_TEST_CHECK(blurRadiusValue);
6085   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6086
6087   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6088   DALI_TEST_CHECK(cornerRadiusValue);
6089   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6090
6091   TestShaderCodeContainSubstrings(
6092     dummyControl,
6093     {
6094       {"#define IS_REQUIRED_BLUR", true},           // Note : mAlwaysUsingBlurRadius is true.
6095       {"#define IS_REQUIRED_BORDERLINE", false},    // Note : We ignore borderline when blur radius occured
6096       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6097     },
6098     TEST_LOCATION);
6099
6100   // Send shader compile signal
6101   application.SendNotification();
6102   application.Render();
6103
6104   callStack.Enable(false);
6105
6106   // Shader not changed
6107   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6108
6109   END_TEST;
6110 }
6111
6112 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6113 {
6114   ToolkitTestApplication application;
6115   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6116
6117   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6118
6119   VisualFactory factory = VisualFactory::Get();
6120   Property::Map propertyMap;
6121   // Case ImageVisual
6122   propertyMap[Visual::Property::TYPE]               = Visual::Type::IMAGE;
6123   propertyMap[ImageVisual::Property::URL]           = TEST_IMAGE_FILE_NAME;
6124   propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6125
6126   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6127
6128   DummyControl        dummyControl = DummyControl::New(true);
6129   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6130   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6131   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6132   application.GetScene().Add(dummyControl);
6133
6134   application.SendNotification();
6135   application.Render();
6136
6137   // Wait for image loading
6138   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6139
6140   application.SendNotification();
6141   application.Render();
6142
6143   TestShaderCodeContainSubstrings(
6144     dummyControl,
6145     {
6146       {"#define IS_REQUIRED_BORDERLINE", false},
6147       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6148     },
6149     TEST_LOCATION);
6150
6151   callStack.Reset();
6152   callStack.Enable(true);
6153
6154   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6155
6156   Animation animation = Animation::New(1.0f);
6157   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6158   animation.Play();
6159
6160   application.SendNotification();
6161   application.Render();
6162   application.Render(1001u); // End of animation
6163
6164   TestShaderCodeContainSubstrings(
6165     dummyControl,
6166     {
6167       {"#define IS_REQUIRED_BORDERLINE", false},
6168       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6169     },
6170     TEST_LOCATION);
6171
6172   callStack.Enable(false);
6173   // Shader not changed
6174   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6175   callStack.Reset();
6176   callStack.Enable(true);
6177
6178   float         targetBorderlineWidth = 10.0f;
6179   Property::Map targetPropertyMap;
6180   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6181
6182   // Update Properties with CornerRadius
6183   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6184
6185   Property::Map resultMap;
6186   imageVisual.CreatePropertyMap(resultMap);
6187
6188   // Test property values: they should be updated
6189   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6190   DALI_TEST_CHECK(cornerRadiusValue);
6191   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6192
6193   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6194   DALI_TEST_CHECK(cornerRadiusPolicyValue);
6195   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6196
6197   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6198   DALI_TEST_CHECK(borderlineWidthValue);
6199   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6200
6201   TestShaderCodeContainSubstrings(
6202     dummyControl,
6203     {
6204       {"#define IS_REQUIRED_BORDERLINE", true},
6205       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6206     },
6207     TEST_LOCATION);
6208
6209   // Send shader compile signal
6210   application.SendNotification();
6211   application.Render();
6212
6213   callStack.Enable(false);
6214   // Shader changed
6215   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6216
6217   END_TEST;
6218 }