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

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