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