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

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