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

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