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