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

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