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