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

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