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

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