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