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