automated-tests/src/dali-toolkit/utc-Dali-Visual.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <iostream>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali-toolkit/dali-toolkit.h>
  23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  24 #include <dali-toolkit/devel-api/controls/control-devel.h>
  25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
  26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
  29 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
  30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
  33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  34 #include <dali/devel-api/actors/actor-devel.h>
  35 #include <dali/devel-api/object/handle-devel.h>
  36 #include <dali/devel-api/text-abstraction/font-client.h>
  37 #include <toolkit-event-thread-callback.h>
  38
  39 #include "dummy-control.h"
  40
  41 using namespace Dali;
  42 using namespace Dali::Toolkit;
  43
  44 namespace
  45 {
  46 const char* TEST_GIF_FILE_NAME          = TEST_RESOURCE_DIR "/anim.gif";
  47 const char* TEST_IMAGE_FILE_NAME        = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  48 const char* TEST_NPATCH_FILE_NAME       = TEST_RESOURCE_DIR "/button-up.9.png";
  49 const char* TEST_SVG_FILE_NAME          = TEST_RESOURCE_DIR "/svg1.svg";
  50 const char* TEST_OBJ_FILE_NAME          = TEST_RESOURCE_DIR "/Cube.obj";
  51 const char* TEST_MTL_FILE_NAME          = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
  53 const char* TEST_RESOURCE_LOCATION      = TEST_RESOURCE_DIR "/";
  54
  55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
  56
  57 Property::Map DefaultTransform()
  58 {
  59   Property::Map transformMap;
  60   transformMap
  61     .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
  62     .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
  63     .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
  64     .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
  65     .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
  66     .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
  67   return transformMap;
  68 }
  69
  70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
  71 {
  72   if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
  73   {
  74     for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
  75     {
  76       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
  77
  78       Property::Value* valueSet = NULL;
  79       if(valueGet.first.type == Property::Key::INDEX)
  80       {
  81         valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
  82       }
  83       else
  84       {
  85         // Get Key is a string so searching Set Map for a string key
  86         valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
  87       }
  88
  89       if(NULL != valueSet)
  90       {
  91         if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
  92         {
  93           tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
  94           return false;
  95         }
  96         else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
  97         {
  98           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
  99           return false;
 100         }
 101         else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
 102         {
 103           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
 104           return false;
 105         }
 106         else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
 107         {
 108           tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
 109           return false;
 110         }
 111         else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
 112         {
 113           Vector2 vector2Get = valueGet.second.Get<Vector2>();
 114           Vector2 vector2Set = valueSet->Get<Vector2>();
 115           tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
 116           return false;
 117         }
 118         else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
 119         {
 120           Vector4 vector4Get = valueGet.second.Get<Vector4>();
 121           Vector4 vector4Set = valueSet->Get<Vector4>();
 122           tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
 123           return false;
 124         }
 125       }
 126       else
 127       {
 128         if(valueGet.first.type == Property::Key::INDEX)
 129         {
 130           tet_printf("  The key %d doesn't exist.", valueGet.first.indexKey);
 131         }
 132         else
 133         {
 134           tet_printf("  The key %s doesn't exist.", valueGet.first.stringKey.c_str());
 135         }
 136         return false;
 137       }
 138     }
 139   }
 140
 141   return true;
 142 }
 143
 144 } //namespace
 145
 146 void dali_visual_startup(void)
 147 {
 148   test_return_value = TET_UNDEF;
 149 }
 150
 151 void dali_visual_cleanup(void)
 152 {
 153   test_return_value = TET_PASS;
 154 }
 155
 156 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
 157 {
 158   Property::Map map;
 159   visual.CreatePropertyMap(map);
 160   Property::Value* value = map.Find(mixColorIndex);
 161   DALI_TEST_CHECK(value);
 162   Vector3 mixColor1;
 163   DALI_TEST_CHECK(value->Get(mixColor1));
 164   DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
 165
 166   value = map.Find(Visual::Property::MIX_COLOR);
 167   DALI_TEST_CHECK(value);
 168   Vector4 mixColor2;
 169   DALI_TEST_CHECK(value->Get(mixColor2));
 170   DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
 171
 172   value = map.Find(Visual::Property::OPACITY);
 173   DALI_TEST_CHECK(value);
 174   float opacity;
 175   DALI_TEST_CHECK(value->Get(opacity));
 176   DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
 177 }
 178
 179 int UtcDaliVisualCopyAndAssignment(void)
 180 {
 181   ToolkitTestApplication application;
 182   tet_infoline("UtcDaliVisualCopyAndAssignment");
 183
 184   VisualFactory factory = VisualFactory::Get();
 185   Property::Map propertyMap;
 186   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 187   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 188   Visual::Base visual = factory.CreateVisual(propertyMap);
 189
 190   Visual::Base visualCopy(visual);
 191   DALI_TEST_CHECK(visual == visualCopy);
 192
 193   Visual::Base emptyVisual;
 194   Visual::Base emptyVisualCopy(emptyVisual);
 195   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 196
 197   Visual::Base visualEquals;
 198   visualEquals = visual;
 199   DALI_TEST_CHECK(visual == visualEquals);
 200
 201   Visual::Base emptyVisualEquals;
 202   emptyVisualEquals = emptyVisual;
 203   DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
 204
 205   //self assignment
 206   visual = visual;
 207   DALI_TEST_CHECK(visual = visualCopy);
 208
 209   END_TEST;
 210 }
 211
 212 int UtcDaliVisualSetName01(void)
 213 {
 214   ToolkitTestApplication application;
 215   tet_infoline("UtcDaliVisualSetName");
 216
 217   VisualFactory factory = VisualFactory::Get();
 218   Property::Map propertyMap;
 219   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 220   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 221   Visual::Base visual = factory.CreateVisual(propertyMap);
 222
 223   const char* visualName = "backgroundVisual";
 224   visual.SetName(visualName);
 225
 226   DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
 227
 228   END_TEST;
 229 }
 230
 231 int UtcDaliVisualSetGetDepthIndex(void)
 232 {
 233   ToolkitTestApplication application;
 234   tet_infoline("UtcDaliVisualSetDepthIndex");
 235
 236   VisualFactory factory = VisualFactory::Get();
 237   Property::Map propertyMap;
 238   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 239   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 240   Visual::Base visual = factory.CreateVisual(propertyMap);
 241
 242   visual.SetDepthIndex(1);
 243
 244   DummyControl        dummyControl = DummyControl::New(true);
 245   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 246   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 247
 248   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 249   application.GetScene().Add(dummyControl);
 250
 251   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
 252   DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
 253   DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
 254
 255   visual.SetDepthIndex(-1);
 256   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
 257   DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
 258   DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
 259
 260   END_TEST;
 261 }
 262
 263 int UtcDaliVisualSize(void)
 264 {
 265   ToolkitTestApplication application;
 266   tet_infoline("UtcDaliVisualSize");
 267
 268   VisualFactory factory = VisualFactory::Get();
 269   Vector2       controlSize(20.f, 30.f);
 270   Vector2       naturalSize;
 271
 272   // color colorVisual
 273   Dali::Property::Map map;
 274   map[Toolkit::Visual::Property::TYPE]  = Visual::COLOR;
 275   map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
 276
 277   Visual::Base colorVisual = factory.CreateVisual(map);
 278   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 279
 280   colorVisual.GetNaturalSize(naturalSize);
 281   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 282
 283   // image visual
 284   map.Clear();
 285   map[Toolkit::Visual::Property::TYPE]                = Toolkit::Visual::IMAGE;
 286   map[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_FILE_NAME;
 287   map[Toolkit::ImageVisual::Property::DESIRED_WIDTH]  = 100.0f;
 288   map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
 289   Visual::Base imageVisual                            = factory.CreateVisual(map);
 290   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 291
 292   imageVisual.GetNaturalSize(naturalSize);
 293   DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
 294
 295   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 296
 297   // border visual
 298   float borderSize = 5.f;
 299   map.Clear();
 300   map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
 301   map[BorderVisual::Property::COLOR]   = Color::RED;
 302   map[BorderVisual::Property::SIZE]    = borderSize;
 303   Visual::Base borderVisual            = factory.CreateVisual(map);
 304   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 305   borderVisual.GetNaturalSize(naturalSize);
 306   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 307
 308   // gradient gradientVisual
 309   Property::Map propertyMap;
 310   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 311   Vector2 start(-1.f, -1.f);
 312   Vector2 end(1.f, 1.f);
 313   propertyMap.Insert("mixColor", Color::MAGENTA);
 314   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
 315   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
 316   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
 317   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 318   Property::Array stopColors;
 319   stopColors.PushBack(Color::RED);
 320   stopColors.PushBack(Color::GREEN);
 321   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 322   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 323   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 324   gradientVisual.GetNaturalSize(naturalSize);
 325   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 326
 327   // animated gradient visual
 328   Vector2 animated_gradient_visual_size(10.f, 10.f);
 329   propertyMap.Clear();
 330   propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
 331   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
 332   animatedGradientVisual.GetNaturalSize(naturalSize);
 333   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 334   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 335
 336   // svg visual
 337   Visual::Base svgVisual = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
 338   svgVisual.GetNaturalSize(naturalSize);
 339   // TEST_SVG_FILE:
 340   //  <svg width="100" height="100">
 341   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 342   //  </svg>
 343   DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION);
 344
 345   // svg visual with a size
 346   Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(200, 200));
 347   svgVisual2.GetNaturalSize(naturalSize);
 348   DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION); // Natural size should still be 100, 100
 349
 350   // Text visual.
 351
 352   // Load some fonts to get the same metrics on different platforms.
 353   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 354   fontClient.SetDpi(96u, 96u);
 355
 356   char*             pathNamePtr = get_current_dir_name();
 357   const std::string pathName(pathNamePtr);
 358   free(pathNamePtr);
 359
 360   fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
 361
 362   // Create a TextVisual with a font size of 12 first
 363   propertyMap.Clear();
 364   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
 365   propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
 366   propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
 367   propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
 368
 369   Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
 370   Vector2      smallTextVisualNaturalSize;
 371   smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
 372
 373   // Then create a TextVisual with a font size of 20
 374   propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
 375   Visual::Base largeTextVisual            = factory.CreateVisual(propertyMap);
 376   Vector2      largeTextVisualNaturalSize;
 377   largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
 378
 379   // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
 380   DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
 381                   smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
 382
 383   // The height returned for a particular width should also be greater for the large text visual
 384   DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
 385
 386   //AnimatedImageVisual
 387   Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
 388   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
 389   animatedImageVisual.GetNaturalSize(naturalSize);
 390   // TEST_GIF_FILE: anim.gif
 391   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 392   DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
 393
 394   END_TEST;
 395 }
 396
 397 int UtcDaliVisualSetOnOffScene(void)
 398 {
 399   ToolkitTestApplication application;
 400   tet_infoline("UtcDaliVisualSetOnOffScene");
 401
 402   VisualFactory factory = VisualFactory::Get();
 403   Property::Map propertyMap;
 404   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 405   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 406   Visual::Base visual = factory.CreateVisual(propertyMap);
 407
 408   DummyControl        actor     = DummyControl::New(true);
 409   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 410   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 411
 412   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 413
 414   application.SendNotification();
 415   application.Render(0);
 416   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 417
 418   application.GetScene().Add(actor);
 419
 420   application.SendNotification();
 421   application.Render(0);
 422   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 423
 424   application.GetScene().Remove(actor);
 425
 426   application.SendNotification();
 427   application.Render(0);
 428   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 429
 430   END_TEST;
 431 }
 432
 433 int UtcDaliVisualSetOnOffScene2(void)
 434 {
 435   ToolkitTestApplication application;
 436   tet_infoline("UtcDaliVisualSetOnOffScene2");
 437
 438   VisualFactory factory = VisualFactory::Get();
 439   Property::Map propertyMap;
 440   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
 441   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
 442   Visual::Base visual = factory.CreateVisual(propertyMap);
 443
 444   DummyControl        actor     = DummyControl::New(true);
 445   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 446   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
 447
 448   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
 449
 450   application.SendNotification();
 451   application.Render(0);
 452   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 453
 454   // First on/off
 455   application.GetScene().Add(actor);
 456
 457   application.SendNotification();
 458   application.Render(0);
 459   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 460   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 461   Renderer renderer = actor.GetRendererAt(0);
 462   auto     textures = renderer.GetTextures();
 463   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
 464
 465   application.GetScene().Remove(actor);
 466
 467   application.SendNotification();
 468   application.Render(0);
 469   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 470
 471   // Second on/off
 472   application.GetScene().Add(actor);
 473
 474   application.SendNotification();
 475   application.Render(0);
 476   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 477   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
 478   renderer = actor.GetRendererAt(0);
 479   textures = renderer.GetTextures();
 480   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
 481
 482   application.GetScene().Remove(actor);
 483
 484   application.SendNotification();
 485   application.Render(0);
 486   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
 487
 488   END_TEST;
 489 }
 490
 491 int UtcDaliVisualGetPropertyMap1(void)
 492 {
 493   ToolkitTestApplication application;
 494   tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
 495
 496   VisualFactory factory = VisualFactory::Get();
 497   Property::Map propertyMap;
 498   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
 499   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
 500   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
 501   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
 502   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
 503   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
 504   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
 505   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
 506   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
 507
 508   Property::Map resultMap;
 509   colorVisual.CreatePropertyMap(resultMap);
 510
 511   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 512   DALI_TEST_CHECK(typeValue);
 513   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
 514
 515   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
 516   DALI_TEST_CHECK(colorValue);
 517   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
 518
 519   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 520   DALI_TEST_CHECK(cornerRadiusValue);
 521   DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
 522
 523   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
 524   DALI_TEST_CHECK(cornerRadiusPolicyValue);
 525   DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
 526
 527   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 528   DALI_TEST_CHECK(borderlineWidthValue);
 529   DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
 530
 531   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
 532   DALI_TEST_CHECK(borderlineColorValue);
 533   DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
 534
 535   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
 536   DALI_TEST_CHECK(borderlineOffsetValue);
 537   DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
 538
 539   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
 540   DALI_TEST_CHECK(blurRadiusValue);
 541   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
 542
 543   // change the blend color
 544   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 545   colorVisual                                   = factory.CreateVisual(propertyMap);
 546   colorVisual.CreatePropertyMap(resultMap);
 547
 548   colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
 549   DALI_TEST_CHECK(colorValue);
 550   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
 551
 552   // Test wrong values
 553   propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
 554
 555   colorVisual = factory.CreateVisual(propertyMap);
 556   colorVisual.CreatePropertyMap(resultMap);
 557
 558   blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
 559   DALI_TEST_CHECK(blurRadiusValue);
 560   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
 561
 562   END_TEST;
 563 }
 564
 565 int UtcDaliVisualGetPropertyMap2(void)
 566 {
 567   ToolkitTestApplication application;
 568   tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
 569
 570   VisualFactory factory = VisualFactory::Get();
 571   Property::Map propertyMap;
 572   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
 573   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
 574   propertyMap.Insert("borderColor", Color::BLUE);
 575   propertyMap.Insert("borderSize", 5.f);
 576   propertyMap.Insert("antiAliasing", true);
 577   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
 578
 579   Property::Map resultMap;
 580   borderVisual.CreatePropertyMap(resultMap);
 581
 582   // check the property values from the returned map from visual
 583   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 584   DALI_TEST_CHECK(typeValue);
 585   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
 586
 587   Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
 588   DALI_TEST_CHECK(colorValue);
 589   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
 590
 591   Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
 592   DALI_TEST_CHECK(sizeValue);
 593   DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
 594
 595   Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
 596   DALI_TEST_CHECK(AAValue);
 597   DALI_TEST_CHECK(AAValue->Get<bool>() == true);
 598
 599   Property::Map propertyMap1;
 600   propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
 601   propertyMap1[BorderVisual::Property::COLOR]   = Color::CYAN;
 602   propertyMap1[BorderVisual::Property::SIZE]    = 10.0f;
 603   borderVisual                                  = factory.CreateVisual(propertyMap1);
 604   borderVisual.CreatePropertyMap(resultMap);
 605
 606   typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 607   DALI_TEST_CHECK(typeValue);
 608   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
 609
 610   colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
 611   DALI_TEST_CHECK(colorValue);
 612   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
 613
 614   sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
 615   DALI_TEST_CHECK(sizeValue);
 616   DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
 617
 618   // Get default value of borderline values here
 619
 620   sizeValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 621   DALI_TEST_CHECK(sizeValue);
 622   DALI_TEST_CHECK(sizeValue->Get<float>() == 0.0f);
 623
 624   colorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
 625   DALI_TEST_CHECK(colorValue);
 626   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLACK);
 627
 628   sizeValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
 629   DALI_TEST_CHECK(sizeValue);
 630   DALI_TEST_CHECK(sizeValue->Get<float>() == 0.0f);
 631
 632   END_TEST;
 633 }
 634
 635 int UtcDaliVisualGetPropertyMap2N(void)
 636 {
 637   ToolkitTestApplication application;
 638   tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
 639
 640   VisualFactory factory = VisualFactory::Get();
 641   Property::Map propertyMap;
 642   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
 643   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
 644
 645   tet_infoline("Test that the visual is created, with a default renderer");
 646   DALI_TEST_CHECK(borderVisual);
 647
 648   DummyControl        dummyControl = DummyControl::New(true);
 649   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 650   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
 651   application.GetScene().Add(dummyControl);
 652
 653   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
 654
 655   END_TEST;
 656 }
 657
 658 int UtcDaliVisualGetPropertyMap3(void)
 659 {
 660   ToolkitTestApplication application;
 661   tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
 662
 663   VisualFactory factory = VisualFactory::Get();
 664   DALI_TEST_CHECK(factory);
 665
 666   Property::Map propertyMap;
 667   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 668
 669   Vector2 start(-1.f, -1.f);
 670   Vector2 end(1.f, 1.f);
 671   propertyMap.Insert("startPosition", start);
 672   propertyMap.Insert("endPosition", end);
 673   propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 674
 675   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
 676
 677   Property::Array stopColors;
 678   stopColors.PushBack(Color::RED);
 679   stopColors.PushBack(Color::GREEN);
 680   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 681
 682   float   borderlineWidth = 4.0f;
 683   Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
 684   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
 685   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
 686
 687   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 688
 689   Property::Map resultMap;
 690   gradientVisual.CreatePropertyMap(resultMap);
 691
 692   // check the property values from the returned map from visual
 693   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 694   DALI_TEST_CHECK(value);
 695   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
 696
 697   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
 698   DALI_TEST_CHECK(value);
 699   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
 700
 701   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
 702   DALI_TEST_CHECK(value);
 703   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
 704
 705   value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
 706   DALI_TEST_CHECK(value);
 707   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 708
 709   value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
 710   DALI_TEST_CHECK(value);
 711   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 712
 713   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 714   DALI_TEST_CHECK(value);
 715   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 716
 717   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 718   DALI_TEST_CHECK(value);
 719   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 720
 721   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
 722   DALI_TEST_CHECK(value);
 723   Property::Array* offsetArray = value->GetArray();
 724   DALI_TEST_CHECK(offsetArray->Count() == 2);
 725   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 726   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 727
 728   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
 729   DALI_TEST_CHECK(value);
 730   Property::Array* colorArray = value->GetArray();
 731   DALI_TEST_CHECK(colorArray->Count() == 2);
 732   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 733   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 734
 735   END_TEST;
 736 }
 737
 738 int UtcDaliVisualGetPropertyMap4(void)
 739 {
 740   ToolkitTestApplication application;
 741   tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
 742
 743   VisualFactory factory = VisualFactory::Get();
 744   DALI_TEST_CHECK(factory);
 745
 746   Property::Map propertyMap;
 747   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 748
 749   Vector2 center(100.f, 100.f);
 750   float   radius = 100.f;
 751   propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
 752   propertyMap.Insert(GradientVisual::Property::CENTER, center);
 753   propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
 754   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
 755
 756   Property::Array stopColors;
 757   stopColors.PushBack(Color::RED);
 758   stopColors.PushBack(Color::BLACK);
 759   stopColors.PushBack(Color::GREEN);
 760   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 761
 762   float   borderlineWidth = 8.0f;
 763   Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
 764   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
 765   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
 766
 767   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 768   DALI_TEST_CHECK(gradientVisual);
 769
 770   Property::Map resultMap;
 771   gradientVisual.CreatePropertyMap(resultMap);
 772
 773   // check the property values from the returned map from visual
 774   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 775   DALI_TEST_CHECK(value);
 776   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
 777
 778   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
 779   DALI_TEST_CHECK(value);
 780   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
 781
 782   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
 783   DALI_TEST_CHECK(value);
 784   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
 785
 786   value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
 787   DALI_TEST_CHECK(value);
 788   DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 789
 790   value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
 791   DALI_TEST_CHECK(value);
 792   DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 793
 794   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
 795   DALI_TEST_CHECK(value);
 796   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 797
 798   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
 799   DALI_TEST_CHECK(value);
 800   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 801
 802   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
 803   DALI_TEST_CHECK(value);
 804   Property::Array* offsetArray = value->GetArray();
 805   DALI_TEST_CHECK(offsetArray->Count() == 3);
 806   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 807   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 808   // any stop value will be clamped to [0.0, 1.0];
 809   DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 810
 811   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
 812   DALI_TEST_CHECK(value);
 813   Property::Array* colorArray = value->GetArray();
 814   DALI_TEST_CHECK(colorArray->Count() == 3);
 815   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 816   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 817   DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 818
 819   END_TEST;
 820 }
 821
 822 int UtcDaliVisualGetPropertyMap5(void)
 823 {
 824   ToolkitTestApplication application;
 825   tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
 826
 827   VisualFactory factory = VisualFactory::Get();
 828   Property::Map propertyMap;
 829   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
 830   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
 831   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
 832   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
 833   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
 834   propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
 835   propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
 836   propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
 837   propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
 838   propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
 839   propertyMap.Insert("synchronousLoading", true);
 840
 841   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 842   DALI_TEST_CHECK(imageVisual);
 843
 844   Property::Map resultMap;
 845   imageVisual.CreatePropertyMap(resultMap);
 846
 847   // check the property values from the returned map from visual
 848   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 849   DALI_TEST_CHECK(value);
 850   DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
 851
 852   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 853   DALI_TEST_CHECK(value);
 854   DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
 855
 856   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 857   DALI_TEST_CHECK(value);
 858   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 859
 860   value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
 861   DALI_TEST_CHECK(value);
 862   DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
 863
 864   value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
 865   DALI_TEST_CHECK(value);
 866   DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
 867
 868   value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
 869   DALI_TEST_CHECK(value);
 870   DALI_TEST_CHECK(value->Get<int>() == 20);
 871
 872   value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
 873   DALI_TEST_CHECK(value);
 874   DALI_TEST_CHECK(value->Get<int>() == 30);
 875
 876   value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
 877   DALI_TEST_CHECK(value);
 878   DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
 879
 880   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
 881   DALI_TEST_CHECK(value);
 882   DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
 883
 884   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
 885   DALI_TEST_CHECK(value);
 886   DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 887
 888   value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
 889   DALI_TEST_CHECK(value);
 890   DALI_TEST_CHECK(value->Get<bool>() == true);
 891
 892   END_TEST;
 893 }
 894
 895 int UtcDaliVisualGetPropertyMap6(void)
 896 {
 897   ToolkitTestApplication application;
 898   tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
 899
 900   Rect<int> border(1, 1, 1, 1);
 901
 902   VisualFactory factory = VisualFactory::Get();
 903   Property::Map propertyMap;
 904   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
 905   propertyMap.Insert("mixColor", Color::MAGENTA);
 906   propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
 907   propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
 908   propertyMap.Insert(ImageVisual::Property::BORDER, border);
 909   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
 910   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
 911   Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
 912
 913   Property::Map resultMap;
 914   nPatchVisual.CreatePropertyMap(resultMap);
 915
 916   // check the property values from the returned map from visual
 917   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 918   DALI_TEST_CHECK(value);
 919   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
 920
 921   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 922   DALI_TEST_CHECK(value);
 923   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 924
 925   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 926   DALI_TEST_CHECK(value);
 927   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
 928
 929   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
 930   DALI_TEST_CHECK(value);
 931   DALI_TEST_CHECK(value->Get<bool>());
 932
 933   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
 934   DALI_TEST_CHECK(value);
 935   DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
 936
 937   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
 938   DALI_TEST_CHECK(value);
 939   DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
 940
 941   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
 942   DALI_TEST_CHECK(value);
 943   DALI_TEST_CHECK(value->Get<float>() == 0.9f);
 944
 945   Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
 946
 947   Property::Map propertyMap1;
 948   propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
 949   propertyMap1.Insert("mixColor", Color::MAGENTA);
 950   propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
 951   propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
 952   propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
 953   nPatchVisual = factory.CreateVisual(propertyMap1);
 954
 955   nPatchVisual.CreatePropertyMap(resultMap);
 956
 957   // check the property values from the returned map from visual
 958   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 959   DALI_TEST_CHECK(value);
 960   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
 961
 962   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
 963   DALI_TEST_CHECK(value);
 964   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
 965
 966   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
 967   DALI_TEST_CHECK(value);
 968   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
 969
 970   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
 971   DALI_TEST_CHECK(value);
 972   DALI_TEST_CHECK(value->Get<bool>());
 973
 974   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
 975   DALI_TEST_CHECK(value);
 976   DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
 977
 978   END_TEST;
 979 }
 980
 981 int UtcDaliVisualGetPropertyMap7(void)
 982 {
 983   ToolkitTestApplication application;
 984   tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
 985
 986   // request SvgVisual with a property map
 987   VisualFactory factory = VisualFactory::Get();
 988   Property::Map propertyMap;
 989   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
 990   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
 991   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
 992   propertyMap.Insert(ImageVisual::Property::ATLASING, false);
 993   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
 994
 995   Property::Map resultMap;
 996   svgVisual.CreatePropertyMap(resultMap);
 997   // check the property values from the returned map from a visual
 998   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
 999   DALI_TEST_CHECK(value);
1000   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1001
1002   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1003   DALI_TEST_CHECK(value);
1004   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1005
1006   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1007   DALI_TEST_CHECK(value);
1008   DALI_TEST_CHECK(value->Get<bool>() == false);
1009
1010   // request SvgVisual with a property map 2
1011   propertyMap.Clear();
1012   propertyMap["visualType"] = Visual::SVG;
1013   propertyMap["mixColor"]   = Color::WHITE;
1014   propertyMap["url"]        = TEST_SVG_FILE_NAME;
1015   propertyMap["atlasing"]   = true;
1016   Visual::Base svgVisual1   = factory.CreateVisual(propertyMap);
1017
1018   resultMap.Clear();
1019   svgVisual1.CreatePropertyMap(resultMap);
1020   // check the property values from the returned map from a visual
1021   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1022   DALI_TEST_CHECK(value);
1023   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1024
1025   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1026   DALI_TEST_CHECK(value);
1027   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1028
1029   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1030   DALI_TEST_CHECK(value);
1031   DALI_TEST_CHECK(value->Get<bool>() == true);
1032
1033   // request SvgVisual with an URL
1034   Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1035   resultMap.Clear();
1036   svgVisual2.CreatePropertyMap(resultMap);
1037   // check the property values from the returned map from a visual
1038   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1039   DALI_TEST_CHECK(value);
1040   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1041
1042   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1043   DALI_TEST_CHECK(value);
1044   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1045
1046   END_TEST;
1047 }
1048
1049 //Mesh visual
1050 int UtcDaliVisualGetPropertyMap8(void)
1051 {
1052   ToolkitTestApplication application;
1053   tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1054
1055   //Request MeshVisual using a property map.
1056   VisualFactory factory = VisualFactory::Get();
1057   Property::Map propertyMap;
1058   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1059   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1060   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1061   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1062   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1063   propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1064   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1065   Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1066
1067   Property::Map resultMap;
1068   meshVisual.CreatePropertyMap(resultMap);
1069   TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1070
1071   //Check values in the result map are identical to the initial map's values.
1072   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1073   DALI_TEST_CHECK(value);
1074   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1075
1076   value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1077   DALI_TEST_CHECK(value);
1078   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1079
1080   value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1081   DALI_TEST_CHECK(value);
1082   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1083
1084   value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1085   DALI_TEST_CHECK(value);
1086   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1087
1088   value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1089   DALI_TEST_CHECK(value);
1090   DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1091
1092   value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1093   DALI_TEST_CHECK(value);
1094   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1095
1096   END_TEST;
1097 }
1098
1099 //Primitive shape visual
1100 int UtcDaliVisualGetPropertyMap9(void)
1101 {
1102   ToolkitTestApplication application;
1103   tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1104
1105   static std::vector<UniformData> customUniforms =
1106     {
1107       UniformData("mixColor", Property::Type::VECTOR3),
1108     };
1109
1110   TestGraphicsController& graphics = application.GetGraphicsController();
1111   graphics.AddCustomUniforms(customUniforms);
1112
1113   Vector4 color      = Vector4(1.0, 0.8, 0.6, 1.0);
1114   Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1115
1116   //Request PrimitiveVisual using a property map.
1117   VisualFactory factory = VisualFactory::Get();
1118   Property::Map propertyMap;
1119   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1120   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1121   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1122   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1123   propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1124   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1125   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1126   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1127   propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1128   propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1129   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1130   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1131   propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1132   Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1133
1134   Property::Map resultMap;
1135   primitiveVisual.CreatePropertyMap(resultMap);
1136
1137   //Check values in the result map are identical to the initial map's values.
1138   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1139   DALI_TEST_CHECK(value);
1140   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1141
1142   value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1143   DALI_TEST_CHECK(value);
1144   DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1145
1146   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1147   DALI_TEST_CHECK(value);
1148   DALI_TEST_CHECK(value->Get<Vector4>() == color);
1149   DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1150
1151   value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1152   DALI_TEST_CHECK(value);
1153   DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1154
1155   value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1156   DALI_TEST_CHECK(value);
1157   DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1158
1159   value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1160   DALI_TEST_CHECK(value);
1161   DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1162
1163   value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1164   DALI_TEST_CHECK(value);
1165   DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1166
1167   value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1168   DALI_TEST_CHECK(value);
1169   DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1170
1171   value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1172   DALI_TEST_CHECK(value);
1173   DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1174
1175   value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1176   DALI_TEST_CHECK(value);
1177   DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1178
1179   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1180   DALI_TEST_CHECK(value);
1181   DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1182
1183   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1184   DALI_TEST_CHECK(value);
1185   DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1186
1187   value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1188   DALI_TEST_CHECK(value);
1189   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1190
1191   DummyControl        actor     = DummyControl::New(true);
1192   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1193   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1194   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1195   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1196   application.GetScene().Add(actor);
1197
1198   Animation animation = Animation::New(1.0f);
1199   animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1200   animation.Play();
1201   application.SendNotification();
1202   application.Render(0);
1203   application.Render(1000);
1204   application.SendNotification();
1205
1206   auto& gl = application.GetGlAbstraction();
1207   DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1208
1209   tet_infoline("Check property map after animation");
1210
1211   primitiveVisual.CreatePropertyMap(resultMap);
1212   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1213   DALI_TEST_CHECK(value);
1214   color = value->Get<Vector4>();
1215   // Ignore alpha part
1216   DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1217
1218   END_TEST;
1219 }
1220
1221 //Text shape visual
1222 int UtcDaliVisualGetPropertyMap10(void)
1223 {
1224   ToolkitTestApplication application;
1225   tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1226
1227   //Request PrimitiveVisual using a property map.
1228   VisualFactory factory = VisualFactory::Get();
1229
1230   Property::Map propertyMap;
1231   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1232   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1233   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1234   propertyMap.Insert("enableMarkup", false);
1235   propertyMap.Insert("text", "Hello world");
1236   propertyMap.Insert("fontFamily", "TizenSans");
1237
1238   Property::Map fontStyleMapSet;
1239   fontStyleMapSet.Insert("weight", "bold");
1240   propertyMap.Insert("fontStyle", fontStyleMapSet);
1241
1242   propertyMap.Insert("pointSize", 12.f);
1243   propertyMap.Insert("multiLine", true);
1244   propertyMap.Insert("horizontalAlignment", "CENTER");
1245   propertyMap.Insert("verticalAlignment", "CENTER");
1246   propertyMap.Insert("textColor", Color::RED);
1247
1248   Property::Map shadowMapSet;
1249   propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1250
1251   Property::Map underlineMapSet;
1252   propertyMap.Insert("underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1).Add("type", Text::Underline::Type::SOLID).Add("dashWidth", 2).Add("dashGap", 1));
1253
1254   Property::Map outlineMapSet;
1255   propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1256
1257   Property::Map backgroundMapSet;
1258   propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1259
1260   Visual::Base textVisual = factory.CreateVisual(propertyMap);
1261
1262   Property::Map resultMap;
1263   textVisual.CreatePropertyMap(resultMap);
1264
1265   //Check values in the result map are identical to the initial map's values.
1266   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1267   DALI_TEST_CHECK(value);
1268   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1269
1270   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1271   DALI_TEST_CHECK(value);
1272   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1273
1274   value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1275   DALI_TEST_CHECK(value);
1276   DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1277
1278   value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1279   DALI_TEST_CHECK(value);
1280   DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1281
1282   value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1283   DALI_TEST_CHECK(value);
1284
1285   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1286   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1287   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1288
1289   value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1290   DALI_TEST_CHECK(value);
1291   DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1292
1293   value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1294   DALI_TEST_CHECK(value);
1295   DALI_TEST_CHECK(value->Get<bool>());
1296
1297   value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1298   DALI_TEST_CHECK(value);
1299   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1300
1301   value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1302   DALI_TEST_CHECK(value);
1303   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1304
1305   value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1306   DALI_TEST_CHECK(value);
1307   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1308
1309   value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1310   DALI_TEST_CHECK(value);
1311   DALI_TEST_CHECK(!value->Get<bool>());
1312
1313   value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1314   DALI_TEST_CHECK(value);
1315
1316   Property::Map shadowMapGet = value->Get<Property::Map>();
1317   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1318   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1319
1320   value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1321   DALI_TEST_CHECK(value);
1322
1323   Property::Map underlineMapGet = value->Get<Property::Map>();
1324   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1325   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1326
1327   value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1328   DALI_TEST_CHECK(value);
1329
1330   Property::Map outlineMapGet = value->Get<Property::Map>();
1331   DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1332   DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1333
1334   value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1335   DALI_TEST_CHECK(value);
1336
1337   Property::Map backgroundMapGet = value->Get<Property::Map>();
1338   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1339   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1340
1341   END_TEST;
1342 }
1343
1344 int UtcDaliVisualGetPropertyMap11(void)
1345 {
1346   ToolkitTestApplication application;
1347   tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1348
1349   VisualFactory factory = VisualFactory::Get();
1350   DALI_TEST_CHECK(factory);
1351
1352   Property::Map propertyMap;
1353   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1354
1355   Vector2 start(-0.5f, 0.5f);
1356   Vector2 end(0.5f, -0.0f);
1357   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1358   Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1359   Vector2 rotate_center(0.0f, 0.4f);
1360   float   rotate_amount = 1.57f;
1361   float   offset        = 100.f;
1362
1363   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1364   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1365   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1366
1367   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1368   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1369   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1370   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1371   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1372   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1373   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1374
1375   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1376   DALI_TEST_CHECK(animatedGradientVisual);
1377
1378   Property::Map resultMap;
1379   animatedGradientVisual.CreatePropertyMap(resultMap);
1380
1381   // check the property values from the returned map from visual
1382   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1383   DALI_TEST_CHECK(value);
1384   DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1385
1386   value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1387   DALI_TEST_CHECK(value);
1388   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1389
1390   value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1391   DALI_TEST_CHECK(value);
1392   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1393
1394   value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1395   DALI_TEST_CHECK(value);
1396   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1397
1398   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1399   DALI_TEST_CHECK(value);
1400   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1401
1402   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1403   DALI_TEST_CHECK(value);
1404   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1405
1406   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1407   DALI_TEST_CHECK(value);
1408   DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1409
1410   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1411   DALI_TEST_CHECK(value);
1412   DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1413
1414   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1415   DALI_TEST_CHECK(value);
1416   DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1417
1418   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1419   DALI_TEST_CHECK(value);
1420   DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1421
1422   value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1423   DALI_TEST_CHECK(value);
1424   DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1425
1426   END_TEST;
1427 }
1428
1429 int UtcDaliVisualGetPropertyMap12(void)
1430 {
1431   ToolkitTestApplication application;
1432   tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1433
1434   // Case 1 : Set values by index
1435   {
1436     tet_printf(" - Set Values by Index\n");
1437     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1438     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1439     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1440     {
1441       tet_printf("test with delay [%f]\n", _delay);
1442       VisualFactory factory = VisualFactory::Get();
1443       DALI_TEST_CHECK(factory);
1444
1445       Property::Map propertyMap;
1446       Property::Map animationMap;
1447       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1448
1449       float duration     = 1.1f;
1450       float delay        = _delay;
1451       float repeat_delay = 0.4f;
1452
1453       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1454       int loop_count = 5;
1455       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1456       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1457
1458       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1459         animationMap.Clear();
1460         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1461         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1462         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1463         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1464         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1465         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1466         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1467         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1468         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1469
1470         return animationMap;
1471       };
1472
1473       Vector2 start1(-0.5f, 0.5f);
1474       Vector2 end1(0.5f, -0.5f);
1475       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1476       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1477       Vector2 rotate_center1(0.0f, 0.4f);
1478       float   rotate_amount1 = 0.0f;
1479       float   offset1        = 0.f;
1480
1481       Vector2 start2(-0.5f, -0.5f);
1482       Vector2 end2(0.5f, 0.5f);
1483       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1484       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1485       Vector2 rotate_center2(0.0f, -0.4f);
1486       float   rotate_amount2 = 6.2832f;
1487       float   offset2        = 2.f;
1488
1489       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1490       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1491       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1492
1493       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1494       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1495       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1496       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1497       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1498       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1499       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1500
1501       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1502       DALI_TEST_CHECK(animatedGradientVisual);
1503
1504       Property::Map resultMap;
1505       animatedGradientVisual.CreatePropertyMap(resultMap);
1506
1507       // check the property values from the returned map from visual
1508       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1509       DALI_TEST_CHECK(value);
1510       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1511
1512       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1513       DALI_TEST_CHECK(value);
1514       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1515
1516       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1517       DALI_TEST_CHECK(value);
1518       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1519
1520       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1521       DALI_TEST_CHECK(value);
1522       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1523
1524       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1525         tet_printf("Check value at %d\n", line_num);
1526         value = resultMap.Find(index, Property::MAP);
1527         DALI_TEST_CHECK(value);
1528         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1529         Property::Map* temp_map = value->GetMap();
1530         DALI_TEST_CHECK(temp_map);
1531
1532         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1533           Property::Value* res = temp_map->Find(index);
1534           DALI_TEST_CHECK(res);
1535           return *res;
1536         };
1537
1538         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1539         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1540         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1541         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1542         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1543         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1544         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1545         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1546         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1547       };
1548
1549       // check the animation map data is good
1550       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1551       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1552       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1553       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1554       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1555       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1556       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1557     }
1558   }
1559
1560   // Case 2 : Set values by string
1561   {
1562     tet_printf(" - Set Values by String\n");
1563     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1564     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1565     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1566     {
1567       tet_printf("test with delay [%f]\n", _delay);
1568       VisualFactory factory = VisualFactory::Get();
1569       DALI_TEST_CHECK(factory);
1570
1571       Property::Map propertyMap;
1572       Property::Map animationMap;
1573       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1574
1575       float duration     = 1.1f;
1576       float delay        = _delay;
1577       float repeat_delay = 0.4f;
1578
1579       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1580       int loop_count = 5;
1581       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1582       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1583
1584       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1585         animationMap.Clear();
1586         animationMap.Insert("startValue", start);
1587         animationMap.Insert("targetValue", target);
1588         animationMap.Insert("directionType", "BACKWARD");
1589         animationMap.Insert("duration", duration);
1590         animationMap.Insert("delay", delay);
1591         animationMap.Insert("repeat", loop_count);
1592         animationMap.Insert("repeatDelay", repeat_delay);
1593         animationMap.Insert("motionType", "MIRROR");
1594         animationMap.Insert("easingType", "IN_OUT");
1595
1596         return animationMap;
1597       };
1598
1599       Vector2 start1(-0.5f, 0.5f);
1600       Vector2 end1(0.5f, -0.5f);
1601       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1602       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1603       Vector2 rotate_center1(0.0f, 0.4f);
1604       float   rotate_amount1 = 0.0f;
1605       float   offset1        = 0.f;
1606
1607       Vector2 start2(-0.5f, -0.5f);
1608       Vector2 end2(0.5f, 0.5f);
1609       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1610       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1611       Vector2 rotate_center2(0.0f, -0.4f);
1612       float   rotate_amount2 = 6.2832f;
1613       float   offset2        = 2.f;
1614
1615       // For test mix the type string/index key and string/index value works well.
1616       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1617       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1618       propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1619
1620       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1621       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1622       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1623       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1624       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1625       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1626       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1627
1628       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1629       DALI_TEST_CHECK(animatedGradientVisual);
1630
1631       Property::Map resultMap;
1632       animatedGradientVisual.CreatePropertyMap(resultMap);
1633
1634       // check the property values from the returned map from visual
1635       // Note : resultMap from CreatePropertyMap only contain indexKey
1636       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1637       DALI_TEST_CHECK(value);
1638       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1639
1640       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1641       DALI_TEST_CHECK(value);
1642       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1643
1644       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1645       DALI_TEST_CHECK(value);
1646       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1647
1648       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1649       DALI_TEST_CHECK(value);
1650       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1651
1652       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1653         tet_printf("Check value at %d\n", line_num);
1654         value = resultMap.Find(index, Property::MAP);
1655         DALI_TEST_CHECK(value);
1656         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1657         Property::Map* temp_map = value->GetMap();
1658         DALI_TEST_CHECK(temp_map);
1659
1660         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1661           Property::Value* res = temp_map->Find(index);
1662           DALI_TEST_CHECK(res);
1663           return *res;
1664         };
1665
1666         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1667         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1668         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1669         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1670         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1671         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1672         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1673         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1674         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1675       };
1676
1677       // check the animation map data is good
1678       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1679       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1680       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1681       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1682       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1683       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1684       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1685     }
1686   }
1687
1688   END_TEST;
1689 }
1690 int UtcDaliVisualGetPropertyMap13(void)
1691 {
1692   ToolkitTestApplication application;
1693   tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1694
1695   for(int _direction = 0; _direction <= 1; ++_direction)
1696   {
1697     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1698     {
1699       tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1700       VisualFactory factory = VisualFactory::Get();
1701       DALI_TEST_CHECK(factory);
1702
1703       Property::Map propertyMap;
1704       Property::Map animationMap;
1705       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1706
1707       float duration     = 1.0f;
1708       float delay        = _delay;
1709       float repeat_delay = 0.5f;
1710
1711       int direction  = _direction;
1712       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1713       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1714       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1715
1716       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1717         animationMap.Clear();
1718         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1719         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1720         if(direction == 0)
1721           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1722         else
1723           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1724         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1725         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1726         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1727         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1728         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1729         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1730         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1731
1732         return animationMap;
1733       };
1734
1735       Vector2 start1(-0.5f, 0.5f);
1736       Vector2 end1(0.5f, -0.5f);
1737       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1738       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1739       Vector2 rotate_center1(1.0f, 0.4f);
1740       float   rotate_amount1 = 2.0f;
1741       float   offset1        = 1.f;
1742
1743       Vector2 start2(-0.5f, -0.5f);
1744       Vector2 end2(0.5f, 0.5f);
1745       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1746       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1747       Vector2 rotate_center2(1.0f, -0.4f);
1748       float   rotate_amount2 = 1.0f;
1749       float   offset2        = 3.f;
1750
1751       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1752       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1753       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1754
1755       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1756       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1757       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1758       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1759       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1760       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1761       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1762
1763       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1764       DALI_TEST_CHECK(animatedGradientVisual);
1765
1766       Property::Map resultMap;
1767       animatedGradientVisual.CreatePropertyMap(resultMap);
1768
1769       // check the property values from the returned map from visual
1770       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1771       DALI_TEST_CHECK(value);
1772       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1773
1774       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1775       DALI_TEST_CHECK(value);
1776       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1777
1778       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1779       DALI_TEST_CHECK(value);
1780       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1781
1782       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1783       DALI_TEST_CHECK(value);
1784       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1785
1786       // If loop_count = 0, Animation doesn't created.
1787       // Optimized resultMap only have one value, which is target value
1788       // Note: target value will be changed by direction option.
1789       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1790       DALI_TEST_CHECK(value);
1791       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1792
1793       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1794       DALI_TEST_CHECK(value);
1795       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1796
1797       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1798       DALI_TEST_CHECK(value);
1799       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1800
1801       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1802       DALI_TEST_CHECK(value);
1803       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1804
1805       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1806       DALI_TEST_CHECK(value);
1807       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1808
1809       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1810       DALI_TEST_CHECK(value);
1811       DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1812
1813       value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1814       DALI_TEST_CHECK(value);
1815       DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1816     }
1817   }
1818
1819   END_TEST;
1820 }
1821
1822 int UtcDaliVisualAnimateBorderVisual01(void)
1823 {
1824   ToolkitTestApplication application;
1825   tet_infoline("UtcDaliAnimateBorderVisual Color");
1826
1827   static std::vector<UniformData> customUniforms =
1828     {
1829       UniformData("borderColor", Property::Type::VECTOR4),
1830       UniformData("mixColor", Property::Type::VECTOR3),
1831     };
1832
1833   TestGraphicsController& graphics = application.GetGraphicsController();
1834   graphics.AddCustomUniforms(customUniforms);
1835
1836   VisualFactory factory = VisualFactory::Get();
1837   Property::Map propertyMap;
1838   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1839   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1840   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1841   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1842   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1843
1844   Property::Map map;
1845   map["target"]      = "testVisual";
1846   map["property"]    = "mixColor";
1847   map["targetValue"] = Vector4(1, 1, 1, 0.1);
1848   map["animator"]    = Property::Map()
1849                       .Add("alphaFunction", "LINEAR")
1850                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1851
1852   Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1853
1854   DummyControl        actor     = DummyControl::New(true);
1855   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1856   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1857   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1858   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1859   application.GetScene().Add(actor);
1860
1861   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1862
1863   Renderer        renderer         = actor.GetRendererAt(0);
1864   Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1865   Property::Index mixColorIndex    = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1866
1867   Animation animation = dummyImpl.CreateTransition(transition);
1868
1869   // Animate the mix color through the transition, and the border color through
1870   // programmatic method.
1871   animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1872   animation.Play();
1873
1874   application.SendNotification();
1875   application.Render(0);
1876   application.Render(2000u); // halfway point between blue and white
1877
1878   Vector4 color     = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1879   Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1880   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1881   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1882
1883   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1884   testColor = Vector4(1, 1, 1, 0.45f);
1885   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1886   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1887
1888   Vector4 uColor;
1889   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1890   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1891
1892   application.Render(2000u);
1893
1894   color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1895   DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1896   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1897
1898   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1899   testColor = Vector4(1, 1, 1, 0.1);
1900   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1901   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1902
1903   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1904   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1905
1906   END_TEST;
1907 }
1908
1909 int UtcDaliVisualAnimateBorderVisual02(void)
1910 {
1911   ToolkitTestApplication application;
1912   tet_infoline("UtcDaliAnimateBorderVisual Size");
1913
1914   static std::vector<UniformData> customUniforms =
1915     {
1916       UniformData("borderSize", Property::Type::FLOAT),
1917     };
1918
1919   TestGraphicsController& graphics = application.GetGraphicsController();
1920   graphics.AddCustomUniforms(customUniforms);
1921
1922   VisualFactory factory = VisualFactory::Get();
1923   Property::Map propertyMap;
1924   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1925   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1926   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1927   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1928
1929   DummyControl        actor     = DummyControl::New(true);
1930   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1931   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1932   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1933   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1934   application.GetScene().Add(actor);
1935
1936   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1937
1938   Renderer        renderer = actor.GetRendererAt(0);
1939   Property::Index index    = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1940
1941   Animation animation = Animation::New(4.0f);
1942   animation.AnimateTo(Property(renderer, index), 9.0f);
1943   animation.Play();
1944
1945   application.SendNotification();
1946   application.Render(0);
1947   application.Render(2000u); // halfway point
1948
1949   float size = renderer.GetCurrentProperty<float>(index);
1950   DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1951   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1952
1953   application.Render(2000u); // halfway point between blue and white
1954
1955   size = renderer.GetCurrentProperty<float>(index);
1956   DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1957   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1958
1959   END_TEST;
1960 }
1961
1962 int UtcDaliVisualAnimateColorVisual(void)
1963 {
1964   ToolkitTestApplication application;
1965   tet_infoline("UtcDaliAnimateColorVisual mixColor");
1966
1967   static std::vector<UniformData> customUniforms =
1968     {
1969       UniformData("mixColor", Property::Type::VECTOR3),
1970     };
1971
1972   TestGraphicsController& graphics = application.GetGraphicsController();
1973   graphics.AddCustomUniforms(customUniforms);
1974
1975   VisualFactory factory = VisualFactory::Get();
1976   Property::Map propertyMap;
1977   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1978   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1979   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1980
1981   DummyControl        actor     = DummyControl::New(true);
1982   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1983   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1984   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1985   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1986   application.GetScene().Add(actor);
1987
1988   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1989
1990   Renderer        renderer      = actor.GetRendererAt(0);
1991   Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1992
1993   Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1994   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1995
1996   Animation animation = Animation::New(4.0f);
1997   animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1998   animation.Play();
1999
2000   application.SendNotification();
2001   application.Render(0);
2002   application.Render(2000u); // halfway point
2003
2004   Vector3 color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2005   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
2006   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
2007
2008   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
2009
2010   application.Render(2000u); // halfway point between blue and white
2011
2012   color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
2013   DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
2014
2015   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
2016
2017   blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
2018   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
2019
2020   END_TEST;
2021 }
2022
2023 int UtcDaliVisualAnimatePrimitiveVisual(void)
2024 {
2025   ToolkitTestApplication application;
2026   tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2027
2028   static std::vector<UniformData> customUniforms =
2029     {
2030       UniformData("mixColor", Property::Type::VECTOR3),
2031     };
2032
2033   TestGraphicsController& graphics = application.GetGraphicsController();
2034   graphics.AddCustomUniforms(customUniforms);
2035
2036   {
2037     VisualFactory factory = VisualFactory::Get();
2038     Property::Map propertyMap;
2039     propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2040     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2041     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2042     Visual::Base visual = factory.CreateVisual(propertyMap);
2043
2044     DummyControl        actor     = DummyControl::New(true);
2045     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2046     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2047     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2048     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2049     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2050     application.GetScene().Add(actor);
2051
2052     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2053
2054     Renderer        renderer = actor.GetRendererAt(0);
2055
2056     const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2057     const Vector4 TARGET_MIX_COLOR(Color::RED);
2058
2059     Property::Map map;
2060     map["target"]       = "testVisual";
2061     map["property"]     = "mixColor";
2062     map["initialValue"] = INITIAL_MIX_COLOR;
2063     map["targetValue"]  = TARGET_MIX_COLOR;
2064     map["animator"]     = Property::Map()
2065                         .Add("alphaFunction", "LINEAR")
2066                         .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2067
2068     Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2069
2070     Animation animation = dummyImpl.CreateTransition(transition);
2071     animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2072     animation.Play();
2073
2074     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2075     glAbstraction.EnableEnableDisableCallTrace(true);
2076     TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
2077     std::ostringstream blendStr;
2078     blendStr << std::hex << GL_BLEND;
2079
2080     application.SendNotification();
2081     application.Render(0);
2082     application.Render(2000u); // halfway point
2083     application.SendNotification();
2084
2085     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2086     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2087     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2088
2089     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2090
2091     glEnableStack.Reset();
2092
2093     application.Render(2001u);      // go past end
2094     application.SendNotification(); // Trigger signals
2095
2096     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2097     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2098     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2099
2100     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2101
2102     actor.Unparent();
2103   }
2104
2105   END_TEST;
2106 }
2107
2108 int UtcDaliVisualAnimatedGradientVisual01(void)
2109 {
2110   ToolkitTestApplication application;
2111   tet_infoline("UtcDaliAnimatedGradientVisual with default");
2112
2113   static std::vector<UniformData> customUniforms =
2114     {
2115       UniformData("start_point", Property::Type::VECTOR2),
2116       UniformData("end_point", Property::Type::VECTOR2),
2117       UniformData("start_color", Property::Type::VECTOR4),
2118       UniformData("end_color", Property::Type::VECTOR4),
2119       UniformData("rotate_center", Property::Type::VECTOR2),
2120       UniformData("rotate_angle", Property::Type::FLOAT),
2121       UniformData("gradient_offset", Property::Type::FLOAT),
2122     };
2123
2124   TestGraphicsController& graphics = application.GetGraphicsController();
2125   graphics.AddCustomUniforms(customUniforms);
2126
2127   {
2128     VisualFactory factory = VisualFactory::Get();
2129     Property::Map propertyMap;
2130     propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2131     Visual::Base visual = factory.CreateVisual(propertyMap);
2132
2133     DummyControl        actor     = DummyControl::New(true);
2134     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2135     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2136     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2137     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2138     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2139     application.GetScene().Add(actor);
2140
2141     application.SendNotification();
2142     application.Render(0);
2143     application.SendNotification();
2144
2145     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2146
2147     for(int step_iter = 0; step_iter < 3; step_iter++)
2148     {
2149       application.SendNotification();
2150       application.Render(0);
2151       application.Render(750u); // step i/4
2152       application.SendNotification();
2153
2154       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2155       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2156       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2157       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2158       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2159       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2160       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2161     }
2162
2163     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2164     application.Render(750u); // go to end
2165     application.SendNotification();
2166
2167     application.Render(10u); // finish
2168     application.SendNotification();
2169
2170     actor.Unparent();
2171     application.SendNotification();
2172     application.Render(0u);
2173     application.SendNotification();
2174   }
2175
2176   END_TEST;
2177 }
2178
2179 int UtcDaliVisualAnimatedGradientVisual02(void)
2180 {
2181   ToolkitTestApplication application;
2182   tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2183
2184   static std::vector<UniformData> customUniforms =
2185     {
2186       UniformData("start_point", Property::Type::VECTOR2),
2187       UniformData("end_point", Property::Type::VECTOR2),
2188       UniformData("start_color", Property::Type::VECTOR4),
2189       UniformData("end_color", Property::Type::VECTOR4),
2190       UniformData("rotate_center", Property::Type::VECTOR2),
2191       UniformData("rotate_angle", Property::Type::FLOAT),
2192       UniformData("gradient_offset", Property::Type::FLOAT),
2193     };
2194
2195   TestGraphicsController& graphics = application.GetGraphicsController();
2196   graphics.AddCustomUniforms(customUniforms);
2197
2198   {
2199     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2200     int   _direction[2]  = {0, 1};
2201     int   _loop_count[3] = {-1, 0, 1};
2202     int   _motion[2]     = {0, 1};
2203     int   _easing[4]     = {0, 1, 2, 3};
2204
2205     int test_case_max = 4 * 2 * 3 * 2 * 4;
2206     int test_case     = 0;
2207     int test_case_d   = 7; // 7 is the number of animated properties.
2208
2209     float _duration     = 0.4f;
2210     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2211     float noise_maker   = 0.0f;
2212     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2213     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2214     {
2215       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2216
2217       VisualFactory factory = VisualFactory::Get();
2218       Property::Map propertyMap;
2219       Property::Map animationMap;
2220       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2221
2222       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2223       int unit_type     = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2224       int spread_type   = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2225
2226       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2227         int tc         = (test_case + tc_offset);
2228         int idx_easing = tc % 4;
2229         tc /= 4;
2230         int idx_motion = tc % 2;
2231         tc /= 2;
2232         int idx_loop_count = tc % 3;
2233         tc /= 3;
2234         int idx_direction = tc % 2;
2235         tc /= 2;
2236         int idx_delay = tc % 4;
2237         tc /= 4;
2238
2239         float duration     = _duration - _repeat_delay;
2240         float repeat_delay = _repeat_delay;
2241         float delay        = _delay[idx_delay] * _duration;
2242         int   direction    = _direction[idx_direction];
2243         int   loop_count   = _loop_count[idx_loop_count];
2244         int   motion       = _motion[idx_motion];
2245         int   easing       = _easing[idx_easing];
2246
2247         animationMap.Clear();
2248         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2249         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2250         if(direction == 0)
2251         {
2252           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2253         }
2254         else
2255         {
2256           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2257         }
2258         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2259         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2260         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2261         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2262         if(motion == 0)
2263         {
2264           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2265         }
2266         else
2267         {
2268           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2269         }
2270         if(easing == 0)
2271         {
2272           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2273         }
2274         else if(easing == 1)
2275         {
2276           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2277         }
2278         else if(easing == 2)
2279         {
2280           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2281         }
2282         else
2283         {
2284           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2285         }
2286
2287         return animationMap;
2288       };
2289
2290       // Give different values for debuging
2291       noise_maker += 1.0f;
2292       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2293       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2294       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2295       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2296       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2297       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2298       float   offset1        = 0.f + noise_maker * 0.1f;
2299
2300       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2301       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2302       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2303       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2304       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2305       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2306       float   offset2        = 2.f + noise_maker * 0.1f;
2307
2308       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2309       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2310       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2311
2312       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2313       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2314       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2315       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2316       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2317       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2318       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2319
2320       Visual::Base visual = factory.CreateVisual(propertyMap);
2321
2322       DummyControl        actor     = DummyControl::New(true);
2323       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2324       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2325       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2326       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2327       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2328       application.GetScene().Add(actor);
2329
2330       application.SendNotification();
2331       application.Render(0);
2332       application.SendNotification();
2333
2334       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2335
2336       application.SendNotification();
2337
2338       //Compare between CPU calculated value and Shader Visual calculated value
2339       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2340         int tc         = (test_case + tc_offset);
2341         int idx_easing = tc % 4;
2342         tc /= 4;
2343         int idx_motion = tc % 2;
2344         tc /= 2;
2345         int idx_loop_count = tc % 3;
2346         tc /= 3;
2347         int idx_direction = tc % 2;
2348         tc /= 2;
2349         int idx_delay = tc % 4;
2350         tc /= 4;
2351
2352         float duration     = _duration - _repeat_delay;
2353         float repeat_delay = _repeat_delay;
2354         float delay        = _delay[idx_delay] * _duration;
2355         int   direction    = _direction[idx_direction];
2356         int   loop_count   = _loop_count[idx_loop_count];
2357         int   motion       = _motion[idx_motion];
2358         int   easing       = _easing[idx_easing];
2359
2360         progress -= delay / _duration;
2361
2362         Property::Value s = start;
2363         Property::Value t = target;
2364         if(direction == 1)
2365         {
2366           s = target;
2367           t = start;
2368         }
2369         float x; ///< Animator progress value
2370         if(loop_count == 0)
2371         {
2372           x = 1.0f;
2373         }
2374         else if(loop_count > 0 && progress + 0.01f > loop_count)
2375         {
2376           x = (motion == 0) ? 1.0f : 0.0f;
2377         }
2378         else
2379         {
2380           if(progress < 0.0f)
2381           {
2382             progress = 0.0f;
2383           }
2384           progress = fmodf(progress, 1.0f);
2385           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2386
2387           x = progress;
2388           if(motion == 1)
2389           {
2390             x = progress * 2.0f;
2391             if(x > 1.0f)
2392             {
2393               x = 2.0f - x;
2394             }
2395           }
2396
2397           if(easing == 1) // EASE_IN
2398           {
2399             x = x * x;
2400           }
2401           else if(easing == 2) // EASE_OUT
2402           {
2403             x = 2.0f * x - x * x;
2404           }
2405           else if(easing == 3) // EASE_IN_OUT
2406           {
2407             x = x * x * (3.0f - 2.0f * x);
2408           }
2409         }
2410         if(value_type == 0) // result type is Float
2411         {
2412           float res;
2413           float cur;
2414           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2415           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2416           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2417         }
2418         else if(value_type == 1) // result type is Vector2
2419         {
2420           Vector2 res;
2421           Vector2 cur;
2422           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2423           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2424           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2425         }
2426         else if(value_type == 2) // result type is Vector3
2427         {
2428           Vector3 res;
2429           Vector3 cur;
2430           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2431           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2432           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2433         }
2434         else // result type is Vector4
2435         {
2436           Vector4 res;
2437           Vector4 cur;
2438           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2439           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2440           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2441         }
2442       };
2443
2444       float step = 0.0f;
2445       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2446       {
2447         for(int step_iter = 0; step_iter < 3; step_iter++)
2448         {
2449           application.SendNotification();
2450           application.Render(_duration * 250.f); // step i/4
2451           application.SendNotification();
2452           step += 0.25f;
2453
2454           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2455           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2456           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2457           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2458           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2459           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2460           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2461         }
2462         application.SendNotification();
2463         application.Render(_duration * 250.f); // step 4/4 will not test
2464         application.SendNotification();
2465         step += 0.25f;
2466       }
2467
2468       application.SendNotification();
2469       actor.Unparent();
2470       application.SendNotification();
2471       application.Render(10.f); // tempral time
2472       application.SendNotification();
2473     }
2474   }
2475
2476   END_TEST;
2477 }
2478
2479 int UtcDaliVisualAnimatedGradientVisual03(void)
2480 {
2481   ToolkitTestApplication application;
2482   tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2483
2484   static std::vector<UniformData> customUniforms =
2485     {
2486       UniformData("start_point", Property::Type::VECTOR2),
2487       UniformData("end_point", Property::Type::VECTOR2),
2488       UniformData("start_color", Property::Type::VECTOR4),
2489       UniformData("end_color", Property::Type::VECTOR4),
2490       UniformData("rotate_center", Property::Type::VECTOR2),
2491       UniformData("rotate_angle", Property::Type::FLOAT),
2492       UniformData("gradient_offset", Property::Type::FLOAT),
2493     };
2494
2495   TestGraphicsController& graphics = application.GetGraphicsController();
2496   graphics.AddCustomUniforms(customUniforms);
2497
2498   {
2499     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2500     int   _direction[2]  = {0, 1};
2501     int   _loop_count[3] = {-1, 0, 1};
2502     int   _motion[2]     = {0, 1};
2503     int   _easing[4]     = {0, 1, 2, 3};
2504
2505     int test_case_max = 4 * 2 * 3 * 2 * 4;
2506     int test_case     = 0;
2507     int test_case_d   = 7; // 7 is the number of animated properties.
2508
2509     float _duration     = 0.4f;
2510     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2511     float noise_maker   = 0.2f;
2512     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2513     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2514     {
2515       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2516
2517       VisualFactory factory = VisualFactory::Get();
2518       Property::Map propertyMap;
2519       Property::Map animationMap;
2520       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2521
2522       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2523         int tc         = (test_case + tc_offset);
2524         int idx_easing = tc % 4;
2525         tc /= 4;
2526         int idx_motion = tc % 2;
2527         tc /= 2;
2528         int idx_loop_count = tc % 3;
2529         tc /= 3;
2530         int idx_direction = tc % 2;
2531         tc /= 2;
2532         int idx_delay = tc % 4;
2533         tc /= 4;
2534
2535         float duration     = _duration - _repeat_delay;
2536         float repeat_delay = _repeat_delay;
2537         float delay        = _delay[idx_delay] * _duration;
2538         int   direction    = _direction[idx_direction];
2539         int   loop_count   = _loop_count[idx_loop_count];
2540         int   motion       = _motion[idx_motion];
2541         int   easing       = _easing[idx_easing];
2542
2543         animationMap.Clear();
2544         animationMap.Insert("startValue", start);
2545         animationMap.Insert("targetValue", target);
2546         if(direction == 0)
2547         {
2548           animationMap.Insert("directionType", "FORWARD");
2549         }
2550         else
2551         {
2552           animationMap.Insert("directionType", "BACKWARD");
2553         }
2554         animationMap.Insert("duration", duration);
2555         animationMap.Insert("delay", delay);
2556         animationMap.Insert("repeat", loop_count);
2557         animationMap.Insert("repeatDelay", repeat_delay);
2558         if(motion == 0)
2559         {
2560           animationMap.Insert("motionType", "LOOP");
2561         }
2562         else
2563         {
2564           animationMap.Insert("motionType", "MIRROR");
2565         }
2566         if(easing == 0)
2567         {
2568           animationMap.Insert("easingType", "LINEAR");
2569         }
2570         else if(easing == 1)
2571         {
2572           animationMap.Insert("easingType", "IN");
2573         }
2574         else if(easing == 2)
2575         {
2576           animationMap.Insert("easingType", "OUT");
2577         }
2578         else
2579         {
2580           animationMap.Insert("easingType", "IN_OUT");
2581         }
2582
2583         return animationMap;
2584       };
2585
2586       // Give different values for debuging
2587       noise_maker += 0.8f;
2588       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2589       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2590       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2591       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2592       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2593       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2594       float   offset1        = 0.f + noise_maker * 0.1f;
2595
2596       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2597       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2598       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2599       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2600       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2601       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2602       float   offset2        = 2.f + noise_maker * 0.1f;
2603
2604       propertyMap.Insert("gradientType", "LINEAR");
2605       propertyMap.Insert("unitType", "USER_SPACE");
2606       propertyMap.Insert("spreadType", "CLAMP");
2607
2608       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2609       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2610       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2611       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2612       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2613       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2614       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2615
2616       Visual::Base visual = factory.CreateVisual(propertyMap);
2617
2618       DummyControl        actor     = DummyControl::New(true);
2619       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2620       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2621       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2622       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2623       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2624       application.GetScene().Add(actor);
2625
2626       application.SendNotification();
2627       application.Render(0);
2628       application.SendNotification();
2629
2630       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2631
2632       application.SendNotification();
2633
2634       //Compare between CPU calculated value and Shader Visual calculated value
2635       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2636         int tc         = (test_case + tc_offset);
2637         int idx_easing = tc % 4;
2638         tc /= 4;
2639         int idx_motion = tc % 2;
2640         tc /= 2;
2641         int idx_loop_count = tc % 3;
2642         tc /= 3;
2643         int idx_direction = tc % 2;
2644         tc /= 2;
2645         int idx_delay = tc % 4;
2646         tc /= 4;
2647
2648         float duration     = _duration - _repeat_delay;
2649         float repeat_delay = _repeat_delay;
2650         float delay        = _delay[idx_delay] * _duration;
2651         int   direction    = _direction[idx_direction];
2652         int   loop_count   = _loop_count[idx_loop_count];
2653         int   motion       = _motion[idx_motion];
2654         int   easing       = _easing[idx_easing];
2655
2656         progress -= delay / _duration;
2657
2658         Property::Value s = start;
2659         Property::Value t = target;
2660         if(direction == 1)
2661         {
2662           s = target;
2663           t = start;
2664         }
2665         float x; ///< Animator progress value
2666         if(loop_count == 0)
2667         {
2668           x = 1.0f;
2669         }
2670         else if(loop_count > 0 && progress + 0.01f > loop_count)
2671         {
2672           x = (motion == 0) ? 1.0f : 0.0f;
2673         }
2674         else
2675         {
2676           if(progress < 0.0f)
2677           {
2678             progress = 0.0f;
2679           }
2680           progress = fmodf(progress, 1.0f);
2681           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2682
2683           x = progress;
2684           if(motion == 1)
2685           {
2686             x = progress * 2.0f;
2687             if(x > 1.0f)
2688             {
2689               x = 2.0f - x;
2690             }
2691           }
2692
2693           if(easing == 1) // EASE_IN
2694           {
2695             x = x * x;
2696           }
2697           else if(easing == 2) // EASE_OUT
2698           {
2699             x = 2.0f * x - x * x;
2700           }
2701           else if(easing == 3) // EASE_IN_OUT
2702           {
2703             x = x * x * (3.0f - 2.0f * x);
2704           }
2705         }
2706         if(value_type == 0) // result type is Float
2707         {
2708           float res;
2709           float cur;
2710           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2711           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2712           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2713         }
2714         else if(value_type == 1) // result type is Vector2
2715         {
2716           Vector2 res;
2717           Vector2 cur;
2718           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2719           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2720           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2721         }
2722         else if(value_type == 2) // result type is Vector3
2723         {
2724           Vector3 res;
2725           Vector3 cur;
2726           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2727           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2728           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2729         }
2730         else // result type is Vector4
2731         {
2732           Vector4 res;
2733           Vector4 cur;
2734           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2735           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2736           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2737         }
2738       };
2739
2740       float step = 0.0f;
2741       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2742       {
2743         for(int step_iter = 0; step_iter < 3; step_iter++)
2744         {
2745           application.SendNotification();
2746           application.Render(_duration * 250.f); // step i/4
2747           application.SendNotification();
2748           step += 0.25f;
2749
2750           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2751           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2752           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2753           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2754           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2755           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2756           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2757         }
2758         application.SendNotification();
2759         application.Render(_duration * 250.f); // step 4/4 will not test
2760         application.SendNotification();
2761         step += 0.25f;
2762       }
2763
2764       application.SendNotification();
2765       actor.Unparent();
2766       application.SendNotification();
2767       application.Render(10.f); // tempral time
2768       application.SendNotification();
2769     }
2770   }
2771
2772   END_TEST;
2773 }
2774
2775 int UtcDaliVisualWireframeVisual(void)
2776 {
2777   ToolkitTestApplication application;
2778
2779   VisualFactory factory = VisualFactory::Get();
2780   Property::Map propertyMap;
2781   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2782
2783   // Create the visual.
2784   Visual::Base visual = factory.CreateVisual(propertyMap);
2785
2786   DALI_TEST_CHECK(visual);
2787
2788   Property::Map resultMap;
2789   visual.CreatePropertyMap(resultMap);
2790
2791   // Check the property values from the returned map from visual
2792   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2793   DALI_TEST_CHECK(value);
2794   DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2795
2796   END_TEST;
2797 }
2798
2799 int UtcDaliVisualGetTransform(void)
2800 {
2801   ToolkitTestApplication application;
2802   tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2803
2804   VisualFactory factory = VisualFactory::Get();
2805   Property::Map propertyMap;
2806   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2807   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2808   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2809
2810   Dali::Property::Map visualMap;
2811   colorVisual.CreatePropertyMap(visualMap);
2812   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2813   Dali::Property::Map* map   = value->GetMap();
2814   DALI_TEST_CHECK(map);
2815
2816   //Test default values
2817   {
2818     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2819     DALI_TEST_CHECK(typeValue);
2820     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2821   }
2822   {
2823     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2824     DALI_TEST_CHECK(typeValue);
2825     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2826   }
2827   {
2828     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2829     DALI_TEST_CHECK(typeValue);
2830     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2831   }
2832   {
2833     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2834     DALI_TEST_CHECK(typeValue);
2835     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2836   }
2837   {
2838     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2839     DALI_TEST_CHECK(typeValue);
2840     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2841   }
2842   {
2843     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2844     DALI_TEST_CHECK(typeValue);
2845     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2846   }
2847   {
2848     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2849     DALI_TEST_CHECK(typeValue);
2850     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2851   }
2852
2853   END_TEST;
2854 }
2855
2856 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2857 {
2858   Property::Map transform;
2859   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2860   transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2861   transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2862   transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2863   transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2864   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2865
2866   visual.SetTransformAndSize(transform, Vector2(100, 100));
2867
2868   Dali::Property::Map visualMap;
2869   visual.CreatePropertyMap(visualMap);
2870   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2871   Dali::Property::Map* map   = value->GetMap();
2872   DALI_TEST_CHECK(map);
2873
2874   {
2875     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2876     DALI_TEST_CHECK(typeValue);
2877     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2878   }
2879   {
2880     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2881     DALI_TEST_CHECK(typeValue);
2882     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2883   }
2884   {
2885     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2886     DALI_TEST_CHECK(typeValue);
2887     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2888   }
2889   {
2890     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2891     DALI_TEST_CHECK(typeValue);
2892     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2893   }
2894   {
2895     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2896     DALI_TEST_CHECK(typeValue);
2897     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2898   }
2899   {
2900     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2901     DALI_TEST_CHECK(typeValue);
2902     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2903   }
2904   {
2905     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2906     DALI_TEST_CHECK(typeValue);
2907     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2908   }
2909
2910   //Put the visual on the stage
2911   DummyControl        actor     = DummyControl::New(true);
2912   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2913   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2914   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2915   application.GetScene().Add(actor);
2916
2917   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2918   dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2919
2920   application.SendNotification();
2921   application.Render(0);
2922   Renderer renderer(actor.GetRendererAt(0));
2923
2924   Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2925   DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2926
2927   Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2928   DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2929
2930   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2931   DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2932
2933   Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2934   DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2935
2936   Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2937   DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2938
2939   Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2940   DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2941
2942   //Set a new transform
2943   transform.Clear();
2944   transform = DefaultTransform();
2945   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2946   transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2947   transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2948   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2949   visual.SetTransformAndSize(transform, Vector2(100, 100));
2950   application.SendNotification();
2951   application.Render(0);
2952
2953   //Check that the values have changed in the renderer
2954   offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2955   DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2956
2957   size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2958   DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2959
2960   offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2961   DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2962
2963   //Parent origin and anchor point should have the default values
2964   parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2965   DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2966
2967   anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2968   DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2969
2970   extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2971   DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2972 }
2973
2974 int UtcDaliVisualSetTransform01(void)
2975 {
2976   ToolkitTestApplication application;
2977   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2978
2979   VisualFactory factory = VisualFactory::Get();
2980   Property::Map propertyMap;
2981   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2982   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2983   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2984   Visual::Base visual = factory.CreateVisual(propertyMap);
2985   TestTransform(application, visual);
2986   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2987
2988   END_TEST;
2989 }
2990
2991 int UtcDaliVisualSetTransform0(void)
2992 {
2993   ToolkitTestApplication application;
2994   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2995
2996   VisualFactory factory = VisualFactory::Get();
2997   Property::Map propertyMap;
2998   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2999   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3000   Visual::Base visual = factory.CreateVisual(propertyMap);
3001   TestTransform(application, visual);
3002   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
3003
3004   END_TEST;
3005 }
3006
3007 int UtcDaliVisualSetTransform1(void)
3008 {
3009   ToolkitTestApplication application;
3010   tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
3011
3012   VisualFactory factory = VisualFactory::Get();
3013   Property::Map propertyMap;
3014   propertyMap[Toolkit::Visual::Property::TYPE]      = Visual::PRIMITIVE;
3015   propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
3016   propertyMap[PrimitiveVisual::Property::SHAPE]     = PrimitiveVisual::Shape::SPHERE;
3017   propertyMap[PrimitiveVisual::Property::SLICES]    = 10;
3018   propertyMap[PrimitiveVisual::Property::STACKS]    = 10;
3019   Visual::Base visual                               = factory.CreateVisual(propertyMap);
3020   TestTransform(application, visual);
3021   TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
3022
3023   END_TEST;
3024 }
3025
3026 int UtcDaliVisualSetTransform2(void)
3027 {
3028   ToolkitTestApplication application;
3029   tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3030
3031   VisualFactory factory = VisualFactory::Get();
3032   Property::Map propertyMap;
3033   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3034   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3035
3036   Property::Array stopOffsets;
3037   stopOffsets.PushBack(0.0f);
3038   stopOffsets.PushBack(0.3f);
3039   stopOffsets.PushBack(0.6f);
3040   stopOffsets.PushBack(0.8f);
3041   stopOffsets.PushBack(1.0f);
3042   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3043
3044   Property::Array stopColors;
3045   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3046   stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3047   stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3048   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3049   stopColors.PushBack(Color::YELLOW);
3050   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3051   propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3052   propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3053   Visual::Base visual = factory.CreateVisual(propertyMap);
3054   TestTransform(application, visual);
3055   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3056
3057   END_TEST;
3058 }
3059
3060 int UtcDaliVisualSetTransform3(void)
3061 {
3062   ToolkitTestApplication application;
3063   tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3064