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     properties["synchronousLoading"]                        = false;
4186
4187     Visual::Base visual = factory.CreateVisual(properties);
4188
4189     // trigger creation through setting on stage
4190     DummyControl        dummy     = DummyControl::New(true);
4191     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4192     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4193
4194     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4195     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4196     application.GetScene().Add(dummy);
4197
4198     application.SendNotification();
4199     application.Render();
4200
4201     // Trigger count is 2 - load & render a frame
4202     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4203
4204     application.SendNotification();
4205     application.Render();
4206
4207     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4208     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4209   }
4210
4211   END_TEST;
4212 }
4213
4214 int UtcDaliVisualBorderline(void)
4215 {
4216   tet_infoline("UtcDaliVisualBorderline");
4217
4218   static std::vector<UniformData> customUniforms =
4219     {
4220       UniformData("cornerRadius", Property::Type::VECTOR4),
4221       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4222       UniformData("borderlineWidth", Property::Type::FLOAT),
4223       UniformData("borderlineColor", Property::Type::VECTOR4),
4224       UniformData("borderlineOffset", Property::Type::FLOAT),
4225     };
4226
4227   // image visual
4228   {
4229     ToolkitTestApplication  application;
4230     TestGraphicsController& graphics = application.GetGraphicsController();
4231     graphics.AddCustomUniforms(customUniforms);
4232
4233     VisualFactory factory = VisualFactory::Get();
4234     Property::Map properties;
4235     float         cornerRadius    = 5.0f;
4236     float         borderlineWidth = 30.0f;
4237     Vector4       borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4238     float         borderlineOffset = 1.0f;
4239
4240     properties[Visual::Property::TYPE]                   = Visual::IMAGE;
4241     properties[ImageVisual::Property::URL]               = TEST_IMAGE_FILE_NAME;
4242     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4243     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4244     properties[DevelVisual::Property::BORDERLINE_COLOR]  = borderlineColor;
4245     properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4246
4247     Visual::Base visual = factory.CreateVisual(properties);
4248
4249     // trigger creation through setting on stage
4250     DummyControl        dummy     = DummyControl::New(true);
4251     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4252     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4253
4254     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4255     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4256     application.GetScene().Add(dummy);
4257
4258     application.SendNotification();
4259     application.Render();
4260
4261     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4262
4263     application.SendNotification();
4264     application.Render();
4265
4266     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4267     // Default corner radius policy is absolute.
4268     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4269     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4270     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4271     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4272   }
4273
4274   // color visual 1
4275   {
4276     ToolkitTestApplication  application;
4277     TestGraphicsController& graphics = application.GetGraphicsController();
4278     graphics.AddCustomUniforms(customUniforms);
4279
4280     VisualFactory factory = VisualFactory::Get();
4281     Property::Map properties;
4282     Vector4       cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4283     float         borderlineWidth = 30.0f;
4284     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4285     float         borderlineOffset = -0.4f;
4286
4287     properties[Visual::Property::TYPE]           = Visual::COLOR;
4288     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4289     properties["cornerRadius"]                   = cornerRadius;
4290     properties["borderlineWidth"]                = borderlineWidth;
4291     properties["borderlineColor"]                = borderlineColor;
4292     properties["borderlineOffset"]               = borderlineOffset;
4293
4294     Visual::Base visual = factory.CreateVisual(properties);
4295
4296     // trigger creation through setting on stage
4297     DummyControl        dummy     = DummyControl::New(true);
4298     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4299     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4300
4301     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4302     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4303     application.GetScene().Add(dummy);
4304
4305     application.SendNotification();
4306     application.Render();
4307
4308     application.SendNotification();
4309     application.Render();
4310
4311     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4312     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4313     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4314     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4315   }
4316
4317   // color visual 2, default color, default offset
4318   {
4319     ToolkitTestApplication  application;
4320     TestGraphicsController& graphics = application.GetGraphicsController();
4321     graphics.AddCustomUniforms(customUniforms);
4322
4323     VisualFactory factory = VisualFactory::Get();
4324     Property::Map properties;
4325     float         borderlineWidth = 30.0f;
4326
4327     properties[Visual::Property::TYPE]                  = Visual::COLOR;
4328     properties[ColorVisual::Property::MIX_COLOR]        = Color::BLUE;
4329     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4330
4331     Visual::Base visual = factory.CreateVisual(properties);
4332
4333     // trigger creation through setting on stage
4334     DummyControl        dummy     = DummyControl::New(true);
4335     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4336     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4337
4338     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4339     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4340     application.GetScene().Add(dummy);
4341
4342     application.SendNotification();
4343     application.Render();
4344
4345     application.SendNotification();
4346     application.Render();
4347
4348     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4349     // Default borderline color is BLACK.
4350     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4351     // Default borderline offset is 0.0f.
4352     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4353   }
4354
4355   // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4356   {
4357     ToolkitTestApplication  application;
4358     TestGraphicsController& graphics = application.GetGraphicsController();
4359     graphics.AddCustomUniforms(customUniforms);
4360
4361     VisualFactory factory = VisualFactory::Get();
4362     Property::Map properties;
4363     float         borderlineWidth = 30.0f;
4364     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4365     float         borderlineOffset = 37.4f;
4366
4367     properties[Visual::Property::TYPE]           = Visual::COLOR;
4368     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4369     properties["borderlineWidth"]                = borderlineWidth;
4370     properties["borderlineColor"]                = borderlineColor;
4371     properties["borderlineOffset"]               = borderlineOffset;
4372
4373     Visual::Base visual = factory.CreateVisual(properties);
4374
4375     // trigger creation through setting on stage
4376     DummyControl        dummy     = DummyControl::New(true);
4377     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4378     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4379
4380     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4381     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4382     application.GetScene().Add(dummy);
4383
4384     application.SendNotification();
4385     application.Render();
4386
4387     application.SendNotification();
4388     application.Render();
4389
4390     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4391     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4392     // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4393     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4394   }
4395
4396   // gradient visual
4397   {
4398     ToolkitTestApplication  application;
4399     TestGraphicsController& graphics = application.GetGraphicsController();
4400     graphics.AddCustomUniforms(customUniforms);
4401
4402     VisualFactory factory = VisualFactory::Get();
4403     Property::Map properties;
4404     float         borderlineWidth = 30.0f;
4405     float         cornerRadius    = 70.0f;
4406
4407     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4408     properties[ColorVisual::Property::MIX_COLOR]         = Color::BLUE;
4409     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4410     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4411     properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4412     properties[GradientVisual::Property::END_POSITION]   = Vector2(-0.5f, -0.5f);
4413     properties[GradientVisual::Property::UNITS]          = GradientVisual::Units::USER_SPACE;
4414
4415     Property::Array stopOffsets;
4416     stopOffsets.PushBack(0.0f);
4417     stopOffsets.PushBack(0.6f);
4418     stopOffsets.PushBack(1.0f);
4419     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4420
4421     Property::Array stopColors;
4422     stopColors.PushBack(Color::RED);
4423     stopColors.PushBack(Color::YELLOW);
4424     stopColors.PushBack(Color::GREEN);
4425     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4426
4427     Visual::Base visual = factory.CreateVisual(properties);
4428
4429     // trigger creation through setting on stage
4430     DummyControl        dummy     = DummyControl::New(true);
4431     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4432     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4433
4434     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4435     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4436     application.GetScene().Add(dummy);
4437
4438     application.SendNotification();
4439     application.Render();
4440
4441     application.SendNotification();
4442     application.Render();
4443
4444     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4445     // Default corner radius policy is absolute.
4446     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4447     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4448     // Default borderline color is BLACK.
4449     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4450     // Default borderline offset is 0.0f.
4451     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4452   }
4453
4454   // animated image visual
4455   {
4456     ToolkitTestApplication  application;
4457     TestGraphicsController& graphics = application.GetGraphicsController();
4458     graphics.AddCustomUniforms(customUniforms);
4459
4460     VisualFactory factory = VisualFactory::Get();
4461     Property::Map properties;
4462     float         borderlineWidth  = 24.0f;
4463     float         borderlineOffset = -1.0f;
4464
4465     properties[Visual::Property::TYPE]                  = Visual::ANIMATED_IMAGE;
4466     properties[ImageVisual::Property::URL]              = TEST_GIF_FILE_NAME;
4467     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4468     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4469     properties["borderlineOffset"]                      = borderlineOffset;
4470
4471     Visual::Base visual = factory.CreateVisual(properties);
4472
4473     // trigger creation through setting on stage
4474     DummyControl        dummy     = DummyControl::New(true);
4475     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4476     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4477
4478     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4479     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4480     application.GetScene().Add(dummy);
4481
4482     application.SendNotification();
4483     application.Render();
4484
4485     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4486
4487     application.SendNotification();
4488     application.Render();
4489
4490     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4491     // Default borderline color is BLACK.
4492     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4493     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4494   }
4495
4496   // vector image visual
4497   {
4498     ToolkitTestApplication  application;
4499     TestGraphicsController& graphics = application.GetGraphicsController();
4500     graphics.AddCustomUniforms(customUniforms);
4501
4502     VisualFactory factory = VisualFactory::Get();
4503     Property::Map properties;
4504     Vector4       cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4505     float         borderlineWidth = 27.0f;
4506     Vector4       borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4507
4508     properties[Visual::Property::TYPE]                  = Visual::SVG;
4509     properties[ImageVisual::Property::URL]              = TEST_SVG_FILE_NAME;
4510     properties[DevelVisual::Property::CORNER_RADIUS]    = cornerRadius;
4511     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4512     properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4513
4514     Visual::Base visual = factory.CreateVisual(properties);
4515
4516     // trigger creation through setting on stage
4517     DummyControl        dummy     = DummyControl::New(true);
4518     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4519     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4520
4521     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4522     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4523     application.GetScene().Add(dummy);
4524
4525     application.SendNotification();
4526     application.Render();
4527
4528     // Wait for loading & rasterization
4529     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4530
4531     application.SendNotification();
4532     application.Render();
4533
4534     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4535     // Default corner radius policy is absolute.
4536     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4537     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4538     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4539     // Default borderline offset is 0.0.
4540     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4541   }
4542
4543   // animated vector image visual
4544   {
4545     ToolkitTestApplication  application;
4546     TestGraphicsController& graphics = application.GetGraphicsController();
4547     graphics.AddCustomUniforms(customUniforms);
4548
4549     VisualFactory factory = VisualFactory::Get();
4550     Property::Map properties;
4551     Vector4       cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4552     float         borderlineWidth = 13.0f;
4553     Vector4       borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4554     float         borderlineOffset = 13.0f;
4555
4556     properties[Visual::Property::TYPE]                      = DevelVisual::ANIMATED_VECTOR_IMAGE;
4557     properties[ImageVisual::Property::URL]                  = TEST_VECTOR_IMAGE_FILE_NAME;
4558     properties["cornerRadius"]                              = cornerRadius;
4559     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4560     properties[DevelVisual::Property::BORDERLINE_WIDTH]     = borderlineWidth;
4561     properties["borderlineColor"]                           = borderlineColor;
4562     properties[DevelVisual::Property::BORDERLINE_OFFSET]    = borderlineOffset;
4563     properties[ImageVisual::Property::SYNCHRONOUS_LOADING]  = false;
4564
4565     Visual::Base visual = factory.CreateVisual(properties);
4566
4567     // trigger creation through setting on stage
4568     DummyControl        dummy     = DummyControl::New(true);
4569     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4570     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4571
4572     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4573     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4574     application.GetScene().Add(dummy);
4575
4576     application.SendNotification();
4577     application.Render();
4578
4579     // Trigger count is 2 - load & render a frame
4580     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4581
4582     application.SendNotification();
4583     application.Render();
4584
4585     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4586     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4587     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4588     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4589     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4590   }
4591
4592   END_TEST;
4593 }
4594
4595 int UtcDaliVisualBorderlineBlendModeTest(void)
4596 {
4597   ToolkitTestApplication application;
4598   tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4599   VisualFactory factory = VisualFactory::Get();
4600
4601   // Case 1 : Test which doesn't support borderline feature.
4602   {
4603     tet_printf("Test Unsupported visual type\n");
4604     Property::Map propertyMap;
4605     propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4606     propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4607     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4608     Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4609
4610     DummyControl        actor     = DummyControl::New(true);
4611     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4612     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4613     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4614     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4615     application.GetScene().Add(actor);
4616
4617     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4618
4619     Renderer renderer = actor.GetRendererAt(0);
4620
4621     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4622     // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4623     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4624
4625     application.GetScene().Remove(actor);
4626   }
4627
4628   // Case 2 : Test which support borderline feature.
4629   {
4630     tet_printf("Test normal case\n");
4631     Property::Map propertyMap;
4632     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4633     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4634     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4635     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4636
4637     DummyControl        actor     = DummyControl::New(true);
4638     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4639     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4640     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4641     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4642     application.GetScene().Add(actor);
4643
4644     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4645
4646     Renderer renderer = actor.GetRendererAt(0);
4647
4648     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4649     // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4650     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4651
4652     application.GetScene().Remove(actor);
4653   }
4654
4655   // Case 3 : Test which animated borderline.
4656   {
4657     tet_printf("Test borderline animate case\n");
4658     Property::Map propertyMap;
4659     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4660     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4661     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4662
4663     DummyControl        actor     = DummyControl::New(true);
4664     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4665     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4666     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4667     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4668     application.GetScene().Add(actor);
4669
4670     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4671
4672     Renderer renderer = actor.GetRendererAt(0);
4673
4674     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4675     // BlendMode is AUTO.
4676     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4677
4678     Animation animation = Animation::New(0.1f);
4679     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4680     animation.Play();
4681
4682     application.SendNotification();
4683     application.Render();
4684     application.Render(101u); // End of animation
4685
4686     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4687     // BlendMode is ON_WITHOUT_CULL.
4688     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4689
4690     Animation revanimation = Animation::New(0.1f);
4691     revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4692     revanimation.Play();
4693
4694     application.SendNotification();
4695     application.Render();
4696     application.Render(101u); // End of animation
4697
4698     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4699     // BlendMode is still ON_WITHOUT_CULL.
4700     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4701
4702     application.GetScene().Remove(actor);
4703   }
4704
4705   // Case 4 : Test which animated corner radius occur.
4706   {
4707     tet_printf("Test borderline animate case\n");
4708     Property::Map propertyMap;
4709     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4710     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4711     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4712     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4713
4714     DummyControl        actor     = DummyControl::New(true);
4715     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4716     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4717     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4718     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4719     application.GetScene().Add(actor);
4720
4721     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4722
4723     Renderer renderer = actor.GetRendererAt(0);
4724
4725     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4726     // BlendMode is ON_WITHOUT_CULL.
4727     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4728
4729     Animation animation = Animation::New(0.1f);
4730     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4731     animation.Play();
4732
4733     application.SendNotification();
4734     application.Render();
4735     application.Render(101u); // End of animation
4736
4737     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4738     // BlendMode is ON_WITHOUT_CULL.
4739     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4740
4741     application.GetScene().Remove(actor);
4742   }
4743
4744   END_TEST;
4745 }
4746
4747 int UtcDaliVisualBorderlineColorAnimateTest(void)
4748 {
4749   ToolkitTestApplication application;
4750   tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4751
4752   TestGraphicsController&         graphics = application.GetGraphicsController();
4753   static std::vector<UniformData> customUniforms =
4754     {
4755       UniformData("mixColor", Property::Type::VECTOR3),
4756       UniformData("cornerRadius", Property::Type::VECTOR4),
4757       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4758       UniformData("borderlineWidth", Property::Type::FLOAT),
4759       UniformData("borderlineColor", Property::Type::VECTOR4),
4760       UniformData("borderlineOffset", Property::Type::FLOAT),
4761     };
4762   graphics.AddCustomUniforms(customUniforms);
4763
4764   {
4765     const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4766     const float   INITIAL_MIX_OPACITY(0.5f);
4767     const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4768     const float   INITIAL_ACTOR_OPACITY(1.0f);
4769     const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4770     const float   TARGET_MIX_OPACITY(0.8f);
4771     const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4772     const float   TARGET_ACTOR_OPACITY(0.5f);
4773
4774     VisualFactory factory = VisualFactory::Get();
4775     Property::Map propertyMap;
4776     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4777     propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4778     propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4779     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4780     propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4781     Visual::Base visual = factory.CreateVisual(propertyMap);
4782
4783     DummyControl        actor     = DummyControl::New(true);
4784     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4785     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4786     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4787     actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4788     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4789     application.GetScene().Add(actor);
4790
4791     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4792
4793     Animation animation = Animation::New(4.0f);
4794     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4795     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4796     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4797     animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4798     animation.Play();
4799
4800     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4801
4802     application.SendNotification();
4803     application.Render(0);
4804     application.Render(2000u); // halfway point
4805     application.SendNotification();
4806
4807     Vector3 halfwayMixColor        = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4808     float   halfwayMixOpacity      = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4809     Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4810     float   halfwayActorOpacity    = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4811     halfwayMixOpacity *= halfwayActorOpacity;
4812     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4813     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4814     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4815     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4816
4817     application.Render(2001u);      // go past end
4818     application.SendNotification(); // Trigger signals
4819
4820     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4821     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4822     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4823     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4824     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4825
4826     actor.Unparent();
4827   }
4828
4829   END_TEST;
4830 }
4831
4832 int UtcDaliColorVisualBlurRadius(void)
4833 {
4834   ToolkitTestApplication application;
4835   tet_infoline("UtcDaliColorVisualBlurRadius");
4836
4837   static std::vector<UniformData> customUniforms =
4838     {
4839       UniformData("blurRadius", Property::Type::FLOAT),
4840     };
4841
4842   TestGraphicsController& graphics = application.GetGraphicsController();
4843   graphics.AddCustomUniforms(customUniforms);
4844
4845   VisualFactory factory = VisualFactory::Get();
4846   Property::Map properties;
4847   float         blurRadius = 20.0f;
4848
4849   properties[Visual::Property::TYPE]           = Visual::COLOR;
4850   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4851   properties["blurRadius"]                     = blurRadius;
4852
4853   Visual::Base visual = factory.CreateVisual(properties);
4854
4855   // trigger creation through setting on stage
4856   DummyControl        dummy     = DummyControl::New(true);
4857   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4858   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4859
4860   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4861   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4862   application.GetScene().Add(dummy);
4863
4864   application.SendNotification();
4865   application.Render();
4866
4867   application.SendNotification();
4868   application.Render();
4869
4870   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4871
4872   END_TEST;
4873 }
4874
4875 int UtcDaliVisualGetType(void)
4876 {
4877   ToolkitTestApplication application;
4878   tet_infoline("UtcDaliVisualGetType");
4879
4880   VisualFactory factory = VisualFactory::Get();
4881
4882   {
4883     Property::Map properties;
4884     properties[Visual::Property::TYPE] = Visual::BORDER;
4885     Visual::Base visual                = factory.CreateVisual(properties);
4886
4887     DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4888   }
4889
4890   {
4891     Property::Map properties;
4892     properties[Visual::Property::TYPE] = Visual::COLOR;
4893     Visual::Base visual                = factory.CreateVisual(properties);
4894
4895     DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4896   }
4897
4898   {
4899     Property::Map properties;
4900     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4901     properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4902     properties[GradientVisual::Property::END_POSITION]   = Vector2(1.f, 1.f);
4903     properties[GradientVisual::Property::STOP_OFFSET]    = Vector2(0.f, 1.f);
4904     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4905     Property::Array stopColors;
4906     stopColors.PushBack(Color::RED);
4907     stopColors.PushBack(Color::GREEN);
4908     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4909     Visual::Base visual                              = factory.CreateVisual(properties);
4910
4911     DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4912   }
4913
4914   {
4915     Property::Map properties;
4916     properties[Visual::Property::TYPE] = Visual::IMAGE;
4917     properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4918     Visual::Base visual = factory.CreateVisual(properties);
4919
4920     DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4921   }
4922
4923   {
4924     Property::Map properties;
4925     properties[Visual::Property::TYPE] = Visual::MESH;
4926     Visual::Base visual                = factory.CreateVisual(properties);
4927
4928     DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4929   }
4930
4931   {
4932     Property::Map properties;
4933     properties[Visual::Property::TYPE]           = Visual::PRIMITIVE;
4934     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4935     Visual::Base visual                          = factory.CreateVisual(properties);
4936
4937     DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4938   }
4939
4940   {
4941     Property::Map properties;
4942     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4943     Visual::Base visual                = factory.CreateVisual(properties);
4944
4945     DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4946   }
4947
4948   {
4949     Property::Map properties;
4950     properties[Visual::Property::TYPE] = Visual::TEXT;
4951     Visual::Base visual                = factory.CreateVisual(properties);
4952
4953     DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4954   }
4955
4956   {
4957     Property::Map properties;
4958     properties[Visual::Property::TYPE]     = Visual::N_PATCH;
4959     properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4960     Visual::Base visual                    = factory.CreateVisual(properties);
4961
4962     DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4963   }
4964
4965   {
4966     Property::Map properties;
4967     properties[Visual::Property::TYPE]     = Visual::SVG;
4968     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4969     Visual::Base visual                    = factory.CreateVisual(properties);
4970
4971     DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4972   }
4973
4974   {
4975     Property::Map properties;
4976     properties[Visual::Property::TYPE]     = Visual::ANIMATED_IMAGE;
4977     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4978     Visual::Base visual                    = factory.CreateVisual(properties);
4979
4980     DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4981   }
4982
4983   {
4984     Property::Map properties;
4985     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4986     Visual::Base visual                = factory.CreateVisual(properties);
4987
4988     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4989   }
4990
4991   {
4992     Property::Map properties;
4993     properties[Visual::Property::TYPE]     = DevelVisual::ANIMATED_VECTOR_IMAGE;
4994     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4995     Visual::Base visual                    = factory.CreateVisual(properties);
4996
4997     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4998   }
4999
5000   {
5001     Property::Map properties;
5002     properties[Visual::Property::TYPE] = DevelVisual::ARC;
5003     Visual::Base visual                = factory.CreateVisual(properties);
5004
5005     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
5006   }
5007
5008   END_TEST;
5009 }
5010
5011 int UtcDaliVisualGetVisualProperty01(void)
5012 {
5013   ToolkitTestApplication application;
5014   tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
5015
5016   static std::vector<UniformData> customUniforms =
5017     {
5018       UniformData("mixColor", Property::Type::VECTOR3),
5019       UniformData("offset", Property::Type::VECTOR2),
5020       UniformData("size", Property::Type::VECTOR2),
5021       UniformData("cornerRadius", Property::Type::VECTOR4),
5022       UniformData("blurRadius", Property::Type::FLOAT),
5023       UniformData("borderlineWidth", Property::Type::FLOAT),
5024       UniformData("borderlineColor", Property::Type::VECTOR4),
5025       UniformData("borderlineOffset", Property::Type::FLOAT)};
5026
5027   TestGraphicsController& graphics = application.GetGraphicsController();
5028   graphics.AddCustomUniforms(customUniforms);
5029
5030   VisualFactory factory = VisualFactory::Get();
5031   Property::Map propertyMap;
5032   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5033   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
5034   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
5035   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
5036   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
5037   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
5038   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
5039   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
5040   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5041
5042   DummyControl        dummyControl = DummyControl::New(true);
5043   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5044   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5045   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5046   application.GetScene().Add(dummyControl);
5047
5048   application.SendNotification();
5049   application.Render();
5050
5051   Vector3 targetColor(1.0f, 1.0f, 1.0f);
5052   Vector2 targetOffset(0.05f, 0.05f);
5053   Vector2 targetSize(1.1f, 1.1f);
5054   float   targetOpacity = 0.5f;
5055   Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
5056   float   targetBlurRadius      = 10.0f;
5057   float   targetBorderlineWidth = 25.0f;
5058   Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
5059   float   targetBorderlineOffset = -1.0f;
5060
5061   Animation animation = Animation::New(1.0f);
5062   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
5063   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5064   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
5065   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
5066   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5067   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
5068   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5069   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5070   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5071   animation.Play();
5072
5073   application.SendNotification();
5074   application.Render();
5075   application.Render(1001u); // End of animation
5076
5077   Property::Map resultMap;
5078   colorVisual.CreatePropertyMap(resultMap);
5079
5080   // Test property values: they should be updated
5081   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5082   DALI_TEST_CHECK(colorValue);
5083   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5084
5085   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5086   Dali::Property::Map* transformMap   = transformValue->GetMap();
5087   DALI_TEST_CHECK(transformMap);
5088
5089   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5090   DALI_TEST_CHECK(offsetValue);
5091   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5092
5093   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5094   DALI_TEST_CHECK(sizeValue);
5095   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5096
5097   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5098   DALI_TEST_CHECK(cornerRadiusValue);
5099   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5100
5101   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5102   DALI_TEST_CHECK(blurRadiusValue);
5103   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5104
5105   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5106   DALI_TEST_CHECK(borderlineWidthValue);
5107   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5108
5109   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5110   DALI_TEST_CHECK(borderlineColorValue);
5111   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5112
5113   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5114   DALI_TEST_CHECK(borderlineOffsetValue);
5115   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5116
5117   // Test uniform values
5118   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5119   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5120   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5121   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5122   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5123   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5124   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5125   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5126
5127   // Test unregistered visual
5128   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
5129   DALI_TEST_CHECK(!property3.object);
5130   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
5131
5132   END_TEST;
5133 }
5134
5135 int UtcDaliVisualGetVisualProperty02(void)
5136 {
5137   ToolkitTestApplication application;
5138   tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
5139
5140   static std::vector<UniformData> customUniforms =
5141     {
5142       UniformData("mixColor", Property::Type::VECTOR3),
5143       UniformData("offset", Property::Type::VECTOR2),
5144       UniformData("size", Property::Type::VECTOR2),
5145       UniformData("cornerRadius", Property::Type::VECTOR4),
5146       UniformData("borderlineWidth", Property::Type::FLOAT),
5147       UniformData("borderlineCOlor", Property::Type::VECTOR4),
5148       UniformData("borderlineOffset", Property::Type::FLOAT),
5149       UniformData("blurRadius", Property::Type::FLOAT),
5150     };
5151
5152   TestGraphicsController& graphics = application.GetGraphicsController();
5153   graphics.AddCustomUniforms(customUniforms);
5154
5155   VisualFactory factory = VisualFactory::Get();
5156   Property::Map propertyMap;
5157   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5158   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5159
5160   DummyControl        dummyControl = DummyControl::New(true);
5161   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5162   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5163   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5164   application.GetScene().Add(dummyControl);
5165
5166   application.SendNotification();
5167   application.Render();
5168
5169   Vector3 targetColor(1.0f, 1.0f, 1.0f);
5170   Vector2 targetOffset(0.05f, 0.05f);
5171   Vector2 targetSize(1.1f, 1.1f);
5172   float   targetOpacity = 0.5f;
5173   Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5174   float   targetBorderlineWidth = 77.7f;
5175   Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5176   float   targetBorderlineOffset = 1.0f;
5177   float   targetBlurRadius       = 10.0f;
5178
5179   // Should work when the properties are not set before
5180   Animation animation = Animation::New(1.0f);
5181   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5182   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5183   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5184   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5185   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5186   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5187   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5188   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5189   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5190   animation.Play();
5191
5192   application.SendNotification();
5193   application.Render();
5194   application.Render(1001u); // End of animation
5195
5196   Property::Map resultMap;
5197   colorVisual.CreatePropertyMap(resultMap);
5198
5199   // Test property values: they should be updated
5200   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5201   DALI_TEST_CHECK(colorValue);
5202   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5203
5204   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5205   Dali::Property::Map* transformMap   = transformValue->GetMap();
5206   DALI_TEST_CHECK(transformMap);
5207
5208   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5209   DALI_TEST_CHECK(offsetValue);
5210   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5211
5212   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5213   DALI_TEST_CHECK(sizeValue);
5214   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5215
5216   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5217   DALI_TEST_CHECK(cornerRadiusValue);
5218   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5219
5220   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5221   DALI_TEST_CHECK(borderlineWidthValue);
5222   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5223
5224   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5225   DALI_TEST_CHECK(borderlineColorValue);
5226   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5227
5228   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5229   DALI_TEST_CHECK(borderlineOffsetValue);
5230   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5231
5232   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5233   DALI_TEST_CHECK(blurRadiusValue);
5234   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5235
5236   // Test uniform values
5237   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5238   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5239   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5240   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5241   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5242
5243   END_TEST;
5244 }
5245
5246 int UtcDaliVisualGetVisualProperty03(void)
5247 {
5248   ToolkitTestApplication application;
5249   tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5250
5251   static std::vector<UniformData> customUniforms =
5252     {
5253       UniformData("cornerRadius", Property::Type::VECTOR4),
5254       UniformData("borderlineWidth", Property::Type::FLOAT),
5255       UniformData("borderlineColor", Property::Type::VECTOR4),
5256       UniformData("borderlineOffset", Property::Type::FLOAT),
5257     };
5258
5259   TestGraphicsController& graphics = application.GetGraphicsController();
5260   graphics.AddCustomUniforms(customUniforms);
5261
5262   VisualFactory factory = VisualFactory::Get();
5263   Property::Map propertyMap;
5264   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5265   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5266
5267   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5268
5269   DummyControl        dummyControl = DummyControl::New(true);
5270   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5271   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5272   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5273   application.GetScene().Add(dummyControl);
5274
5275   // Wait for image loading
5276   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5277
5278   application.SendNotification();
5279   application.Render();
5280
5281   float   targetOpacity = 0.5f;
5282   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5283   float   targetBorderlineWidth = 10.0f;
5284   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5285   float   targetBorderlineOffset = -1.5f;
5286
5287   Animation animation = Animation::New(1.0f);
5288   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5289   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5290   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5291   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5292   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5293   animation.Play();
5294
5295   application.SendNotification();
5296   application.Render();
5297   application.Render(1001u); // End of animation
5298
5299   Property::Map resultMap;
5300   imageVisual.CreatePropertyMap(resultMap);
5301
5302   // Test property values: they should be updated
5303   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5304   DALI_TEST_CHECK(colorValue);
5305   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5306
5307   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5308   DALI_TEST_CHECK(cornerRadiusValue);
5309   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5310
5311   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5312   DALI_TEST_CHECK(borderlineWidthValue);
5313   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5314
5315   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5316   DALI_TEST_CHECK(borderlineColorValue);
5317   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5318
5319   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5320   DALI_TEST_CHECK(borderlineOffsetValue);
5321   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5322
5323   // Test uniform value
5324   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5325   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5326   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5327   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5328
5329   END_TEST;
5330 }
5331
5332 int UtcDaliVisualGetVisualProperty04(void)
5333 {
5334   ToolkitTestApplication application;
5335   tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5336
5337   static std::vector<UniformData> customUniforms =
5338     {
5339       UniformData("cornerRadius", Property::Type::VECTOR4),
5340     };
5341
5342   TestGraphicsController& graphics = application.GetGraphicsController();
5343   graphics.AddCustomUniforms(customUniforms);
5344
5345   Vector2         start(-1.f, -1.f);
5346   Vector2         end(1.f, 1.f);
5347   Property::Array stopColors;
5348   stopColors.PushBack(Color::RED);
5349   stopColors.PushBack(Color::GREEN);
5350
5351   VisualFactory factory = VisualFactory::Get();
5352   Property::Map propertyMap;
5353   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5354   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5355   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5356   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5357   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5358   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5359   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5360
5361   DummyControl        dummyControl = DummyControl::New(true);
5362   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5363   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5364   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5365   application.GetScene().Add(dummyControl);
5366
5367   application.SendNotification();
5368   application.Render();
5369
5370   float   targetOpacity = 0.5f;
5371   Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5372
5373   Animation animation = Animation::New(1.0f);
5374   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5375   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5376   animation.Play();
5377
5378   application.SendNotification();
5379   application.Render();
5380   application.Render(1001u); // End of animation
5381
5382   Property::Map resultMap;
5383   gradientVisual.CreatePropertyMap(resultMap);
5384
5385   // Test property values: they should be updated
5386   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5387   DALI_TEST_CHECK(colorValue);
5388   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5389
5390   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5391   DALI_TEST_CHECK(cornerRadiusValue);
5392   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5393
5394   // Test uniform value
5395   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5396
5397   END_TEST;
5398 }
5399
5400 int UtcDaliVisualGetVisualProperty05(void)
5401 {
5402   ToolkitTestApplication application;
5403   tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5404
5405   static std::vector<UniformData> customUniforms =
5406     {
5407       UniformData("cornerRadius", Property::Type::VECTOR4),
5408       UniformData("borderlineWidth", Property::Type::FLOAT),
5409       UniformData("borderlineColor", Property::Type::VECTOR4),
5410       UniformData("borderlineOffset", Property::Type::FLOAT),
5411     };
5412
5413   TestGraphicsController& graphics = application.GetGraphicsController();
5414   graphics.AddCustomUniforms(customUniforms);
5415
5416   VisualFactory factory = VisualFactory::Get();
5417   Property::Map propertyMap;
5418   propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5419   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5420
5421   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5422
5423   DummyControl        dummyControl = DummyControl::New(true);
5424   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5425   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5426   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5427   application.GetScene().Add(dummyControl);
5428
5429   application.SendNotification();
5430   application.Render();
5431
5432   // Wait for loading & rasterization
5433   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5434
5435   application.SendNotification();
5436   application.Render();
5437
5438   float   targetOpacity = 0.5f;
5439   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5440   float   targetBorderlineWidth = 10.0f;
5441   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5442   float   targetBorderlineOffset = -1.5f;
5443
5444   Animation animation = Animation::New(1.0f);
5445   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5446   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5447   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5448   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5449   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5450   animation.Play();
5451
5452   application.SendNotification();
5453   application.Render();
5454   application.Render(1001u); // End of animation
5455
5456   Property::Map resultMap;
5457   svgVisual.CreatePropertyMap(resultMap);
5458
5459   // Test property values: they should be updated
5460   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5461   DALI_TEST_CHECK(colorValue);
5462   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5463
5464   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5465   DALI_TEST_CHECK(cornerRadiusValue);
5466   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5467
5468   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5469   DALI_TEST_CHECK(borderlineWidthValue);
5470   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5471
5472   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5473   DALI_TEST_CHECK(borderlineColorValue);
5474   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5475
5476   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5477   DALI_TEST_CHECK(borderlineOffsetValue);
5478   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5479
5480   // Currently test with multiple program doesn't work well. will fix another day
5481   // Test uniform value
5482   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5483   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5484   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5485   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5486
5487   END_TEST;
5488 }
5489
5490 int UtcDaliVisualGetVisualProperty06(void)
5491 {
5492   ToolkitTestApplication application;
5493   tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5494
5495   static std::vector<UniformData> customUniforms =
5496     {
5497       UniformData("cornerRadius", Property::Type::VECTOR4),
5498       UniformData("borderlineWidth", Property::Type::FLOAT),
5499       UniformData("borderlineColor", Property::Type::VECTOR4),
5500       UniformData("borderlineOffset", Property::Type::FLOAT),
5501     };
5502
5503   TestGraphicsController& graphics = application.GetGraphicsController();
5504   graphics.AddCustomUniforms(customUniforms);
5505
5506   VisualFactory factory = VisualFactory::Get();
5507   Property::Map propertyMap;
5508   propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5509   propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5510
5511   Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5512
5513   DummyControl        dummyControl = DummyControl::New(true);
5514   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5515   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5516   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5517   application.GetScene().Add(dummyControl);
5518
5519   application.SendNotification();
5520   application.Render();
5521
5522   // Wait for image loading
5523   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5524
5525   application.SendNotification();
5526   application.Render();
5527
5528   float   targetOpacity = 0.5f;
5529   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5530   float   targetBorderlineWidth = 10.0f;
5531   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5532   float   targetBorderlineOffset = -1.5f;
5533
5534   Animation animation = Animation::New(1.0f);
5535   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5536   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5537   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5538   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5539   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5540   animation.Play();
5541
5542   application.SendNotification();
5543   application.Render();
5544   application.Render(1001u); // End of animation
5545
5546   Property::Map resultMap;
5547   animatedImageVisual.CreatePropertyMap(resultMap);
5548
5549   // Test property values: they should be updated
5550   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5551   DALI_TEST_CHECK(colorValue);
5552   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5553
5554   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5555   DALI_TEST_CHECK(cornerRadiusValue);
5556   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5557
5558   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5559   DALI_TEST_CHECK(borderlineWidthValue);
5560   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5561
5562   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5563   DALI_TEST_CHECK(borderlineColorValue);
5564   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5565
5566   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5567   DALI_TEST_CHECK(borderlineOffsetValue);
5568   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5569
5570   // Currently test with multiple program doesn't work well. will fix another day
5571   // Test uniform value
5572   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5573   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5574   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5575   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5576
5577   END_TEST;
5578 }
5579
5580 int UtcDaliVisualGetVisualProperty07(void)
5581 {
5582   ToolkitTestApplication application;
5583   tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5584
5585   static std::vector<UniformData> customUniforms =
5586     {
5587       UniformData("cornerRadius", Property::Type::VECTOR4),
5588       UniformData("borderlineWidth", Property::Type::FLOAT),
5589       UniformData("borderlineColor", Property::Type::VECTOR4),
5590       UniformData("borderlineOffset", Property::Type::FLOAT),
5591     };
5592
5593   TestGraphicsController& graphics = application.GetGraphicsController();
5594   graphics.AddCustomUniforms(customUniforms);
5595
5596   VisualFactory factory = VisualFactory::Get();
5597   Property::Map propertyMap;
5598   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5599   propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5600   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, false);
5601
5602   Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5603
5604   DummyControl        dummyControl = DummyControl::New(true);
5605   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5606   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5607   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5608   application.GetScene().Add(dummyControl);
5609
5610   application.SendNotification();
5611   application.Render();
5612
5613   // Trigger count is 2 - load & render a frame
5614   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5615
5616   application.SendNotification();
5617   application.Render();
5618
5619   float   targetOpacity = 0.5f;
5620   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5621   float   targetBorderlineWidth = 10.0f;
5622   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5623   float   targetBorderlineOffset = -1.5f;
5624
5625   Animation animation = Animation::New(1.0f);
5626   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5627   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5628   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5629   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5630   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5631   animation.Play();
5632
5633   application.SendNotification();
5634   application.Render();
5635   application.Render(1001u); // End of animation
5636
5637   Property::Map resultMap;
5638   animatedVectorVisual.CreatePropertyMap(resultMap);
5639
5640   // Test property values: they should be updated
5641   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5642   DALI_TEST_CHECK(colorValue);
5643   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5644
5645   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5646   DALI_TEST_CHECK(cornerRadiusValue);
5647   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5648
5649   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5650   DALI_TEST_CHECK(borderlineWidthValue);
5651   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5652
5653   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5654   DALI_TEST_CHECK(borderlineColorValue);
5655   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5656
5657   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5658   DALI_TEST_CHECK(borderlineOffsetValue);
5659   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5660
5661   // Currently test with multiple program doesn't work well. will fix another day
5662   // Test uniform value
5663   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5664   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5665   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5666   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5667
5668   END_TEST;
5669 }
5670
5671 int UtcDaliVisualUpdateProperty01(void)
5672 {
5673   ToolkitTestApplication application;
5674   tet_infoline("UtcDaliVisualUpdateProperty01: Test update property by DoAction. Standard case");
5675
5676   VisualFactory factory = VisualFactory::Get();
5677   Property::Map propertyMap;
5678   propertyMap[Visual::Property::TYPE]                     = Visual::Type::IMAGE;
5679   propertyMap[ImageVisual::Property::URL]                 = TEST_IMAGE_FILE_NAME;
5680   propertyMap[Visual::Property::MIX_COLOR]                = Color::BLUE;
5681   propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5682
5683   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5684
5685   DummyControl        dummyControl = DummyControl::New(true);
5686   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5687   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5688   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5689   application.GetScene().Add(dummyControl);
5690
5691   application.SendNotification();
5692   application.Render();
5693
5694   // Wait for image loading
5695   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5696
5697   application.SendNotification();
5698   application.Render();
5699
5700   Property::Map originalMap;
5701   imageVisual.CreatePropertyMap(originalMap);
5702
5703   float                    targetOpacity            = 0.5f;
5704   Vector3                  targetMixColor           = Vector3(1.0f, 0.4f, 0.2f);
5705   bool                     targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5706   DevelVisual::FittingMode targetVisualFittingMode  = DevelVisual::CENTER;
5707   Vector4                  targetCornerRadius       = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5708   float                    targetBorderlineWidth    = 20.0f;
5709   Vector4                  targetBorderlineColor    = Color::RED;
5710   float                    targetBorderlineOffset   = 1.0f;
5711
5712   Property::Map targetPropertyMap;
5713   targetPropertyMap[Visual::Property::OPACITY]                  = targetOpacity;
5714   targetPropertyMap[ImageVisual::Property::URL]                 = "foobar";
5715   targetPropertyMap[Visual::Property::MIX_COLOR]                = targetMixColor;
5716   targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA]      = targetPreMultipliedAlpha;
5717   targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5718   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]       = targetCornerRadius;
5719   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH]    = targetBorderlineWidth;
5720   targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR]    = targetBorderlineColor;
5721   targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET]   = targetBorderlineOffset;
5722
5723   // Update Properties
5724   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5725
5726   Property::Map resultMap;
5727   imageVisual.CreatePropertyMap(resultMap);
5728
5729   // Test property values: they should be updated
5730   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5731   DALI_TEST_CHECK(colorValue);
5732   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5733
5734   Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5735   DALI_TEST_CHECK(urlValue);
5736   // NOTE : ImageVisual URL must NOT changed.
5737   DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5738
5739   Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5740   DALI_TEST_CHECK(preMultipliedValue);
5741   DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5742
5743   Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5744   DALI_TEST_CHECK(visualFittingModeValue);
5745   DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5746
5747   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5748   DALI_TEST_CHECK(cornerRadiusValue);
5749   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5750
5751   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5752   DALI_TEST_CHECK(borderlineWidthValue);
5753   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5754
5755   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5756   DALI_TEST_CHECK(borderlineColorValue);
5757   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5758
5759   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5760   DALI_TEST_CHECK(borderlineOffsetValue);
5761   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5762
5763   END_TEST;
5764 }
5765
5766 int UtcDaliVisualUpdateProperty02(void)
5767 {
5768   ToolkitTestApplication application;
5769   tet_infoline("UtcDaliVisualUpdateProperty02: Test update property by DoAction. Initialize as zero, and update non-zero case");
5770
5771   Vector4 borderlineColor  = Color::BLUE;
5772   float   borderlineOffset = 1.0f;
5773
5774   VisualFactory factory = VisualFactory::Get();
5775   Property::Map propertyMap;
5776   propertyMap[Visual::Property::TYPE]                      = Visual::Type::IMAGE;
5777   propertyMap[ImageVisual::Property::URL]                  = TEST_IMAGE_FILE_NAME;
5778   propertyMap[Visual::Property::MIX_COLOR]                 = Color::BLUE;
5779   propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE]  = DevelVisual::FIT_WIDTH;
5780   propertyMap[DevelVisual::Property::CORNER_RADIUS]        = 0.0f;
5781   propertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5782   propertyMap[DevelVisual::Property::BORDERLINE_WIDTH]     = 0.0f;
5783   propertyMap[DevelVisual::Property::BORDERLINE_COLOR]     = borderlineColor;
5784   propertyMap[DevelVisual::Property::BORDERLINE_OFFSET]    = borderlineOffset;
5785
5786   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5787
5788   DummyControl        dummyControl = DummyControl::New(true);
5789   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5790   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5791   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5792   application.GetScene().Add(dummyControl);
5793
5794   application.SendNotification();
5795   application.Render();
5796
5797   // Wait for image loading
5798   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5799
5800   application.SendNotification();
5801   application.Render();
5802
5803   Property::Map originalMap;
5804   imageVisual.CreatePropertyMap(originalMap);
5805
5806   Vector4 targetCornerRadius    = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5807   float   targetBorderlineWidth = 20.0f;
5808
5809   Property::Map targetPropertyMap;
5810   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]    = targetCornerRadius;
5811   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
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   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5820   DALI_TEST_CHECK(cornerRadiusValue);
5821   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5822
5823   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5824   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5825   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5826
5827   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5828   DALI_TEST_CHECK(borderlineWidthValue);
5829   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5830
5831   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5832   DALI_TEST_CHECK(borderlineColorValue);
5833   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), borderlineColor, TEST_LOCATION);
5834
5835   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5836   DALI_TEST_CHECK(borderlineOffsetValue);
5837   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), borderlineOffset, TEST_LOCATION);
5838
5839   END_TEST;
5840 }
5841
5842 int UtcDaliVisualUpdatePropertyInvalidType(void)
5843 {
5844   ToolkitTestApplication application;
5845   tet_infoline("UtcDaliVisualUpdatePropertyInvalidType: Test update property by DoAction. But some value is not invalid to update");
5846
5847   VisualFactory factory = VisualFactory::Get();
5848   Property::Map propertyMap;
5849   propertyMap[Visual::Property::TYPE]     = Visual::Type::N_PATCH;
5850   propertyMap[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
5851
5852   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5853
5854   DummyControl        dummyControl = DummyControl::New(true);
5855   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5856   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5857   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5858   application.GetScene().Add(dummyControl);
5859
5860   application.SendNotification();
5861   application.Render();
5862
5863   // Wait for image loading
5864   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5865
5866   application.SendNotification();
5867   application.Render();
5868
5869   Property::Map originalMap;
5870   imageVisual.CreatePropertyMap(originalMap);
5871
5872   float                    targetOpacity            = 0.5f;
5873   Vector3                  targetMixColor           = Vector3(1.0f, 0.4f, 0.2f);
5874   bool                     targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5875   DevelVisual::FittingMode targetVisualFittingMode  = DevelVisual::CENTER;
5876   Vector4                  targetCornerRadius       = Vector4(10.0f, 0.0f, 1.0f, 2.0f);
5877   float                    targetBorderlineWidth    = 20.0f;
5878   Vector4                  targetBorderlineColor    = Color::RED;
5879   float                    targetBorderlineOffset   = 1.0f;
5880
5881   Property::Map targetPropertyMap;
5882   targetPropertyMap[Visual::Property::OPACITY]                  = targetOpacity;
5883   targetPropertyMap[ImageVisual::Property::URL]                 = "foobar";
5884   targetPropertyMap[Visual::Property::MIX_COLOR]                = targetMixColor;
5885   targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA]      = targetPreMultipliedAlpha;
5886   targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5887
5888   // Properties that N_PATCH visual could not used.
5889   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]     = targetCornerRadius;
5890   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH]  = targetBorderlineWidth;
5891   targetPropertyMap[DevelVisual::Property::BORDERLINE_COLOR]  = targetBorderlineColor;
5892   targetPropertyMap[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5893
5894   // Update Properties
5895   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5896
5897   Property::Map resultMap;
5898   imageVisual.CreatePropertyMap(resultMap);
5899
5900   // Test property values: they should be updated
5901   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5902   DALI_TEST_CHECK(colorValue);
5903   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5904
5905   Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5906   DALI_TEST_CHECK(urlValue);
5907   // NOTE : NPatchVisual URL must NOT changed.
5908   DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_NPATCH_FILE_NAME, TEST_LOCATION);
5909
5910   Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5911   DALI_TEST_CHECK(preMultipliedValue);
5912   DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5913
5914   Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5915   DALI_TEST_CHECK(visualFittingModeValue);
5916   DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5917
5918   // We don't check properties value that N_PATCH visual could not used.
5919   // It is undefined.
5920
5921   END_TEST;
5922 }
5923
5924 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5925 {
5926   ToolkitTestApplication application;
5927   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5928
5929   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5930
5931   VisualFactory factory = VisualFactory::Get();
5932   Property::Map propertyMap;
5933   // Case ImageVisual
5934   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
5935   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5936
5937   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5938
5939   DummyControl        dummyControl = DummyControl::New(true);
5940   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5941   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5942   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5943   application.GetScene().Add(dummyControl);
5944
5945   application.SendNotification();
5946   application.Render();
5947
5948   // Wait for image loading
5949   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5950
5951   application.SendNotification();
5952   application.Render();
5953
5954   TestShaderCodeContainSubstrings(
5955     dummyControl,
5956     {
5957       {"#define IS_REQUIRED_BORDERLINE", false},
5958       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
5959     },
5960     TEST_LOCATION);
5961
5962   callStack.Reset();
5963   callStack.Enable(true);
5964
5965   Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5966
5967   Property::Map targetPropertyMap;
5968   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]        = targetCornerRadius;
5969   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5970
5971   // Update Properties with CornerRadius
5972   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5973
5974   Property::Map resultMap;
5975   imageVisual.CreatePropertyMap(resultMap);
5976
5977   // Test property values: they should be updated
5978   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5979   DALI_TEST_CHECK(cornerRadiusValue);
5980   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5981
5982   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5983   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5984   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5985
5986   TestShaderCodeContainSubstrings(
5987     dummyControl,
5988     {
5989       {"#define IS_REQUIRED_BORDERLINE", false},
5990       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
5991     },
5992     TEST_LOCATION);
5993
5994   // Send shader compile signal
5995   application.SendNotification();
5996   application.Render();
5997
5998   callStack.Enable(false);
5999   // Shader changed
6000   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6001   callStack.Reset();
6002   callStack.Enable(true);
6003
6004   float   targetBorderlineWidth  = 10.0f;
6005   Vector4 targetBorderlineColor  = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
6006   float   targetBorderlineOffset = -0.3f;
6007
6008   Property::Map targetPropertyMap2;
6009   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
6010   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6011   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]     = targetBorderlineWidth;
6012   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]     = targetBorderlineColor;
6013   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET]    = targetBorderlineOffset;
6014
6015   // Update Properties with Borderline
6016   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6017
6018   Property::Map resultMap2;
6019   imageVisual.CreatePropertyMap(resultMap2);
6020
6021   // Test property values: they should be updated
6022   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6023   DALI_TEST_CHECK(cornerRadiusValue);
6024   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6025
6026   cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6027   DALI_TEST_CHECK(cornerRadiusPolicyValue);
6028   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6029
6030   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6031   DALI_TEST_CHECK(borderlineWidthValue);
6032   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6033
6034   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6035   DALI_TEST_CHECK(borderlineColorValue);
6036   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6037
6038   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6039   DALI_TEST_CHECK(borderlineOffsetValue);
6040   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6041
6042   TestShaderCodeContainSubstrings(
6043     dummyControl,
6044     {
6045       {"#define IS_REQUIRED_BORDERLINE", true},
6046       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6047     },
6048     TEST_LOCATION);
6049
6050   // Send shader compile signal
6051   application.SendNotification();
6052   application.Render();
6053
6054   callStack.Enable(false);
6055   // Shader changed
6056   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6057   callStack.Reset();
6058   callStack.Enable(true);
6059
6060   Property::Map targetPropertyMap3;
6061   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
6062   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
6063   targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH]     = 0.0f;
6064   targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR]     = Vector4::ZERO;
6065   targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET]    = 0.0f;
6066
6067   // Update Properties into zero
6068   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
6069
6070   Property::Map resultMap3;
6071   imageVisual.CreatePropertyMap(resultMap3);
6072
6073   // Test property values: they should be updated
6074   cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6075   DALI_TEST_CHECK(cornerRadiusValue);
6076   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6077
6078   cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6079   DALI_TEST_CHECK(cornerRadiusPolicyValue);
6080   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6081
6082   borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6083   DALI_TEST_CHECK(borderlineWidthValue);
6084   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
6085
6086   borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6087   DALI_TEST_CHECK(borderlineColorValue);
6088   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6089
6090   borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6091   DALI_TEST_CHECK(borderlineOffsetValue);
6092   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
6093
6094   TestShaderCodeContainSubstrings(
6095     dummyControl,
6096     {
6097       {"#define IS_REQUIRED_BORDERLINE", true},     // Note : mAlwaysUsingBorderline is true.
6098       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6099     },
6100     TEST_LOCATION);
6101
6102   // Send shader compile signal
6103   application.SendNotification();
6104   application.Render();
6105
6106   callStack.Enable(false);
6107   // Shader not changed
6108   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6109
6110   END_TEST;
6111 }
6112
6113 int UtcDaliVisualUpdatePropertyChangeShader02(void)
6114 {
6115   ToolkitTestApplication application;
6116   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
6117
6118   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6119
6120   VisualFactory factory = VisualFactory::Get();
6121   Property::Map propertyMap;
6122   // Case ImageVisual
6123   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
6124   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
6125
6126   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6127
6128   DummyControl        dummyControl = DummyControl::New(true);
6129   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6130   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6131   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6132   application.GetScene().Add(dummyControl);
6133
6134   application.SendNotification();
6135   application.Render();
6136
6137   // Wait for image loading
6138   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6139
6140   application.SendNotification();
6141   application.Render();
6142
6143   TestShaderCodeContainSubstrings(
6144     dummyControl,
6145     {
6146       {"#define IS_REQUIRED_BORDERLINE", false},
6147       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6148     },
6149     TEST_LOCATION);
6150
6151   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6152
6153   Property::Map targetPropertyMap;
6154   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
6155
6156   callStack.Reset();
6157   callStack.Enable(true);
6158
6159   // Update Properties with CornerRadius
6160   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6161
6162   Property::Map resultMap;
6163   imageVisual.CreatePropertyMap(resultMap);
6164
6165   // Test property values: they should be updated
6166   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6167   DALI_TEST_CHECK(cornerRadiusValue);
6168   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6169
6170   TestShaderCodeContainSubstrings(
6171     dummyControl,
6172     {
6173       {"#define IS_REQUIRED_BORDERLINE", false},
6174       {"#define IS_REQUIRED_ROUNDED_CORNER", false}, // Note : corner radius is zero. so we don't change shader!
6175     },
6176     TEST_LOCATION);
6177
6178   // Send shader compile signal
6179   application.SendNotification();
6180   application.Render();
6181
6182   callStack.Enable(false);
6183
6184   // Shader doesn't changed
6185   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6186   callStack.Reset();
6187   callStack.Enable(true);
6188
6189   float   targetBorderlineWidth  = 0.0f;
6190   Vector4 targetBorderlineColor  = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
6191   float   targetBorderlineOffset = -1.0f;
6192
6193   Property::Map targetPropertyMap2;
6194   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]  = targetBorderlineWidth;
6195   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]  = targetBorderlineColor;
6196   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
6197
6198   // Update Properties with Borderline
6199   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6200
6201   Property::Map resultMap2;
6202   imageVisual.CreatePropertyMap(resultMap2);
6203
6204   // Test property values: they should be updated
6205   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6206   DALI_TEST_CHECK(borderlineWidthValue);
6207   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6208
6209   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
6210   DALI_TEST_CHECK(borderlineColorValue);
6211   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
6212
6213   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
6214   DALI_TEST_CHECK(borderlineOffsetValue);
6215   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
6216
6217   TestShaderCodeContainSubstrings(
6218     dummyControl,
6219     {
6220       {"#define IS_REQUIRED_BORDERLINE", false}, // Note : borderline width is zero. so we don't change shader!
6221       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6222     },
6223     TEST_LOCATION);
6224
6225   // Send shader compile signal
6226   application.SendNotification();
6227   application.Render();
6228
6229   callStack.Enable(false);
6230
6231   // Shader doesn't changed
6232   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6233
6234   END_TEST;
6235 }
6236
6237 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6238 {
6239   ToolkitTestApplication application;
6240   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6241
6242   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6243
6244   VisualFactory factory = VisualFactory::Get();
6245   Property::Map propertyMap;
6246   // Case ImageVisual
6247   propertyMap[Visual::Property::TYPE]           = Visual::Type::COLOR;
6248   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6249
6250   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6251
6252   DummyControl        dummyControl = DummyControl::New(true);
6253   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6254   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6255   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6256   application.GetScene().Add(dummyControl);
6257
6258   application.SendNotification();
6259   application.Render();
6260
6261   application.SendNotification();
6262   application.Render();
6263
6264   TestShaderCodeContainSubstrings(
6265     dummyControl,
6266     {
6267       {"#define IS_REQUIRED_BLUR", false},
6268       {"#define IS_REQUIRED_BORDERLINE", false},
6269       {"#define IS_REQUIRED_ROUNDED_CORNER", false},
6270     },
6271     TEST_LOCATION);
6272
6273   float   targetBlurRadius   = 15.0f;
6274   Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6275
6276   Property::Map targetPropertyMap;
6277   targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6278   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]    = targetCornerRadius;
6279   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6280
6281   callStack.Reset();
6282   callStack.Enable(true);
6283
6284   // Update Properties with CornerRadius
6285   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6286
6287   Property::Map resultMap;
6288   imageVisual.CreatePropertyMap(resultMap);
6289
6290   // Test property values: they should be updated
6291   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6292   DALI_TEST_CHECK(blurRadiusValue);
6293   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6294
6295   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6296   DALI_TEST_CHECK(cornerRadiusValue);
6297   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6298
6299   TestShaderCodeContainSubstrings(
6300     dummyControl,
6301     {
6302       {"#define IS_REQUIRED_BLUR", true},
6303       {"#define IS_REQUIRED_BORDERLINE", false}, // Note : We ignore borderline when blur radius occured
6304       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6305     },
6306     TEST_LOCATION);
6307
6308   // Send shader compile signal
6309   application.SendNotification();
6310   application.Render();
6311
6312   callStack.Enable(false);
6313
6314   // Shader changed
6315   DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6316   callStack.Reset();
6317   callStack.Enable(true);
6318
6319   Property::Map targetPropertyMap2;
6320   targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6321   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]    = Vector4::ZERO;
6322   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6323
6324   // Update Properties with CornerRadius
6325   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6326
6327   Property::Map resultMap2;
6328   imageVisual.CreatePropertyMap(resultMap2);
6329
6330   // Test property values: they should be updated
6331   blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6332   DALI_TEST_CHECK(blurRadiusValue);
6333   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6334
6335   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6336   DALI_TEST_CHECK(cornerRadiusValue);
6337   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6338
6339   TestShaderCodeContainSubstrings(
6340     dummyControl,
6341     {
6342       {"#define IS_REQUIRED_BLUR", true},           // Note : mAlwaysUsingBlurRadius is true.
6343       {"#define IS_REQUIRED_BORDERLINE", false},    // Note : We ignore borderline when blur radius occured
6344       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6345     },
6346     TEST_LOCATION);
6347
6348   // Send shader compile signal
6349   application.SendNotification();
6350   application.Render();
6351
6352   callStack.Enable(false);
6353
6354   // Shader not changed
6355   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6356
6357   END_TEST;
6358 }
6359
6360 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6361 {
6362   ToolkitTestApplication application;
6363   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6364
6365   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6366
6367   VisualFactory factory = VisualFactory::Get();
6368   Property::Map propertyMap;
6369   // Case ImageVisual
6370   propertyMap[Visual::Property::TYPE]               = Visual::Type::IMAGE;
6371   propertyMap[ImageVisual::Property::URL]           = TEST_IMAGE_FILE_NAME;
6372   propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6373
6374   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6375
6376   DummyControl        dummyControl = DummyControl::New(true);
6377   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6378   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6379   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6380   application.GetScene().Add(dummyControl);
6381
6382   application.SendNotification();
6383   application.Render();
6384
6385   // Wait for image loading
6386   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6387
6388   application.SendNotification();
6389   application.Render();
6390
6391   TestShaderCodeContainSubstrings(
6392     dummyControl,
6393     {
6394       {"#define IS_REQUIRED_BORDERLINE", false},
6395       {"#define IS_REQUIRED_ROUNDED_CORNER", true},
6396     },
6397     TEST_LOCATION);
6398
6399   callStack.Reset();
6400   callStack.Enable(true);
6401
6402   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6403
6404   Animation animation = Animation::New(1.0f);
6405   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6406   animation.Play();
6407
6408   application.SendNotification();
6409   application.Render();
6410   application.Render(1001u); // End of animation
6411
6412   TestShaderCodeContainSubstrings(
6413     dummyControl,
6414     {
6415       {"#define IS_REQUIRED_BORDERLINE", false},
6416       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6417     },
6418     TEST_LOCATION);
6419
6420   callStack.Enable(false);
6421   // Shader not changed
6422   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6423   callStack.Reset();
6424   callStack.Enable(true);
6425
6426   float         targetBorderlineWidth = 10.0f;
6427   Property::Map targetPropertyMap;
6428   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6429
6430   // Update Properties with CornerRadius
6431   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6432
6433   Property::Map resultMap;
6434   imageVisual.CreatePropertyMap(resultMap);
6435
6436   // Test property values: they should be updated
6437   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6438   DALI_TEST_CHECK(cornerRadiusValue);
6439   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6440
6441   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6442   DALI_TEST_CHECK(cornerRadiusPolicyValue);
6443   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6444
6445   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6446   DALI_TEST_CHECK(borderlineWidthValue);
6447   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6448
6449   TestShaderCodeContainSubstrings(
6450     dummyControl,
6451     {
6452       {"#define IS_REQUIRED_BORDERLINE", true},
6453       {"#define IS_REQUIRED_ROUNDED_CORNER", true}, // Note : mAlwaysUsingCornerRadius is true.
6454     },
6455     TEST_LOCATION);
6456
6457   // Send shader compile signal
6458   application.SendNotification();
6459   application.Render();
6460
6461   callStack.Enable(false);
6462   // Shader changed
6463   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6464
6465   END_TEST;
6466 }