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