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, and cannot change value )
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     Visual::Base imageVisual = factory.CreateVisual(
3476       Property::Map()
3477         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3478         .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3479         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3480
3481     Dali::Property::Map visualMap;
3482     imageVisual.CreatePropertyMap(visualMap);
3483     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3484
3485     // test values
3486     DALI_TEST_CHECK(value);
3487     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3488   }
3489
3490   // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3491   {
3492     Visual::Base imageVisual = factory.CreateVisual(
3493       Property::Map()
3494         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3495         .Add(ImageVisual::Property::URL, "something.json"));
3496
3497     Dali::Property::Map visualMap;
3498     imageVisual.CreatePropertyMap(visualMap);
3499     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3500
3501     // test values
3502     DALI_TEST_CHECK(value);
3503     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3504   }
3505   {
3506     Visual::Base imageVisual = factory.CreateVisual(
3507       Property::Map()
3508         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3509         .Add(ImageVisual::Property::URL, "something.json")
3510         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3511
3512     Dali::Property::Map visualMap;
3513     imageVisual.CreatePropertyMap(visualMap);
3514     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3515
3516     // test values
3517     DALI_TEST_CHECK(value);
3518     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3519   }
3520
3521   // text visual ( premultiplied alpha by default is true, and cannot change value )
3522   {
3523     Visual::Base textVisual = factory.CreateVisual(
3524       Property::Map()
3525         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3526         .Add(TextVisual::Property::TEXT, "Text"));
3527
3528     Dali::Property::Map visualMap;
3529     textVisual.CreatePropertyMap(visualMap);
3530     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3531
3532     // test values
3533     DALI_TEST_CHECK(value);
3534     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3535   }
3536   {
3537     Visual::Base textVisual = factory.CreateVisual(
3538       Property::Map()
3539         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3540         .Add(TextVisual::Property::TEXT, "Text")
3541         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3542
3543     Dali::Property::Map visualMap;
3544     textVisual.CreatePropertyMap(visualMap);
3545     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3546
3547     // test values
3548     DALI_TEST_CHECK(value);
3549     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3550   }
3551
3552   // gradient visual ( premultiplied alpha by default is true, and cannot change value )
3553   {
3554     Visual::Base gradientVisual = factory.CreateVisual(
3555       Property::Map()
3556         .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3557         .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3558         .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3559         .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3560
3561     Dali::Property::Map visualMap;
3562     gradientVisual.CreatePropertyMap(visualMap);
3563     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3564
3565     // test values
3566     DALI_TEST_CHECK(value);
3567     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3568   }
3569   {
3570     Visual::Base gradientVisual = factory.CreateVisual(
3571       Property::Map()
3572         .Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT)
3573         .Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f))
3574         .Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f))
3575         .Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f)))
3576         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3577
3578     Dali::Property::Map visualMap;
3579     gradientVisual.CreatePropertyMap(visualMap);
3580     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3581
3582     // test values
3583     DALI_TEST_CHECK(value);
3584     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3585   }
3586
3587   // color visual ( premultiplied alpha by default is false, and cannot change value )
3588   {
3589     Visual::Base colorVisual = factory.CreateVisual(
3590       Property::Map()
3591         .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3592         .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA));
3593
3594     Dali::Property::Map visualMap;
3595     colorVisual.CreatePropertyMap(visualMap);
3596     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3597
3598     // test values
3599     DALI_TEST_CHECK(value);
3600     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3601   }
3602   {
3603     Visual::Base colorVisual = factory.CreateVisual(
3604       Property::Map()
3605         .Add(Toolkit::Visual::Property::TYPE, Visual::COLOR)
3606         .Add(ColorVisual::Property::MIX_COLOR, Color::AQUA)
3607         .Add(Visual::Property::PREMULTIPLIED_ALPHA, true));
3608
3609     Dali::Property::Map visualMap;
3610     colorVisual.CreatePropertyMap(visualMap);
3611     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3612
3613     // test values
3614     DALI_TEST_CHECK(value);
3615     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3616   }
3617
3618   END_TEST;
3619 }
3620
3621 int UtcDaliRegisterVisualOrder(void)
3622 {
3623   ToolkitTestApplication application;
3624   tet_infoline("Register Visual Order");
3625
3626   DummyControl        dummyControl = DummyControl::New(true);
3627   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3628
3629   VisualFactory factory = VisualFactory::Get();
3630   Property::Map propertyMap;
3631   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3632   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3633
3634   tet_infoline("Register visual, should have depth index of 0.0f");
3635   Visual::Base testVisual = factory.CreateVisual(propertyMap);
3636   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual);
3637   DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 0, TEST_LOCATION);
3638
3639   tet_infoline("Register more visuals, each added one should have a depth index greater than previous");
3640
3641   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3642   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3643   DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual.GetDepthIndex());
3644
3645   Visual::Base foregroundVisual = factory.CreateVisual(propertyMap);
3646   dummyImpl.RegisterVisual(DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual);
3647   DALI_TEST_CHECK(foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex());
3648
3649   Visual::Base focusVisual = factory.CreateVisual(propertyMap);
3650   dummyImpl.RegisterVisual(DummyControl::Property::FOCUS_VISUAL, focusVisual);
3651   DALI_TEST_CHECK(focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex());
3652
3653   tet_infoline("Set depth index on a new visual before registering, the depth index should not have been changed");
3654   Visual::Base labelVisual = factory.CreateVisual(propertyMap);
3655   labelVisual.SetDepthIndex(-2000);
3656   dummyImpl.RegisterVisual(DummyControl::Property::LABEL_VISUAL, labelVisual);
3657   DALI_TEST_EQUALS(labelVisual.GetDepthIndex(), -2000, TEST_LOCATION);
3658
3659   tet_infoline("Replace visual, the depth index should be the same as what was previously set");
3660   const int    testVisual2DepthIndex  = testVisual2.GetDepthIndex();
3661   Visual::Base testVisual2Replacement = factory.CreateVisual(propertyMap);
3662   DALI_TEST_CHECK(testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex);
3663   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2Replacement);
3664   DALI_TEST_EQUALS(testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION);
3665
3666   tet_infoline("Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured");
3667   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual(propertyMap);
3668   anotherTestVisual2Replacement.SetDepthIndex(2000);
3669   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement);
3670   DALI_TEST_EQUALS(anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION);
3671
3672   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3673   application.GetScene().Add(dummyControl);
3674
3675   END_TEST;
3676 }
3677
3678 int UtcDaliRegisterVisualOrder02(void)
3679 {
3680   ToolkitTestApplication application;
3681   tet_infoline("Register Visual Order with Background Set");
3682
3683   DummyControl        dummyControl = DummyControl::New(true);
3684   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3685
3686   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3687
3688   VisualFactory factory = VisualFactory::Get();
3689   Property::Map propertyMap;
3690   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3691   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3692
3693   tet_printf("Register a control background visual, should have depth index of %d\n", backgroundDepthIndex);
3694
3695   dummyControl.SetProperty(Control::Property::BACKGROUND, propertyMap);
3696
3697   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3698   tet_printf("Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX);
3699   Visual::Base testVisual1 = factory.CreateVisual(propertyMap);
3700   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, testVisual1);
3701   DALI_TEST_EQUALS(testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX, TEST_LOCATION);
3702
3703   tet_printf("Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX);
3704   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3705   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, testVisual2);
3706   DALI_TEST_CHECK(testVisual2.GetDepthIndex() > testVisual1.GetDepthIndex());
3707
3708   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3709   application.GetScene().Add(dummyControl);
3710
3711   END_TEST;
3712 }
3713
3714 int UtcDaliRegisterVisualWithDepthIndex(void)
3715 {
3716   ToolkitTestApplication application;
3717   tet_infoline("Register a Visual With Depth Index");
3718
3719   DummyControl        dummyControl = DummyControl::New(true);
3720   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3721
3722   VisualFactory factory = VisualFactory::Get();
3723   Property::Map propertyMap;
3724   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3725   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3726
3727   tet_infoline("Register a visual with a depth index, it should be enabled by default too");
3728   Visual::Base testVisual = factory.CreateVisual(propertyMap);
3729   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203);
3730   DALI_TEST_EQUALS(testVisual.GetDepthIndex(), 203, TEST_LOCATION);
3731   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL), true, TEST_LOCATION);
3732
3733   tet_infoline("Register another visual with a depth index and it disabled");
3734   Visual::Base testVisual2 = factory.CreateVisual(propertyMap);
3735   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450);
3736   DALI_TEST_EQUALS(testVisual2.GetDepthIndex(), 450, TEST_LOCATION);
3737   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), false, TEST_LOCATION);
3738
3739   tet_infoline("Register another visual with a depth index and it enabled using the enabled API");
3740   Visual::Base testVisual3 = factory.CreateVisual(propertyMap);
3741   DevelControl::RegisterVisual(dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300);
3742   DALI_TEST_EQUALS(testVisual3.GetDepthIndex(), 300, TEST_LOCATION);
3743   DALI_TEST_EQUALS(DevelControl::IsVisualEnabled(dummyImpl, DummyControl::Property::TEST_VISUAL2), true, TEST_LOCATION);
3744
3745   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3746   application.GetScene().Add(dummyControl);
3747
3748   END_TEST;
3749 }
3750
3751 int UtcDaliSvgVisualCustomShader(void)
3752 {
3753   ToolkitTestApplication application;
3754   tet_infoline("SvgVisual with custom shader");
3755
3756   VisualFactory     factory = VisualFactory::Get();
3757   Property::Map     properties;
3758   Property::Map     shader;
3759   const std::string vertexShader                                   = "Foobar";
3760   const std::string fragmentShader                                 = "Foobar";
3761   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3762   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
3763
3764   properties[Visual::Property::TYPE]     = Visual::IMAGE;
3765   properties[Visual::Property::SHADER]   = shader;
3766   properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3767
3768   Visual::Base visual = factory.CreateVisual(properties);
3769
3770   // trigger creation through setting on stage
3771   DummyControl        dummy     = DummyControl::New(true);
3772   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3773   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3774
3775   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3776   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3777   application.GetScene().Add(dummy);
3778
3779   application.SendNotification();
3780   application.Render();
3781
3782   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3783
3784   Renderer        renderer = dummy.GetRendererAt(0);
3785   Shader          shader2  = renderer.GetShader();
3786   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
3787   Property::Map*  map      = value.GetMap();
3788   DALI_TEST_CHECK(map);
3789
3790   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3791   DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3792
3793   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3794   DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3795
3796   END_TEST;
3797 }
3798
3799 int UtcDaliVisualRoundedCorner(void)
3800 {
3801   ToolkitTestApplication application;
3802   tet_infoline("UtcDaliVisualRoundedCorner");
3803
3804   static std::vector<UniformData> customUniforms =
3805     {
3806       UniformData("cornerRadius", Property::Type::VECTOR4),
3807       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3808     };
3809
3810   TestGraphicsController& graphics = application.GetGraphicsController();
3811   graphics.AddCustomUniforms(customUniforms);
3812
3813   // image visual
3814   {
3815     VisualFactory factory = VisualFactory::Get();
3816     Property::Map properties;
3817     float         cornerRadius = 30.0f;
3818
3819     properties[Visual::Property::TYPE]               = Visual::IMAGE;
3820     properties[ImageVisual::Property::URL]           = TEST_IMAGE_FILE_NAME;
3821     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3822
3823     Visual::Base visual = factory.CreateVisual(properties);
3824
3825     // trigger creation through setting on stage
3826     DummyControl        dummy     = DummyControl::New(true);
3827     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3828     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3829
3830     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3831     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3832     application.GetScene().Add(dummy);
3833
3834     application.SendNotification();
3835     application.Render();
3836
3837     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3838
3839     application.SendNotification();
3840     application.Render();
3841
3842     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3843     // Default corner radius policy is absolute.
3844     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3845   }
3846
3847   // color visual 1
3848   {
3849     VisualFactory factory = VisualFactory::Get();
3850     Property::Map properties;
3851     float         cornerRadius = 30.0f;
3852
3853     properties[Visual::Property::TYPE]           = Visual::COLOR;
3854     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3855     properties["cornerRadius"]                   = cornerRadius;
3856     properties["cornerRadiusPolicy"]             = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3857
3858     Visual::Base visual = factory.CreateVisual(properties);
3859
3860     // trigger creation through setting on stage
3861     DummyControl        dummy     = DummyControl::New(true);
3862     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3863     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3864
3865     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3866     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3867     application.GetScene().Add(dummy);
3868
3869     application.SendNotification();
3870     application.Render();
3871
3872     application.SendNotification();
3873     application.Render();
3874
3875     // Currently test with multiple program doesn't work well. will fix another day
3876     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3877     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3878   }
3879
3880   // color visual 2
3881   {
3882     VisualFactory factory = VisualFactory::Get();
3883     Property::Map properties;
3884     Vector4       cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3885
3886     properties[Visual::Property::TYPE]                      = Visual::COLOR;
3887     properties[ColorVisual::Property::MIX_COLOR]            = Color::BLUE;
3888     properties[DevelVisual::Property::CORNER_RADIUS]        = cornerRadius;
3889     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3890
3891     Visual::Base visual = factory.CreateVisual(properties);
3892
3893     // trigger creation through setting on stage
3894     DummyControl        dummy     = DummyControl::New(true);
3895     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3896     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3897
3898     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3899     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3900     application.GetScene().Add(dummy);
3901
3902     application.SendNotification();
3903     application.Render();
3904
3905     application.SendNotification();
3906     application.Render();
3907
3908     // Currently test with multiple program doesn't work well. will fix another day
3909     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3910     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
3911   }
3912
3913   // color visual 3 - invalid value
3914   {
3915     VisualFactory factory = VisualFactory::Get();
3916     Property::Map properties;
3917     Vector4       cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3918
3919     properties[Visual::Property::TYPE]                      = Visual::COLOR;
3920     properties[ColorVisual::Property::MIX_COLOR]            = Color::BLUE;
3921     properties[DevelVisual::Property::CORNER_RADIUS]        = cornerRadius;
3922     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3923
3924     Visual::Base visual = factory.CreateVisual(properties);
3925
3926     // trigger creation through setting on stage
3927     DummyControl        dummy     = DummyControl::New(true);
3928     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3929     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3930
3931     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3932     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3933     application.GetScene().Add(dummy);
3934
3935     application.SendNotification();
3936     application.Render();
3937
3938     application.SendNotification();
3939     application.Render();
3940
3941     // Currently test with multiple program doesn't work well. will fix another day
3942     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
3943     // Default corner radius policy is absolute.
3944     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3945   }
3946
3947   // gradient visual
3948   {
3949     VisualFactory factory = VisualFactory::Get();
3950     Property::Map properties;
3951     float         cornerRadius = 30.0f;
3952
3953     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
3954     properties[ColorVisual::Property::MIX_COLOR]         = Color::BLUE;
3955     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
3956     properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
3957     properties[GradientVisual::Property::END_POSITION]   = Vector2(-0.5f, -0.5f);
3958     properties[GradientVisual::Property::UNITS]          = GradientVisual::Units::USER_SPACE;
3959
3960     Property::Array stopOffsets;
3961     stopOffsets.PushBack(0.0f);
3962     stopOffsets.PushBack(0.6f);
3963     stopOffsets.PushBack(1.0f);
3964     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3965
3966     Property::Array stopColors;
3967     stopColors.PushBack(Color::RED);
3968     stopColors.PushBack(Color::YELLOW);
3969     stopColors.PushBack(Color::GREEN);
3970     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3971
3972     Visual::Base visual = factory.CreateVisual(properties);
3973
3974     // trigger creation through setting on stage
3975     DummyControl        dummy     = DummyControl::New(true);
3976     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3977     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3978
3979     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3980     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3981     application.GetScene().Add(dummy);
3982
3983     application.SendNotification();
3984     application.Render();
3985
3986     application.SendNotification();
3987     application.Render();
3988
3989     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
3990     // Default corner radius policy is absolute.
3991     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
3992   }
3993
3994   // animated image visual
3995   {
3996     VisualFactory factory = VisualFactory::Get();
3997     Property::Map properties;
3998     Vector4       cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3999
4000     properties[Visual::Property::TYPE]               = Visual::ANIMATED_IMAGE;
4001     properties[ImageVisual::Property::URL]           = TEST_GIF_FILE_NAME;
4002     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
4003     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4004     properties["cornerRadiusPolicy"]                 = Toolkit::Visual::Transform::Policy::ABSOLUTE;
4005
4006     Visual::Base visual = factory.CreateVisual(properties);
4007
4008     // trigger creation through setting on stage
4009     DummyControl        dummy     = DummyControl::New(true);
4010     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4011     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4012
4013     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4014     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4015     application.GetScene().Add(dummy);
4016
4017     application.SendNotification();
4018     application.Render();
4019
4020     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4021
4022     application.SendNotification();
4023     application.Render();
4024
4025     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4026     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4027   }
4028
4029   // vector image visual
4030   {
4031     VisualFactory factory = VisualFactory::Get();
4032     Property::Map properties;
4033     Vector4       cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
4034
4035     properties[Visual::Property::TYPE]               = Visual::SVG;
4036     properties[ImageVisual::Property::URL]           = TEST_SVG_FILE_NAME;
4037     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4038
4039     Visual::Base visual = factory.CreateVisual(properties);
4040
4041     // trigger creation through setting on stage
4042     DummyControl        dummy     = DummyControl::New(true);
4043     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4044     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4045
4046     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4047     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4048     application.GetScene().Add(dummy);
4049
4050     application.SendNotification();
4051     application.Render();
4052
4053     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4054
4055     application.SendNotification();
4056     application.Render();
4057
4058     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4059     // Default corner radius policy is absolute.
4060     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4061   }
4062
4063   // animated vector image visual
4064   {
4065     VisualFactory factory = VisualFactory::Get();
4066     Property::Map properties;
4067     float         cornerRadius = 1.3f;
4068
4069     properties[Visual::Property::TYPE]                      = DevelVisual::ANIMATED_VECTOR_IMAGE;
4070     properties[ImageVisual::Property::URL]                  = TEST_VECTOR_IMAGE_FILE_NAME;
4071     properties["cornerRadius"]                              = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
4072     properties["cornerRadius"]                              = cornerRadius;
4073     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4074
4075     Visual::Base visual = factory.CreateVisual(properties);
4076
4077     // trigger creation through setting on stage
4078     DummyControl        dummy     = DummyControl::New(true);
4079     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4080     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4081
4082     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4083     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4084     application.GetScene().Add(dummy);
4085
4086     application.SendNotification();
4087     application.Render();
4088
4089     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4090
4091     application.SendNotification();
4092     application.Render();
4093
4094     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4095     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4096   }
4097
4098   END_TEST;
4099 }
4100
4101 int UtcDaliVisualBorderline(void)
4102 {
4103   ToolkitTestApplication application;
4104   tet_infoline("UtcDaliVisualBorderline");
4105
4106   static std::vector<UniformData> customUniforms =
4107     {
4108       UniformData("cornerRadius", Property::Type::VECTOR4),
4109       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4110       UniformData("borderlineWidth", Property::Type::FLOAT),
4111       UniformData("borderlineColor", Property::Type::VECTOR4),
4112       UniformData("borderlineOffset", Property::Type::FLOAT),
4113     };
4114
4115   TestGraphicsController& graphics = application.GetGraphicsController();
4116   graphics.AddCustomUniforms(customUniforms);
4117
4118   // image visual
4119   {
4120     VisualFactory factory = VisualFactory::Get();
4121     Property::Map properties;
4122     float         cornerRadius    = 5.0f;
4123     float         borderlineWidth = 30.0f;
4124     Vector4       borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4125     float         borderlineOffset = 1.0f;
4126
4127     properties[Visual::Property::TYPE]                   = Visual::IMAGE;
4128     properties[ImageVisual::Property::URL]               = TEST_IMAGE_FILE_NAME;
4129     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4130     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4131     properties[DevelVisual::Property::BORDERLINE_COLOR]  = borderlineColor;
4132     properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4133
4134     Visual::Base visual = factory.CreateVisual(properties);
4135
4136     // trigger creation through setting on stage
4137     DummyControl        dummy     = DummyControl::New(true);
4138     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4139     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4140
4141     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4142     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4143     application.GetScene().Add(dummy);
4144
4145     application.SendNotification();
4146     application.Render();
4147
4148     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4149
4150     application.SendNotification();
4151     application.Render();
4152
4153     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4154     // Default corner radius policy is absolute.
4155     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4156     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4157     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4158     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4159   }
4160
4161   // color visual 1
4162   {
4163     VisualFactory factory = VisualFactory::Get();
4164     Property::Map properties;
4165     Vector4       cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4166     float         borderlineWidth = 30.0f;
4167     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4168     float         borderlineOffset = -0.4f;
4169
4170     properties[Visual::Property::TYPE]           = Visual::COLOR;
4171     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4172     properties["cornerRadius"]                   = cornerRadius;
4173     properties["borderlineWidth"]                = borderlineWidth;
4174     properties["borderlineColor"]                = borderlineColor;
4175     properties["borderlineOffset"]               = borderlineOffset;
4176
4177     Visual::Base visual = factory.CreateVisual(properties);
4178
4179     // trigger creation through setting on stage
4180     DummyControl        dummy     = DummyControl::New(true);
4181     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4182     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4183
4184     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4185     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4186     application.GetScene().Add(dummy);
4187
4188     application.SendNotification();
4189     application.Render();
4190
4191     application.SendNotification();
4192     application.Render();
4193
4194     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4195     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4196     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4197     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4198   }
4199
4200   // color visual 2, default color, default offset
4201   {
4202     VisualFactory factory = VisualFactory::Get();
4203     Property::Map properties;
4204     float         borderlineWidth = 30.0f;
4205
4206     properties[Visual::Property::TYPE]                  = Visual::COLOR;
4207     properties[ColorVisual::Property::MIX_COLOR]        = Color::BLUE;
4208     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4209
4210     Visual::Base visual = factory.CreateVisual(properties);
4211
4212     // trigger creation through setting on stage
4213     DummyControl        dummy     = DummyControl::New(true);
4214     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4215     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4216
4217     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4218     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4219     application.GetScene().Add(dummy);
4220
4221     application.SendNotification();
4222     application.Render();
4223
4224     application.SendNotification();
4225     application.Render();
4226
4227     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4228     // Default borderline color is BLACK.
4229     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4230     // Default borderline offset is 0.0f.
4231     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4232   }
4233
4234   // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4235   {
4236     VisualFactory factory = VisualFactory::Get();
4237     Property::Map properties;
4238     float         borderlineWidth = 30.0f;
4239     Vector4       borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4240     float         borderlineOffset = 37.4f;
4241
4242     properties[Visual::Property::TYPE]           = Visual::COLOR;
4243     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4244     properties["borderlineWidth"]                = borderlineWidth;
4245     properties["borderlineColor"]                = borderlineColor;
4246     properties["borderlineOffset"]               = borderlineOffset;
4247
4248     Visual::Base visual = factory.CreateVisual(properties);
4249
4250     // trigger creation through setting on stage
4251     DummyControl        dummy     = DummyControl::New(true);
4252     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4253     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4254
4255     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4256     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4257     application.GetScene().Add(dummy);
4258
4259     application.SendNotification();
4260     application.Render();
4261
4262     application.SendNotification();
4263     application.Render();
4264
4265     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4266     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4267     // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4268     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4269   }
4270
4271   // gradient visual
4272   {
4273     VisualFactory factory = VisualFactory::Get();
4274     Property::Map properties;
4275     float         borderlineWidth = 30.0f;
4276     float         cornerRadius    = 70.0f;
4277
4278     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4279     properties[ColorVisual::Property::MIX_COLOR]         = Color::BLUE;
4280     properties[DevelVisual::Property::CORNER_RADIUS]     = cornerRadius;
4281     properties[DevelVisual::Property::BORDERLINE_WIDTH]  = borderlineWidth;
4282     properties[GradientVisual::Property::START_POSITION] = Vector2(0.5f, 0.5f);
4283     properties[GradientVisual::Property::END_POSITION]   = Vector2(-0.5f, -0.5f);
4284     properties[GradientVisual::Property::UNITS]          = GradientVisual::Units::USER_SPACE;
4285
4286     Property::Array stopOffsets;
4287     stopOffsets.PushBack(0.0f);
4288     stopOffsets.PushBack(0.6f);
4289     stopOffsets.PushBack(1.0f);
4290     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4291
4292     Property::Array stopColors;
4293     stopColors.PushBack(Color::RED);
4294     stopColors.PushBack(Color::YELLOW);
4295     stopColors.PushBack(Color::GREEN);
4296     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4297
4298     Visual::Base visual = factory.CreateVisual(properties);
4299
4300     // trigger creation through setting on stage
4301     DummyControl        dummy     = DummyControl::New(true);
4302     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4303     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4304
4305     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4306     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4307     application.GetScene().Add(dummy);
4308
4309     application.SendNotification();
4310     application.Render();
4311
4312     application.SendNotification();
4313     application.Render();
4314
4315     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius)), true, TEST_LOCATION);
4316     // Default corner radius policy is absolute.
4317     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4318     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4319     // Default borderline color is BLACK.
4320     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4321     // Default borderline offset is 0.0f.
4322     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4323   }
4324
4325   // animated image visual
4326   {
4327     VisualFactory factory = VisualFactory::Get();
4328     Property::Map properties;
4329     float         borderlineWidth  = 24.0f;
4330     float         borderlineOffset = -1.0f;
4331
4332     properties[Visual::Property::TYPE]                  = Visual::ANIMATED_IMAGE;
4333     properties[ImageVisual::Property::URL]              = TEST_GIF_FILE_NAME;
4334     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4335     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4336     properties["borderlineOffset"]                      = borderlineOffset;
4337
4338     Visual::Base visual = factory.CreateVisual(properties);
4339
4340     // trigger creation through setting on stage
4341     DummyControl        dummy     = DummyControl::New(true);
4342     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4343     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4344
4345     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4346     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4347     application.GetScene().Add(dummy);
4348
4349     application.SendNotification();
4350     application.Render();
4351
4352     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4353
4354     application.SendNotification();
4355     application.Render();
4356
4357     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4358     // Default borderline color is BLACK.
4359     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", Color::BLACK), true, TEST_LOCATION);
4360     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4361   }
4362
4363   // vector image visual
4364   {
4365     VisualFactory factory = VisualFactory::Get();
4366     Property::Map properties;
4367     Vector4       cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4368     float         borderlineWidth = 27.0f;
4369     Vector4       borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4370
4371     properties[Visual::Property::TYPE]                  = Visual::SVG;
4372     properties[ImageVisual::Property::URL]              = TEST_SVG_FILE_NAME;
4373     properties[DevelVisual::Property::CORNER_RADIUS]    = cornerRadius;
4374     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4375     properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4376
4377     Visual::Base visual = factory.CreateVisual(properties);
4378
4379     // trigger creation through setting on stage
4380     DummyControl        dummy     = DummyControl::New(true);
4381     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4382     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4383
4384     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4385     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4386     application.GetScene().Add(dummy);
4387
4388     application.SendNotification();
4389     application.Render();
4390
4391     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4392
4393     application.SendNotification();
4394     application.Render();
4395
4396     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4397     // Default corner radius policy is absolute.
4398     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE), true, TEST_LOCATION);
4399     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4400     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4401     // Default borderline offset is 0.0.
4402     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", 0.0f), true, TEST_LOCATION);
4403   }
4404
4405   // animated vector image visual
4406   {
4407     VisualFactory factory = VisualFactory::Get();
4408     Property::Map properties;
4409     Vector4       cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4410     float         borderlineWidth = 13.0f;
4411     Vector4       borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4412     float         borderlineOffset = 13.0f;
4413
4414     properties[Visual::Property::TYPE]                      = DevelVisual::ANIMATED_VECTOR_IMAGE;
4415     properties[ImageVisual::Property::URL]                  = TEST_VECTOR_IMAGE_FILE_NAME;
4416     properties["cornerRadius"]                              = cornerRadius;
4417     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4418     properties[DevelVisual::Property::BORDERLINE_WIDTH]     = borderlineWidth;
4419     properties["borderlineColor"]                           = borderlineColor;
4420     properties[DevelVisual::Property::BORDERLINE_OFFSET]    = borderlineOffset;
4421
4422     Visual::Base visual = factory.CreateVisual(properties);
4423
4424     // trigger creation through setting on stage
4425     DummyControl        dummy     = DummyControl::New(true);
4426     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4427     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4428
4429     dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4430     dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4431     application.GetScene().Add(dummy);
4432
4433     application.SendNotification();
4434     application.Render();
4435
4436     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4437
4438     application.SendNotification();
4439     application.Render();
4440
4441     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", cornerRadius), true, TEST_LOCATION);
4442     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE), true, TEST_LOCATION);
4443     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", borderlineWidth), true, TEST_LOCATION);
4444     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", borderlineColor), true, TEST_LOCATION);
4445     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", borderlineOffset), true, TEST_LOCATION);
4446   }
4447
4448   END_TEST;
4449 }
4450
4451 int UtcDaliVisualBorderlineBlendModeTest(void)
4452 {
4453   ToolkitTestApplication application;
4454   tet_infoline("UtcDaliVisualBorderlineBlendModeTest");
4455   VisualFactory factory = VisualFactory::Get();
4456
4457   // Case 1 : Test which doesn't support borderline feature.
4458   {
4459     tet_printf("Test Unsupported visual type\n");
4460     Property::Map propertyMap;
4461     propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
4462     propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
4463     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4464     Visual::Base borderVisual = factory.CreateVisual(propertyMap);
4465
4466     DummyControl        actor     = DummyControl::New(true);
4467     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4468     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
4469     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4470     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4471     application.GetScene().Add(actor);
4472
4473     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4474
4475     Renderer renderer = actor.GetRendererAt(0);
4476
4477     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4478     // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
4479     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4480
4481     application.GetScene().Remove(actor);
4482   }
4483
4484   // Case 2 : Test which support borderline feature.
4485   {
4486     tet_printf("Test normal case\n");
4487     Property::Map propertyMap;
4488     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4489     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4490     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4491     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4492
4493     DummyControl        actor     = DummyControl::New(true);
4494     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4495     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4496     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4497     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4498     application.GetScene().Add(actor);
4499
4500     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4501
4502     Renderer renderer = actor.GetRendererAt(0);
4503
4504     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4505     // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
4506     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4507
4508     application.GetScene().Remove(actor);
4509   }
4510
4511   // Case 3 : Test which animated borderline.
4512   {
4513     tet_printf("Test borderline animate case\n");
4514     Property::Map propertyMap;
4515     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4516     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4517     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4518
4519     DummyControl        actor     = DummyControl::New(true);
4520     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4521     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4522     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4523     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4524     application.GetScene().Add(actor);
4525
4526     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4527
4528     Renderer renderer = actor.GetRendererAt(0);
4529
4530     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4531     // BlendMode is AUTO.
4532     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
4533
4534     Animation animation = Animation::New(0.1f);
4535     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f);
4536     animation.Play();
4537
4538     application.SendNotification();
4539     application.Render();
4540     application.Render(101u); // End of animation
4541
4542     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4543     // BlendMode is ON_WITHOUT_CULL.
4544     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4545
4546     Animation revanimation = Animation::New(0.1f);
4547     revanimation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f);
4548     revanimation.Play();
4549
4550     application.SendNotification();
4551     application.Render();
4552     application.Render(101u); // End of animation
4553
4554     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4555     // BlendMode is still ON_WITHOUT_CULL.
4556     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4557
4558     application.GetScene().Remove(actor);
4559   }
4560
4561   // Case 4 : Test which animated corner radius occur.
4562   {
4563     tet_printf("Test borderline animate case\n");
4564     Property::Map propertyMap;
4565     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4566     propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
4567     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4568     Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4569
4570     DummyControl        actor     = DummyControl::New(true);
4571     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4572     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4573     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4574     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4575     application.GetScene().Add(actor);
4576
4577     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4578
4579     Renderer renderer = actor.GetRendererAt(0);
4580
4581     Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4582     // BlendMode is ON_WITHOUT_CULL.
4583     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4584
4585     Animation animation = Animation::New(0.1f);
4586     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f));
4587     animation.Play();
4588
4589     application.SendNotification();
4590     application.Render();
4591     application.Render(101u); // End of animation
4592
4593     blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
4594     // BlendMode is ON_WITHOUT_CULL.
4595     DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
4596
4597     application.GetScene().Remove(actor);
4598   }
4599
4600   END_TEST;
4601 }
4602
4603 int UtcDaliVisualBorderlineColorAnimateTest(void)
4604 {
4605   ToolkitTestApplication application;
4606   tet_infoline("UtcDaliVisualBorderlineColorAnimateTest color");
4607
4608   TestGraphicsController&         graphics = application.GetGraphicsController();
4609   static std::vector<UniformData> customUniforms =
4610     {
4611       UniformData("mixColor", Property::Type::VECTOR3),
4612       UniformData("cornerRadius", Property::Type::VECTOR4),
4613       UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
4614       UniformData("borderlineWidth", Property::Type::FLOAT),
4615       UniformData("borderlineColor", Property::Type::VECTOR4),
4616       UniformData("borderlineOffset", Property::Type::FLOAT),
4617     };
4618   graphics.AddCustomUniforms(customUniforms);
4619
4620   {
4621     const Vector3 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f);
4622     const float   INITIAL_MIX_OPACITY(0.5f);
4623     const Vector4 INITIAL_BORDERLINE_COLOR(0.0f, 1.0f, 0.0f, 1.0f);
4624     const float   INITIAL_ACTOR_OPACITY(1.0f);
4625     const Vector3 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f);
4626     const float   TARGET_MIX_OPACITY(0.8f);
4627     const Vector4 TARGET_BORDERLINE_COLOR(1.0f, 0.0f, 1.0f, 0.2f);
4628     const float   TARGET_ACTOR_OPACITY(0.5f);
4629
4630     VisualFactory factory = VisualFactory::Get();
4631     Property::Map propertyMap;
4632     propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4633     propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
4634     propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
4635     propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
4636     propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
4637     Visual::Base visual = factory.CreateVisual(propertyMap);
4638
4639     DummyControl        actor     = DummyControl::New(true);
4640     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
4641     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4642     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
4643     actor.SetProperty(Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY);
4644     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4645     application.GetScene().Add(actor);
4646
4647     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
4648
4649     Animation animation = Animation::New(4.0f);
4650     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR);
4651     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
4652     animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR);
4653     animation.AnimateTo(Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
4654     animation.Play();
4655
4656     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
4657
4658     application.SendNotification();
4659     application.Render(0);
4660     application.Render(2000u); // halfway point
4661     application.SendNotification();
4662
4663     Vector3 halfwayMixColor        = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5f;
4664     float   halfwayMixOpacity      = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY) * 0.5f;
4665     Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
4666     float   halfwayActorOpacity    = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY) * 0.5f;
4667     halfwayMixOpacity *= halfwayActorOpacity;
4668     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION);
4669     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION);
4670     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION);
4671     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION);
4672
4673     application.Render(2001u);      // go past end
4674     application.SendNotification(); // Trigger signals
4675
4676     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION);
4677     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION);
4678     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4679     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION);
4680     DALI_TEST_EQUALS(glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR), true, TEST_LOCATION);
4681
4682     actor.Unparent();
4683   }
4684
4685   END_TEST;
4686 }
4687
4688 int UtcDaliColorVisualBlurRadius(void)
4689 {
4690   ToolkitTestApplication application;
4691   tet_infoline("UtcDaliColorVisualBlurRadius");
4692
4693   static std::vector<UniformData> customUniforms =
4694     {
4695       UniformData("blurRadius", Property::Type::FLOAT),
4696     };
4697
4698   TestGraphicsController& graphics = application.GetGraphicsController();
4699   graphics.AddCustomUniforms(customUniforms);
4700
4701   VisualFactory factory = VisualFactory::Get();
4702   Property::Map properties;
4703   float         blurRadius = 20.0f;
4704
4705   properties[Visual::Property::TYPE]           = Visual::COLOR;
4706   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4707   properties["blurRadius"]                     = blurRadius;
4708
4709   Visual::Base visual = factory.CreateVisual(properties);
4710
4711   // trigger creation through setting on stage
4712   DummyControl        dummy     = DummyControl::New(true);
4713   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
4714   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
4715
4716   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
4717   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
4718   application.GetScene().Add(dummy);
4719
4720   application.SendNotification();
4721   application.Render();
4722
4723   application.SendNotification();
4724   application.Render();
4725
4726   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", blurRadius), true, TEST_LOCATION);
4727
4728   END_TEST;
4729 }
4730
4731 int UtcDaliVisualGetType(void)
4732 {
4733   ToolkitTestApplication application;
4734   tet_infoline("UtcDaliVisualGetType");
4735
4736   VisualFactory factory = VisualFactory::Get();
4737
4738   {
4739     Property::Map properties;
4740     properties[Visual::Property::TYPE] = Visual::BORDER;
4741     Visual::Base visual                = factory.CreateVisual(properties);
4742
4743     DALI_TEST_CHECK(visual.GetType() == Visual::BORDER);
4744   }
4745
4746   {
4747     Property::Map properties;
4748     properties[Visual::Property::TYPE] = Visual::COLOR;
4749     Visual::Base visual                = factory.CreateVisual(properties);
4750
4751     DALI_TEST_CHECK(visual.GetType() == Visual::COLOR);
4752   }
4753
4754   {
4755     Property::Map properties;
4756     properties[Visual::Property::TYPE]                   = Visual::GRADIENT;
4757     properties[GradientVisual::Property::START_POSITION] = Vector2(-1.f, -1.f);
4758     properties[GradientVisual::Property::END_POSITION]   = Vector2(1.f, 1.f);
4759     properties[GradientVisual::Property::STOP_OFFSET]    = Vector2(0.f, 1.f);
4760     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4761     Property::Array stopColors;
4762     stopColors.PushBack(Color::RED);
4763     stopColors.PushBack(Color::GREEN);
4764     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4765     Visual::Base visual                              = factory.CreateVisual(properties);
4766
4767     DALI_TEST_CHECK(visual.GetType() == Visual::GRADIENT);
4768   }
4769
4770   {
4771     Property::Map properties;
4772     properties[Visual::Property::TYPE] = Visual::IMAGE;
4773     properties.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4774     Visual::Base visual = factory.CreateVisual(properties);
4775
4776     DALI_TEST_CHECK(visual.GetType() == Visual::IMAGE);
4777   }
4778
4779   {
4780     Property::Map properties;
4781     properties[Visual::Property::TYPE] = Visual::MESH;
4782     Visual::Base visual                = factory.CreateVisual(properties);
4783
4784     DALI_TEST_CHECK(visual.GetType() == Visual::MESH);
4785   }
4786
4787   {
4788     Property::Map properties;
4789     properties[Visual::Property::TYPE]           = Visual::PRIMITIVE;
4790     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4791     Visual::Base visual                          = factory.CreateVisual(properties);
4792
4793     DALI_TEST_CHECK(visual.GetType() == Visual::PRIMITIVE);
4794   }
4795
4796   {
4797     Property::Map properties;
4798     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4799     Visual::Base visual                = factory.CreateVisual(properties);
4800
4801     DALI_TEST_CHECK(visual.GetType() == Visual::WIREFRAME);
4802   }
4803
4804   {
4805     Property::Map properties;
4806     properties[Visual::Property::TYPE] = Visual::TEXT;
4807     Visual::Base visual                = factory.CreateVisual(properties);
4808
4809     DALI_TEST_CHECK(visual.GetType() == Visual::TEXT);
4810   }
4811
4812   {
4813     Property::Map properties;
4814     properties[Visual::Property::TYPE]     = Visual::N_PATCH;
4815     properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
4816     Visual::Base visual                    = factory.CreateVisual(properties);
4817
4818     DALI_TEST_CHECK(visual.GetType() == Visual::N_PATCH);
4819   }
4820
4821   {
4822     Property::Map properties;
4823     properties[Visual::Property::TYPE]     = Visual::SVG;
4824     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4825     Visual::Base visual                    = factory.CreateVisual(properties);
4826
4827     DALI_TEST_CHECK(visual.GetType() == Visual::SVG);
4828   }
4829
4830   {
4831     Property::Map properties;
4832     properties[Visual::Property::TYPE]     = Visual::ANIMATED_IMAGE;
4833     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4834     Visual::Base visual                    = factory.CreateVisual(properties);
4835
4836     DALI_TEST_CHECK(visual.GetType() == Visual::ANIMATED_IMAGE);
4837   }
4838
4839   {
4840     Property::Map properties;
4841     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4842     Visual::Base visual                = factory.CreateVisual(properties);
4843
4844     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_GRADIENT));
4845   }
4846
4847   {
4848     Property::Map properties;
4849     properties[Visual::Property::TYPE]     = DevelVisual::ANIMATED_VECTOR_IMAGE;
4850     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4851     Visual::Base visual                    = factory.CreateVisual(properties);
4852
4853     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ANIMATED_VECTOR_IMAGE));
4854   }
4855
4856   {
4857     Property::Map properties;
4858     properties[Visual::Property::TYPE] = DevelVisual::ARC;
4859     Visual::Base visual                = factory.CreateVisual(properties);
4860
4861     DALI_TEST_CHECK(visual.GetType() == static_cast<Visual::Type>(DevelVisual::ARC));
4862   }
4863
4864   END_TEST;
4865 }
4866
4867 int UtcDaliVisualGetVisualProperty01(void)
4868 {
4869   ToolkitTestApplication application;
4870   tet_infoline("UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual");
4871
4872   static std::vector<UniformData> customUniforms =
4873     {
4874       UniformData("mixColor", Property::Type::VECTOR3),
4875       UniformData("offset", Property::Type::VECTOR2),
4876       UniformData("size", Property::Type::VECTOR2),
4877       UniformData("cornerRadius", Property::Type::VECTOR4),
4878       UniformData("blurRadius", Property::Type::FLOAT),
4879       UniformData("borderlineWidth", Property::Type::FLOAT),
4880       UniformData("borderlineColor", Property::Type::VECTOR4),
4881       UniformData("borderlineOffset", Property::Type::FLOAT)};
4882
4883   TestGraphicsController& graphics = application.GetGraphicsController();
4884   graphics.AddCustomUniforms(customUniforms);
4885
4886   VisualFactory factory = VisualFactory::Get();
4887   Property::Map propertyMap;
4888   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4889   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4890   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4891   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4892   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4893   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4894   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4895   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4896   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4897
4898   DummyControl        dummyControl = DummyControl::New(true);
4899   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4900   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4901   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4902   application.GetScene().Add(dummyControl);
4903
4904   application.SendNotification();
4905   application.Render();
4906
4907   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4908   Vector2 targetOffset(0.05f, 0.05f);
4909   Vector2 targetSize(1.1f, 1.1f);
4910   float   targetOpacity = 0.5f;
4911   Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4912   float   targetBlurRadius      = 10.0f;
4913   float   targetBorderlineWidth = 25.0f;
4914   Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4915   float   targetBorderlineOffset = -1.0f;
4916
4917   Animation animation = Animation::New(1.0f);
4918   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4919   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4920   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4921   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4922   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4923   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4924   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4925   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4926   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4927   animation.Play();
4928
4929   application.SendNotification();
4930   application.Render();
4931   application.Render(1001u); // End of animation
4932
4933   Property::Map resultMap;
4934   colorVisual.CreatePropertyMap(resultMap);
4935
4936   // Test property values: they should be updated
4937   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4938   DALI_TEST_CHECK(colorValue);
4939   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4940
4941   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4942   Dali::Property::Map* transformMap   = transformValue->GetMap();
4943   DALI_TEST_CHECK(transformMap);
4944
4945   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4946   DALI_TEST_CHECK(offsetValue);
4947   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4948
4949   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4950   DALI_TEST_CHECK(sizeValue);
4951   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4952
4953   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4954   DALI_TEST_CHECK(cornerRadiusValue);
4955   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
4956
4957   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4958   DALI_TEST_CHECK(blurRadiusValue);
4959   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
4960
4961   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4962   DALI_TEST_CHECK(borderlineWidthValue);
4963   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
4964
4965   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4966   DALI_TEST_CHECK(borderlineColorValue);
4967   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
4968
4969   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4970   DALI_TEST_CHECK(borderlineOffsetValue);
4971   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
4972
4973   // Test uniform values
4974   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4975   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4976   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4977   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4978   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4979   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4980   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4981   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4982
4983   // Test unregistered visual
4984   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4985   DALI_TEST_CHECK(!property3.object);
4986   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4987
4988   END_TEST;
4989 }
4990
4991 int UtcDaliVisualGetVisualProperty02(void)
4992 {
4993   ToolkitTestApplication application;
4994   tet_infoline("UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual");
4995
4996   static std::vector<UniformData> customUniforms =
4997     {
4998       UniformData("mixColor", Property::Type::VECTOR3),
4999       UniformData("offset", Property::Type::VECTOR2),
5000       UniformData("size", Property::Type::VECTOR2),
5001       UniformData("cornerRadius", Property::Type::VECTOR4),
5002       UniformData("borderlineWidth", Property::Type::FLOAT),
5003       UniformData("borderlineCOlor", Property::Type::VECTOR4),
5004       UniformData("borderlineOffset", Property::Type::FLOAT),
5005       UniformData("blurRadius", Property::Type::FLOAT),
5006     };
5007
5008   TestGraphicsController& graphics = application.GetGraphicsController();
5009   graphics.AddCustomUniforms(customUniforms);
5010
5011   VisualFactory factory = VisualFactory::Get();
5012   Property::Map propertyMap;
5013   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
5014   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
5015
5016   DummyControl        dummyControl = DummyControl::New(true);
5017   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5018   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
5019   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5020   application.GetScene().Add(dummyControl);
5021
5022   application.SendNotification();
5023   application.Render();
5024
5025   Vector3 targetColor(1.0f, 1.0f, 1.0f);
5026   Vector2 targetOffset(0.05f, 0.05f);
5027   Vector2 targetSize(1.1f, 1.1f);
5028   float   targetOpacity = 0.5f;
5029   Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
5030   float   targetBorderlineWidth = 77.7f;
5031   Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
5032   float   targetBorderlineOffset = 1.0f;
5033   float   targetBlurRadius       = 10.0f;
5034
5035   // Should work when the properties are not set before
5036   Animation animation = Animation::New(1.0f);
5037   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
5038   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
5039   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
5040   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
5041   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
5042   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
5043   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
5044   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
5045   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
5046   animation.Play();
5047
5048   application.SendNotification();
5049   application.Render();
5050   application.Render(1001u); // End of animation
5051
5052   Property::Map resultMap;
5053   colorVisual.CreatePropertyMap(resultMap);
5054
5055   // Test property values: they should be updated
5056   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
5057   DALI_TEST_CHECK(colorValue);
5058   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
5059
5060   Property::Value*     transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
5061   Dali::Property::Map* transformMap   = transformValue->GetMap();
5062   DALI_TEST_CHECK(transformMap);
5063
5064   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
5065   DALI_TEST_CHECK(offsetValue);
5066   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
5067
5068   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
5069   DALI_TEST_CHECK(sizeValue);
5070   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
5071
5072   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5073   DALI_TEST_CHECK(cornerRadiusValue);
5074   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5075
5076   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5077   DALI_TEST_CHECK(borderlineWidthValue);
5078   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5079
5080   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5081   DALI_TEST_CHECK(borderlineColorValue);
5082   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5083
5084   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5085   DALI_TEST_CHECK(borderlineOffsetValue);
5086   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5087
5088   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
5089   DALI_TEST_CHECK(blurRadiusValue);
5090   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
5091
5092   // Test uniform values
5093   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
5094   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
5095   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
5096   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5097   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
5098
5099   END_TEST;
5100 }
5101
5102 int UtcDaliVisualGetVisualProperty03(void)
5103 {
5104   ToolkitTestApplication application;
5105   tet_infoline("UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual");
5106
5107   static std::vector<UniformData> customUniforms =
5108     {
5109       UniformData("cornerRadius", Property::Type::VECTOR4),
5110       UniformData("borderlineWidth", Property::Type::FLOAT),
5111       UniformData("borderlineColor", Property::Type::VECTOR4),
5112       UniformData("borderlineOffset", Property::Type::FLOAT),
5113     };
5114
5115   TestGraphicsController& graphics = application.GetGraphicsController();
5116   graphics.AddCustomUniforms(customUniforms);
5117
5118   VisualFactory factory = VisualFactory::Get();
5119   Property::Map propertyMap;
5120   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
5121   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
5122
5123   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5124
5125   DummyControl        dummyControl = DummyControl::New(true);
5126   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5127   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5128   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5129   application.GetScene().Add(dummyControl);
5130
5131   // Wait for image loading
5132   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5133
5134   application.SendNotification();
5135   application.Render();
5136
5137   float   targetOpacity = 0.5f;
5138   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5139   float   targetBorderlineWidth = 10.0f;
5140   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5141   float   targetBorderlineOffset = -1.5f;
5142
5143   Animation animation = Animation::New(1.0f);
5144   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5145   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5146   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5147   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5148   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5149   animation.Play();
5150
5151   application.SendNotification();
5152   application.Render();
5153   application.Render(1001u); // End of animation
5154
5155   Property::Map resultMap;
5156   imageVisual.CreatePropertyMap(resultMap);
5157
5158   // Test property values: they should be updated
5159   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5160   DALI_TEST_CHECK(colorValue);
5161   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5162
5163   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5164   DALI_TEST_CHECK(cornerRadiusValue);
5165   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5166
5167   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5168   DALI_TEST_CHECK(borderlineWidthValue);
5169   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5170
5171   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5172   DALI_TEST_CHECK(borderlineColorValue);
5173   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5174
5175   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5176   DALI_TEST_CHECK(borderlineOffsetValue);
5177   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5178
5179   // Test uniform value
5180   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5181   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5182   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5183   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5184
5185   END_TEST;
5186 }
5187
5188 int UtcDaliVisualGetVisualProperty04(void)
5189 {
5190   ToolkitTestApplication application;
5191   tet_infoline("UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual");
5192
5193   static std::vector<UniformData> customUniforms =
5194     {
5195       UniformData("cornerRadius", Property::Type::VECTOR4),
5196     };
5197
5198   TestGraphicsController& graphics = application.GetGraphicsController();
5199   graphics.AddCustomUniforms(customUniforms);
5200
5201   Vector2         start(-1.f, -1.f);
5202   Vector2         end(1.f, 1.f);
5203   Property::Array stopColors;
5204   stopColors.PushBack(Color::RED);
5205   stopColors.PushBack(Color::GREEN);
5206
5207   VisualFactory factory = VisualFactory::Get();
5208   Property::Map propertyMap;
5209   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
5210   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
5211   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
5212   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
5213   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
5214   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
5215   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
5216
5217   DummyControl        dummyControl = DummyControl::New(true);
5218   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5219   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
5220   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5221   application.GetScene().Add(dummyControl);
5222
5223   application.SendNotification();
5224   application.Render();
5225
5226   float   targetOpacity = 0.5f;
5227   Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
5228
5229   Animation animation = Animation::New(1.0f);
5230   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5231   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5232   animation.Play();
5233
5234   application.SendNotification();
5235   application.Render();
5236   application.Render(1001u); // End of animation
5237
5238   Property::Map resultMap;
5239   gradientVisual.CreatePropertyMap(resultMap);
5240
5241   // Test property values: they should be updated
5242   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5243   DALI_TEST_CHECK(colorValue);
5244   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5245
5246   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5247   DALI_TEST_CHECK(cornerRadiusValue);
5248   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5249
5250   // Test uniform value
5251   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5252
5253   END_TEST;
5254 }
5255
5256 int UtcDaliVisualGetVisualProperty05(void)
5257 {
5258   ToolkitTestApplication application;
5259   tet_infoline("UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual");
5260
5261   static std::vector<UniformData> customUniforms =
5262     {
5263       UniformData("cornerRadius", Property::Type::VECTOR4),
5264       UniformData("borderlineWidth", Property::Type::FLOAT),
5265       UniformData("borderlineColor", Property::Type::VECTOR4),
5266       UniformData("borderlineOffset", Property::Type::FLOAT),
5267     };
5268
5269   TestGraphicsController& graphics = application.GetGraphicsController();
5270   graphics.AddCustomUniforms(customUniforms);
5271
5272   VisualFactory factory = VisualFactory::Get();
5273   Property::Map propertyMap;
5274   propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
5275   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
5276
5277   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
5278
5279   DummyControl        dummyControl = DummyControl::New(true);
5280   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5281   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
5282   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5283   application.GetScene().Add(dummyControl);
5284
5285   application.SendNotification();
5286   application.Render();
5287
5288   // Wait for image loading
5289   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5290
5291   application.SendNotification();
5292   application.Render();
5293
5294   float   targetOpacity = 0.5f;
5295   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5296   float   targetBorderlineWidth = 10.0f;
5297   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5298   float   targetBorderlineOffset = -1.5f;
5299
5300   Animation animation = Animation::New(1.0f);
5301   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5302   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5303   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5304   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5305   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5306   animation.Play();
5307
5308   application.SendNotification();
5309   application.Render();
5310   application.Render(1001u); // End of animation
5311
5312   Property::Map resultMap;
5313   svgVisual.CreatePropertyMap(resultMap);
5314
5315   // Test property values: they should be updated
5316   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5317   DALI_TEST_CHECK(colorValue);
5318   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5319
5320   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5321   DALI_TEST_CHECK(cornerRadiusValue);
5322   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5323
5324   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5325   DALI_TEST_CHECK(borderlineWidthValue);
5326   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5327
5328   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5329   DALI_TEST_CHECK(borderlineColorValue);
5330   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5331
5332   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5333   DALI_TEST_CHECK(borderlineOffsetValue);
5334   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5335
5336   // Currently test with multiple program doesn't work well. will fix another day
5337   // Test uniform value
5338   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5339   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5340   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5341   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5342
5343   END_TEST;
5344 }
5345
5346 int UtcDaliVisualGetVisualProperty06(void)
5347 {
5348   ToolkitTestApplication application;
5349   tet_infoline("UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual");
5350
5351   static std::vector<UniformData> customUniforms =
5352     {
5353       UniformData("cornerRadius", Property::Type::VECTOR4),
5354       UniformData("borderlineWidth", Property::Type::FLOAT),
5355       UniformData("borderlineColor", Property::Type::VECTOR4),
5356       UniformData("borderlineOffset", Property::Type::FLOAT),
5357     };
5358
5359   TestGraphicsController& graphics = application.GetGraphicsController();
5360   graphics.AddCustomUniforms(customUniforms);
5361
5362   VisualFactory factory = VisualFactory::Get();
5363   Property::Map propertyMap;
5364   propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5365   propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5366
5367   Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5368
5369   DummyControl        dummyControl = DummyControl::New(true);
5370   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5371   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5372   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5373   application.GetScene().Add(dummyControl);
5374
5375   application.SendNotification();
5376   application.Render();
5377
5378   // Wait for image loading
5379   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5380
5381   application.SendNotification();
5382   application.Render();
5383
5384   float   targetOpacity = 0.5f;
5385   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5386   float   targetBorderlineWidth = 10.0f;
5387   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5388   float   targetBorderlineOffset = -1.5f;
5389
5390   Animation animation = Animation::New(1.0f);
5391   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5392   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5393   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5394   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5395   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5396   animation.Play();
5397
5398   application.SendNotification();
5399   application.Render();
5400   application.Render(1001u); // End of animation
5401
5402   Property::Map resultMap;
5403   animatedImageVisual.CreatePropertyMap(resultMap);
5404
5405   // Test property values: they should be updated
5406   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5407   DALI_TEST_CHECK(colorValue);
5408   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5409
5410   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5411   DALI_TEST_CHECK(cornerRadiusValue);
5412   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5413
5414   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5415   DALI_TEST_CHECK(borderlineWidthValue);
5416   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5417
5418   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5419   DALI_TEST_CHECK(borderlineColorValue);
5420   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5421
5422   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5423   DALI_TEST_CHECK(borderlineOffsetValue);
5424   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5425
5426   // Currently test with multiple program doesn't work well. will fix another day
5427   // Test uniform value
5428   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5429   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5430   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5431   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5432
5433   END_TEST;
5434 }
5435
5436 int UtcDaliVisualGetVisualProperty07(void)
5437 {
5438   ToolkitTestApplication application;
5439   tet_infoline("UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual");
5440
5441   static std::vector<UniformData> customUniforms =
5442     {
5443       UniformData("cornerRadius", Property::Type::VECTOR4),
5444       UniformData("borderlineWidth", Property::Type::FLOAT),
5445       UniformData("borderlineColor", Property::Type::VECTOR4),
5446       UniformData("borderlineOffset", Property::Type::FLOAT),
5447     };
5448
5449   TestGraphicsController& graphics = application.GetGraphicsController();
5450   graphics.AddCustomUniforms(customUniforms);
5451
5452   VisualFactory factory = VisualFactory::Get();
5453   Property::Map propertyMap;
5454   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5455   propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5456
5457   Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5458
5459   DummyControl        dummyControl = DummyControl::New(true);
5460   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5461   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5462   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5463   application.GetScene().Add(dummyControl);
5464
5465   application.SendNotification();
5466   application.Render();
5467
5468   // Wait for image loading
5469   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5470
5471   application.SendNotification();
5472   application.Render();
5473
5474   float   targetOpacity = 0.5f;
5475   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5476   float   targetBorderlineWidth = 10.0f;
5477   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5478   float   targetBorderlineOffset = -1.5f;
5479
5480   Animation animation = Animation::New(1.0f);
5481   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5482   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5483   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5484   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5485   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5486   animation.Play();
5487
5488   application.SendNotification();
5489   application.Render();
5490   application.Render(1001u); // End of animation
5491
5492   Property::Map resultMap;
5493   animatedVectorVisual.CreatePropertyMap(resultMap);
5494
5495   // Test property values: they should be updated
5496   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5497   DALI_TEST_CHECK(colorValue);
5498   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5499
5500   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5501   DALI_TEST_CHECK(cornerRadiusValue);
5502   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5503
5504   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5505   DALI_TEST_CHECK(borderlineWidthValue);
5506   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5507
5508   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5509   DALI_TEST_CHECK(borderlineColorValue);
5510   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5511
5512   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5513   DALI_TEST_CHECK(borderlineOffsetValue);
5514   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5515
5516   // Currently test with multiple program doesn't work well. will fix another day
5517   // Test uniform value
5518   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5519   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5520   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5521   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5522
5523   END_TEST;
5524 }
5525
5526 int UtcDaliVisualUpdateProperty(void)
5527 {
5528   ToolkitTestApplication application;
5529   tet_infoline("UtcDaliVisualUpdateProperty: Test update property by DoAction. Standard case");
5530
5531   VisualFactory factory = VisualFactory::Get();
5532   Property::Map propertyMap;
5533   propertyMap[Visual::Property::TYPE]                     = Visual::Type::IMAGE;
5534   propertyMap[ImageVisual::Property::URL]                 = TEST_IMAGE_FILE_NAME;
5535   propertyMap[Visual::Property::MIX_COLOR]                = Color::BLUE;
5536   propertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = DevelVisual::FIT_WIDTH;
5537
5538   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5539
5540   DummyControl        dummyControl = DummyControl::New(true);
5541   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5542   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5543   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5544   application.GetScene().Add(dummyControl);
5545
5546   application.SendNotification();
5547   application.Render();
5548
5549   // Wait for image loading
5550   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5551
5552   application.SendNotification();
5553   application.Render();
5554
5555   Property::Map originalMap;
5556   imageVisual.CreatePropertyMap(originalMap);
5557
5558   float                    targetOpacity            = 0.5f;
5559   Vector3                  targetMixColor           = Vector3(1.0f, 0.4f, 0.2f);
5560   bool                     targetPreMultipliedAlpha = originalMap[Visual::Property::PREMULTIPLIED_ALPHA].Get<bool>() ^ true;
5561   DevelVisual::FittingMode targetVisualFittingMode  = DevelVisual::CENTER;
5562
5563   Property::Map targetPropertyMap;
5564   targetPropertyMap[Visual::Property::OPACITY]                  = targetOpacity;
5565   targetPropertyMap[ImageVisual::Property::URL]                 = "foobar";
5566   targetPropertyMap[Visual::Property::MIX_COLOR]                = targetMixColor;
5567   targetPropertyMap[Visual::Property::PREMULTIPLIED_ALPHA]      = targetPreMultipliedAlpha;
5568   targetPropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = targetVisualFittingMode;
5569
5570   // Update Properties
5571   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5572
5573   Property::Map resultMap;
5574   imageVisual.CreatePropertyMap(resultMap);
5575
5576   // Test property values: they should be updated
5577   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5578   DALI_TEST_CHECK(colorValue);
5579   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetMixColor.r, targetMixColor.g, targetMixColor.b, targetOpacity), TEST_LOCATION);
5580
5581   Property::Value* urlValue = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
5582   DALI_TEST_CHECK(urlValue);
5583   // NOTE : ImageVisual URL must NOT changed.
5584   DALI_TEST_EQUALS(urlValue->Get<std::string>(), TEST_IMAGE_FILE_NAME, TEST_LOCATION);
5585
5586   Property::Value* preMultipliedValue = resultMap.Find(Visual::Property::PREMULTIPLIED_ALPHA, Property::BOOLEAN);
5587   DALI_TEST_CHECK(preMultipliedValue);
5588   DALI_TEST_EQUALS(preMultipliedValue->Get<bool>(), targetPreMultipliedAlpha, TEST_LOCATION);
5589
5590   Property::Value* visualFittingModeValue = resultMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE, Property::STRING);
5591   DALI_TEST_CHECK(visualFittingModeValue);
5592   DALI_TEST_EQUALS(visualFittingModeValue->Get<std::string>(), "CENTER", TEST_LOCATION);
5593
5594   END_TEST;
5595 }
5596
5597 int UtcDaliVisualUpdatePropertyChangeShader01(void)
5598 {
5599   ToolkitTestApplication application;
5600   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader01: Test update property by DoAction. Change the shader case");
5601
5602   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5603
5604   VisualFactory factory = VisualFactory::Get();
5605   Property::Map propertyMap;
5606   // Case ImageVisual
5607   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
5608   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5609
5610   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5611
5612   DummyControl        dummyControl = DummyControl::New(true);
5613   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5614   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5615   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5616   application.GetScene().Add(dummyControl);
5617
5618   application.SendNotification();
5619   application.Render();
5620
5621   // Wait for image loading
5622   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5623
5624   application.SendNotification();
5625   application.Render();
5626
5627   // Get shader
5628   {
5629     Renderer        renderer = dummyControl.GetRendererAt(0);
5630     Shader          shader   = renderer.GetShader();
5631     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5632     Property::Map*  map      = value.GetMap();
5633     DALI_TEST_CHECK(map);
5634
5635     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5636     DALI_TEST_CHECK(fragment);
5637     std::string fragmentShader;
5638     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5639     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5640     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5641
5642     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5643     std::string      vertexShader;
5644     DALI_TEST_CHECK(vertex->Get(vertexShader));
5645     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5646     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5647   }
5648   callStack.Reset();
5649   callStack.Enable(true);
5650
5651   Vector4 targetCornerRadius = Vector4(1.0f, 12.0f, 2.0f, 21.0f);
5652
5653   Property::Map targetPropertyMap;
5654   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]        = targetCornerRadius;
5655   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
5656
5657   // Update Properties with CornerRadius
5658   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5659
5660   Property::Map resultMap;
5661   imageVisual.CreatePropertyMap(resultMap);
5662
5663   // Test property values: they should be updated
5664   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5665   DALI_TEST_CHECK(cornerRadiusValue);
5666   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5667
5668   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5669   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5670   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
5671
5672   // Get shader
5673   {
5674     Renderer        renderer = dummyControl.GetRendererAt(0);
5675     Shader          shader   = renderer.GetShader();
5676     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5677     Property::Map*  map      = value.GetMap();
5678     DALI_TEST_CHECK(map);
5679
5680     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5681     DALI_TEST_CHECK(fragment);
5682     std::string fragmentShader;
5683     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5684     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5685     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5686
5687     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5688     std::string      vertexShader;
5689     DALI_TEST_CHECK(vertex->Get(vertexShader));
5690     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5691     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5692   }
5693
5694   // Send shader compile signal
5695   application.SendNotification();
5696   application.Render();
5697
5698   callStack.Enable(false);
5699   // Shader changed
5700   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5701   callStack.Reset();
5702   callStack.Enable(true);
5703
5704   float   targetBorderlineWidth  = 10.0f;
5705   Vector4 targetBorderlineColor  = Vector4(1.0f, 0.2f, 0.1f, 0.5f);
5706   float   targetBorderlineOffset = -0.3f;
5707
5708   Property::Map targetPropertyMap2;
5709   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
5710   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5711   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]     = targetBorderlineWidth;
5712   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]     = targetBorderlineColor;
5713   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET]    = targetBorderlineOffset;
5714
5715   // Update Properties with Borderline
5716   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5717
5718   Property::Map resultMap2;
5719   imageVisual.CreatePropertyMap(resultMap2);
5720
5721   // Test property values: they should be updated
5722   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5723   DALI_TEST_CHECK(cornerRadiusValue);
5724   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5725
5726   cornerRadiusPolicyValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5727   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5728   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5729
5730   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5731   DALI_TEST_CHECK(borderlineWidthValue);
5732   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5733
5734   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5735   DALI_TEST_CHECK(borderlineColorValue);
5736   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5737
5738   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5739   DALI_TEST_CHECK(borderlineOffsetValue);
5740   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5741
5742   // Get shader
5743   {
5744     Renderer        renderer = dummyControl.GetRendererAt(0);
5745     Shader          shader   = renderer.GetShader();
5746     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5747     Property::Map*  map      = value.GetMap();
5748     DALI_TEST_CHECK(map);
5749
5750     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5751     DALI_TEST_CHECK(fragment);
5752     std::string fragmentShader;
5753     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5754     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5755     // Note : mAlwaysUsingCornerRadius is true.
5756     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5757
5758     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5759     std::string      vertexShader;
5760     DALI_TEST_CHECK(vertex->Get(vertexShader));
5761     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5762     // Note : mAlwaysUsingCornerRadius is true.
5763     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5764   }
5765
5766   // Send shader compile signal
5767   application.SendNotification();
5768   application.Render();
5769
5770   callStack.Enable(false);
5771   // Shader changed
5772   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
5773   callStack.Reset();
5774   callStack.Enable(true);
5775
5776   Property::Map targetPropertyMap3;
5777   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS]        = Vector4::ZERO;
5778   targetPropertyMap3[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
5779   targetPropertyMap3[DevelVisual::Property::BORDERLINE_WIDTH]     = 0.0f;
5780   targetPropertyMap3[DevelVisual::Property::BORDERLINE_COLOR]     = Vector4::ZERO;
5781   targetPropertyMap3[DevelVisual::Property::BORDERLINE_OFFSET]    = 0.0f;
5782
5783   // Update Properties into zero
5784   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap3);
5785
5786   Property::Map resultMap3;
5787   imageVisual.CreatePropertyMap(resultMap3);
5788
5789   // Test property values: they should be updated
5790   cornerRadiusValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5791   DALI_TEST_CHECK(cornerRadiusValue);
5792   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5793
5794   cornerRadiusPolicyValue = resultMap3.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
5795   DALI_TEST_CHECK(cornerRadiusPolicyValue);
5796   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
5797
5798   borderlineWidthValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5799   DALI_TEST_CHECK(borderlineWidthValue);
5800   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), 0.0f, TEST_LOCATION);
5801
5802   borderlineColorValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5803   DALI_TEST_CHECK(borderlineColorValue);
5804   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
5805
5806   borderlineOffsetValue = resultMap3.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5807   DALI_TEST_CHECK(borderlineOffsetValue);
5808   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), 0.0f, TEST_LOCATION);
5809
5810   // Get shader
5811   {
5812     Renderer        renderer = dummyControl.GetRendererAt(0);
5813     Shader          shader   = renderer.GetShader();
5814     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5815     Property::Map*  map      = value.GetMap();
5816     DALI_TEST_CHECK(map);
5817
5818     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5819     DALI_TEST_CHECK(fragment);
5820     std::string fragmentShader;
5821     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5822     // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5823     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5824     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5825
5826     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5827     std::string      vertexShader;
5828     DALI_TEST_CHECK(vertex->Get(vertexShader));
5829     // Note : mAlwaysUsingBorderline and mAlwaysUsingCornerRadius is true.
5830     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
5831     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
5832   }
5833
5834   // Send shader compile signal
5835   application.SendNotification();
5836   application.Render();
5837
5838   callStack.Enable(false);
5839   // Shader not changed
5840   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
5841
5842   END_TEST;
5843 }
5844
5845 int UtcDaliVisualUpdatePropertyChangeShader02(void)
5846 {
5847   ToolkitTestApplication application;
5848   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader02: Test update property by DoAction. Fake update");
5849
5850   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
5851
5852   VisualFactory factory = VisualFactory::Get();
5853   Property::Map propertyMap;
5854   // Case ImageVisual
5855   propertyMap[Visual::Property::TYPE]     = Visual::Type::IMAGE;
5856   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
5857
5858   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
5859
5860   DummyControl        dummyControl = DummyControl::New(true);
5861   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5862   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
5863   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5864   application.GetScene().Add(dummyControl);
5865
5866   application.SendNotification();
5867   application.Render();
5868
5869   // Wait for image loading
5870   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5871
5872   application.SendNotification();
5873   application.Render();
5874
5875   // Get shader
5876   {
5877     Renderer        renderer = dummyControl.GetRendererAt(0);
5878     Shader          shader   = renderer.GetShader();
5879     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5880     Property::Map*  map      = value.GetMap();
5881     DALI_TEST_CHECK(map);
5882
5883     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5884     DALI_TEST_CHECK(fragment);
5885     std::string fragmentShader;
5886     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5887     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5888     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5889
5890     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5891     std::string      vertexShader;
5892     DALI_TEST_CHECK(vertex->Get(vertexShader));
5893     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5894     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5895   }
5896
5897   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
5898
5899   Property::Map targetPropertyMap;
5900   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS] = targetCornerRadius;
5901
5902   callStack.Reset();
5903   callStack.Enable(true);
5904
5905   // Update Properties with CornerRadius
5906   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
5907
5908   Property::Map resultMap;
5909   imageVisual.CreatePropertyMap(resultMap);
5910
5911   // Test property values: they should be updated
5912   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5913   DALI_TEST_CHECK(cornerRadiusValue);
5914   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
5915
5916   // Get shader
5917   {
5918     Renderer        renderer = dummyControl.GetRendererAt(0);
5919     Shader          shader   = renderer.GetShader();
5920     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5921     Property::Map*  map      = value.GetMap();
5922     DALI_TEST_CHECK(map);
5923
5924     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5925     DALI_TEST_CHECK(fragment);
5926     std::string fragmentShader;
5927     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5928     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5929     // Note : corner radius is zero. so we don't change shader!
5930     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5931
5932     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5933     std::string      vertexShader;
5934     DALI_TEST_CHECK(vertex->Get(vertexShader));
5935     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5936     // Note : corner radius is zero. so we don't change shader!
5937     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5938   }
5939
5940   // Send shader compile signal
5941   application.SendNotification();
5942   application.Render();
5943
5944   callStack.Enable(false);
5945
5946   // Shader doesn't changed
5947   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
5948   callStack.Reset();
5949   callStack.Enable(true);
5950
5951   float   targetBorderlineWidth  = 0.0f;
5952   Vector4 targetBorderlineColor  = Vector4(1.0f, 1.0f, 0.0f, 0.0f);
5953   float   targetBorderlineOffset = -1.0f;
5954
5955   Property::Map targetPropertyMap2;
5956   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH]  = targetBorderlineWidth;
5957   targetPropertyMap2[DevelVisual::Property::BORDERLINE_COLOR]  = targetBorderlineColor;
5958   targetPropertyMap2[DevelVisual::Property::BORDERLINE_OFFSET] = targetBorderlineOffset;
5959
5960   // Update Properties with Borderline
5961   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
5962
5963   Property::Map resultMap2;
5964   imageVisual.CreatePropertyMap(resultMap2);
5965
5966   // Test property values: they should be updated
5967   Property::Value* borderlineWidthValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5968   DALI_TEST_CHECK(borderlineWidthValue);
5969   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
5970
5971   Property::Value* borderlineColorValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5972   DALI_TEST_CHECK(borderlineColorValue);
5973   DALI_TEST_EQUALS(borderlineColorValue->Get<Vector4>(), targetBorderlineColor, TEST_LOCATION);
5974
5975   Property::Value* borderlineOffsetValue = resultMap2.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5976   DALI_TEST_CHECK(borderlineOffsetValue);
5977   DALI_TEST_EQUALS(borderlineOffsetValue->Get<float>(), targetBorderlineOffset, TEST_LOCATION);
5978
5979   // Get shader
5980   {
5981     Renderer        renderer = dummyControl.GetRendererAt(0);
5982     Shader          shader   = renderer.GetShader();
5983     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
5984     Property::Map*  map      = value.GetMap();
5985     DALI_TEST_CHECK(map);
5986
5987     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
5988     DALI_TEST_CHECK(fragment);
5989     std::string fragmentShader;
5990     DALI_TEST_CHECK(fragment->Get(fragmentShader));
5991     // Note : borderline width is zero. so we don't change shader!
5992     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
5993     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
5994
5995     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
5996     std::string      vertexShader;
5997     DALI_TEST_CHECK(vertex->Get(vertexShader));
5998     // Note : borderline width is zero. so we don't change shader!
5999     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6000     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6001   }
6002
6003   // Send shader compile signal
6004   application.SendNotification();
6005   application.Render();
6006
6007   callStack.Enable(false);
6008
6009   // Shader doesn't changed
6010   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6011
6012   END_TEST;
6013 }
6014
6015 int UtcDaliVisualUpdatePropertyChangeShader03(void)
6016 {
6017   ToolkitTestApplication application;
6018   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader03: Test update property by DoAction. Blur Radius");
6019
6020   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6021
6022   VisualFactory factory = VisualFactory::Get();
6023   Property::Map propertyMap;
6024   // Case ImageVisual
6025   propertyMap[Visual::Property::TYPE]           = Visual::Type::COLOR;
6026   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
6027
6028   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6029
6030   DummyControl        dummyControl = DummyControl::New(true);
6031   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6032   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6033   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6034   application.GetScene().Add(dummyControl);
6035
6036   application.SendNotification();
6037   application.Render();
6038
6039   application.SendNotification();
6040   application.Render();
6041
6042   // Get shader
6043   {
6044     Renderer        renderer = dummyControl.GetRendererAt(0);
6045     Shader          shader   = renderer.GetShader();
6046     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6047     Property::Map*  map      = value.GetMap();
6048     DALI_TEST_CHECK(map);
6049
6050     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6051     DALI_TEST_CHECK(fragment);
6052     std::string fragmentShader;
6053     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6054     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6055     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6056     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6057
6058     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6059     std::string      vertexShader;
6060     DALI_TEST_CHECK(vertex->Get(vertexShader));
6061     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") == std::string::npos);
6062     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6063     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") == std::string::npos);
6064   }
6065
6066   float   targetBlurRadius   = 15.0f;
6067   Vector4 targetCornerRadius = Vector4(1.0f, 0.1f, 1.1f, 0.0f);
6068
6069   Property::Map targetPropertyMap;
6070   targetPropertyMap[DevelColorVisual::Property::BLUR_RADIUS] = targetBlurRadius;
6071   targetPropertyMap[DevelVisual::Property::CORNER_RADIUS]    = targetCornerRadius;
6072   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = 10.0f; // Don't care. just dummy
6073
6074   callStack.Reset();
6075   callStack.Enable(true);
6076
6077   // Update Properties with CornerRadius
6078   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6079
6080   Property::Map resultMap;
6081   imageVisual.CreatePropertyMap(resultMap);
6082
6083   // Test property values: they should be updated
6084   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6085   DALI_TEST_CHECK(blurRadiusValue);
6086   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), targetBlurRadius, TEST_LOCATION);
6087
6088   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6089   DALI_TEST_CHECK(cornerRadiusValue);
6090   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6091
6092   // Get shader
6093   {
6094     Renderer        renderer = dummyControl.GetRendererAt(0);
6095     Shader          shader   = renderer.GetShader();
6096     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6097     Property::Map*  map      = value.GetMap();
6098     DALI_TEST_CHECK(map);
6099
6100     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6101     DALI_TEST_CHECK(fragment);
6102     std::string fragmentShader;
6103     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6104     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6105     // Note : We ignore borderline when blur radius occured
6106     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6107     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6108
6109     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6110     std::string      vertexShader;
6111     DALI_TEST_CHECK(vertex->Get(vertexShader));
6112     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6113     // Note : We ignore borderline when blur radius occured
6114     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6115     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6116   }
6117
6118   // Send shader compile signal
6119   application.SendNotification();
6120   application.Render();
6121
6122   callStack.Enable(false);
6123
6124   // Shader changed
6125   DALI_TEST_CHECK((callStack.FindMethod("CreateShader")));
6126   callStack.Reset();
6127   callStack.Enable(true);
6128
6129   Property::Map targetPropertyMap2;
6130   targetPropertyMap2[DevelColorVisual::Property::BLUR_RADIUS] = 0.0f;
6131   targetPropertyMap2[DevelVisual::Property::CORNER_RADIUS]    = Vector4::ZERO;
6132   targetPropertyMap2[DevelVisual::Property::BORDERLINE_WIDTH] = 15.0f; // Don't care. just dummy
6133
6134   // Update Properties with CornerRadius
6135   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap2);
6136
6137   Property::Map resultMap2;
6138   imageVisual.CreatePropertyMap(resultMap2);
6139
6140   // Test property values: they should be updated
6141   blurRadiusValue = resultMap2.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
6142   DALI_TEST_CHECK(blurRadiusValue);
6143   DALI_TEST_EQUALS(blurRadiusValue->Get<float>(), 0.0f, TEST_LOCATION);
6144
6145   cornerRadiusValue = resultMap2.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6146   DALI_TEST_CHECK(cornerRadiusValue);
6147   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), Vector4::ZERO, TEST_LOCATION);
6148
6149   // Get shader
6150   {
6151     Renderer        renderer = dummyControl.GetRendererAt(0);
6152     Shader          shader   = renderer.GetShader();
6153     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6154     Property::Map*  map      = value.GetMap();
6155     DALI_TEST_CHECK(map);
6156
6157     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6158     DALI_TEST_CHECK(fragment);
6159     std::string fragmentShader;
6160     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6161     // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6162     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6163     // Note : We ignore borderline when blur radius occured
6164     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6165     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6166
6167     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6168     std::string      vertexShader;
6169     DALI_TEST_CHECK(vertex->Get(vertexShader));
6170     // Note : mAlwaysUsingBlurRadius and mAlwaysUsingCornerRadius is true.
6171     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BLUR 1") != std::string::npos);
6172     // Note : We ignore borderline when blur radius occured
6173     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6174     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6175   }
6176
6177   // Send shader compile signal
6178   application.SendNotification();
6179   application.Render();
6180
6181   callStack.Enable(false);
6182
6183   // Shader not changed
6184   DALI_TEST_CHECK(!(callStack.FindMethod("CreateShader")));
6185
6186   END_TEST;
6187 }
6188
6189 int UtcDaliVisualUpdatePropertyChangeShader04(void)
6190 {
6191   ToolkitTestApplication application;
6192   tet_infoline("UtcDaliVisualUpdatePropertyChangeShader04: Test update property by DoAction during Animation. Change the shader case");
6193
6194   TraceCallStack& callStack = application.GetGraphicsController().mCallStack;
6195
6196   VisualFactory factory = VisualFactory::Get();
6197   Property::Map propertyMap;
6198   // Case ImageVisual
6199   propertyMap[Visual::Property::TYPE]               = Visual::Type::IMAGE;
6200   propertyMap[ImageVisual::Property::URL]           = TEST_IMAGE_FILE_NAME;
6201   propertyMap[DevelVisual::Property::CORNER_RADIUS] = 10.0f;
6202
6203   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
6204
6205   DummyControl        dummyControl = DummyControl::New(true);
6206   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
6207   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
6208   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
6209   application.GetScene().Add(dummyControl);
6210
6211   application.SendNotification();
6212   application.Render();
6213
6214   // Wait for image loading
6215   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
6216
6217   application.SendNotification();
6218   application.Render();
6219
6220   // Get shader
6221   {
6222     Renderer        renderer = dummyControl.GetRendererAt(0);
6223     Shader          shader   = renderer.GetShader();
6224     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6225     Property::Map*  map      = value.GetMap();
6226     DALI_TEST_CHECK(map);
6227
6228     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6229     DALI_TEST_CHECK(fragment);
6230     std::string fragmentShader;
6231     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6232     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6233     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6234
6235     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6236     std::string      vertexShader;
6237     DALI_TEST_CHECK(vertex->Get(vertexShader));
6238     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6239     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6240   }
6241   callStack.Reset();
6242   callStack.Enable(true);
6243
6244   Vector4 targetCornerRadius = Vector4(0.0f, 0.0f, 0.0f, 0.0f);
6245
6246   Animation animation = Animation::New(1.0f);
6247   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
6248   animation.Play();
6249
6250   application.SendNotification();
6251   application.Render();
6252   application.Render(1001u); // End of animation
6253
6254   // Get shader
6255   {
6256     Renderer        renderer = dummyControl.GetRendererAt(0);
6257     Shader          shader   = renderer.GetShader();
6258     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6259     Property::Map*  map      = value.GetMap();
6260     DALI_TEST_CHECK(map);
6261
6262     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6263     DALI_TEST_CHECK(fragment);
6264     std::string fragmentShader;
6265     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6266     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6267     // Note : mAlwaysUsingCornerRadius is true.
6268     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6269
6270     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6271     std::string      vertexShader;
6272     DALI_TEST_CHECK(vertex->Get(vertexShader));
6273     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") == std::string::npos);
6274     // Note : mAlwaysUsingCornerRadius is true.
6275     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6276   }
6277   callStack.Enable(false);
6278   // Shader not changed
6279   DALI_TEST_CHECK(!callStack.FindMethod("CreateShader"));
6280   callStack.Reset();
6281   callStack.Enable(true);
6282
6283   float         targetBorderlineWidth = 10.0f;
6284   Property::Map targetPropertyMap;
6285   targetPropertyMap[DevelVisual::Property::BORDERLINE_WIDTH] = targetBorderlineWidth;
6286
6287   // Update Properties with CornerRadius
6288   DevelControl::DoAction(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Action::UPDATE_PROPERTY, targetPropertyMap);
6289
6290   Property::Map resultMap;
6291   imageVisual.CreatePropertyMap(resultMap);
6292
6293   // Test property values: they should be updated
6294   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
6295   DALI_TEST_CHECK(cornerRadiusValue);
6296   DALI_TEST_EQUALS(cornerRadiusValue->Get<Vector4>(), targetCornerRadius, TEST_LOCATION);
6297
6298   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
6299   DALI_TEST_CHECK(cornerRadiusPolicyValue);
6300   DALI_TEST_EQUALS(cornerRadiusPolicyValue->Get<int>(), static_cast<int>(Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
6301
6302   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
6303   DALI_TEST_CHECK(borderlineWidthValue);
6304   DALI_TEST_EQUALS(borderlineWidthValue->Get<float>(), targetBorderlineWidth, TEST_LOCATION);
6305
6306   // Get shader
6307   {
6308     Renderer        renderer = dummyControl.GetRendererAt(0);
6309     Shader          shader   = renderer.GetShader();
6310     Property::Value value    = shader.GetProperty(Shader::Property::PROGRAM);
6311     Property::Map*  map      = value.GetMap();
6312     DALI_TEST_CHECK(map);
6313
6314     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
6315     DALI_TEST_CHECK(fragment);
6316     std::string fragmentShader;
6317     DALI_TEST_CHECK(fragment->Get(fragmentShader));
6318     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6319     // Note : mAlwaysUsingCornerRadius is true.
6320     DALI_TEST_CHECK(fragmentShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6321
6322     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
6323     std::string      vertexShader;
6324     DALI_TEST_CHECK(vertex->Get(vertexShader));
6325     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_BORDERLINE 1") != std::string::npos);
6326     // Note : mAlwaysUsingCornerRadius is true.
6327     DALI_TEST_CHECK(vertexShader.find("#define IS_REQUIRED_ROUNDED_CORNER 1") != std::string::npos);
6328   }
6329
6330   // Send shader compile signal
6331   application.SendNotification();
6332   application.Render();
6333
6334   callStack.Enable(false);
6335   // Shader changed
6336   DALI_TEST_CHECK(callStack.FindMethod("CreateShader"));
6337
6338   END_TEST;
6339 }