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