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