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

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