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

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