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