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