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

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