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

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