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