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

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