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

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