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.1);
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.45f );
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
1761   Vector4 uColor;
1762   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1763   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1764
1765   application.Render(2000u);
1766
1767   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1768   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1769   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1770
1771   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1772   testColor = Vector4(1,1,1,0.1);
1773   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), TEST_LOCATION );
1774   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1775
1776   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1777   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1778
1779   END_TEST;
1780 }
1781
1782
1783 int UtcDaliVisualAnimateBorderVisual02(void)
1784 {
1785   ToolkitTestApplication application;
1786   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1787
1788   VisualFactory factory = VisualFactory::Get();
1789   Property::Map propertyMap;
1790   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1791   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1792   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1793   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1794
1795   DummyControl actor = DummyControl::New(true);
1796   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1797   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1798   actor.SetSize(2000, 2000);
1799   actor.SetParentOrigin(ParentOrigin::CENTER);
1800   Stage::GetCurrent().Add(actor);
1801
1802   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1803
1804   Renderer renderer = actor.GetRendererAt(0);
1805   Property::Index index = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::SIZE );
1806
1807   Animation animation = Animation::New(4.0f);
1808   animation.AnimateTo( Property(renderer, index), 9.0f );
1809   animation.Play();
1810
1811   application.SendNotification();
1812   application.Render(0);
1813   application.Render(2000u); // halfway point
1814
1815   float size = renderer.GetCurrentProperty< float >( index );
1816   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1817   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1818
1819   application.Render(2000u); // halfway point between blue and white
1820
1821   size = renderer.GetCurrentProperty< float >( index );
1822   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1823   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1824
1825   END_TEST;
1826 }
1827
1828 int UtcDaliVisualAnimateColorVisual(void)
1829 {
1830   ToolkitTestApplication application;
1831   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1832
1833   VisualFactory factory = VisualFactory::Get();
1834   Property::Map propertyMap;
1835   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1836   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1837   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1838
1839   DummyControl actor = DummyControl::New(true);
1840   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1841   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1842   actor.SetSize(2000, 2000);
1843   actor.SetParentOrigin(ParentOrigin::CENTER);
1844   Stage::GetCurrent().Add(actor);
1845
1846   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1847
1848   Renderer renderer = actor.GetRendererAt(0);
1849   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
1850
1851   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1852   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1853
1854   Animation animation = Animation::New(4.0f);
1855   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1856   animation.Play();
1857
1858   application.SendNotification();
1859   application.Render(0);
1860   application.Render(2000u); // halfway point
1861
1862   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1863   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1864   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1865
1866   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1867
1868   application.Render(2000u); // halfway point between blue and white
1869
1870   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1871   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1872
1873   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1874
1875   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1876   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1877
1878   END_TEST;
1879 }
1880
1881 int UtcDaliVisualAnimatePrimitiveVisual(void)
1882 {
1883   ToolkitTestApplication application;
1884   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1885
1886   {
1887     VisualFactory factory = VisualFactory::Get();
1888     Property::Map propertyMap;
1889     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1890     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1891     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1892     Visual::Base visual = factory.CreateVisual( propertyMap );
1893
1894     DummyControl actor = DummyControl::New(true);
1895     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1896     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1897     actor.SetSize(2000, 2000);
1898     actor.SetParentOrigin(ParentOrigin::CENTER);
1899     actor.SetColor(Color::BLACK);
1900     Stage::GetCurrent().Add(actor);
1901
1902     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1903
1904     Renderer renderer = actor.GetRendererAt(0);
1905     Property::Index index = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
1906
1907     tet_infoline("Test that the renderer has the Primitive mix color");
1908     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1909
1910     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1911     const Vector4 TARGET_MIX_COLOR( Color::RED );
1912
1913     Property::Map map;
1914     map["target"] = "testVisual";
1915     map["property"] = "mixColor";
1916     map["initialValue"] = INITIAL_MIX_COLOR;
1917     map["targetValue"] = TARGET_MIX_COLOR;
1918     map["animator"] = Property::Map()
1919       .Add("alphaFunction", "LINEAR")
1920       .Add("timePeriod", Property::Map()
1921            .Add("delay", 0.0f)
1922            .Add("duration", 4.0f));
1923
1924     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1925
1926     Animation animation = dummyImpl.CreateTransition( transition );
1927     Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1928     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
1929
1930     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1931     animation.Play();
1932
1933     application.SendNotification();
1934     application.Render(0);
1935     application.Render(2000u); // halfway point
1936     application.SendNotification();
1937
1938     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1939     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a )), true, TEST_LOCATION );
1940     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1941
1942     application.Render(2001u); // go past end
1943     application.SendNotification(); // Trigger signals
1944
1945     DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1946     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4( 1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a ) ), true, TEST_LOCATION );
1947     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1948
1949     blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1950     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1951
1952     actor.Unparent();
1953   }
1954
1955   END_TEST;
1956 }
1957
1958 int UtcDaliVisualAnimatedGradientVisual01(void)
1959 {
1960   ToolkitTestApplication application;
1961   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
1962
1963   {
1964     VisualFactory factory = VisualFactory::Get();
1965     Property::Map propertyMap;
1966     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1967     Visual::Base visual = factory.CreateVisual( propertyMap );
1968
1969     DummyControl actor = DummyControl::New(true);
1970     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1971     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1972     actor.SetSize(2000, 2000);
1973     actor.SetParentOrigin(ParentOrigin::CENTER);
1974     actor.SetColor(Color::BLACK);
1975     Stage::GetCurrent().Add(actor);
1976
1977     application.SendNotification();
1978     application.Render(0);
1979     application.SendNotification();
1980
1981     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1982
1983     for(int step_iter = 0; step_iter < 3; step_iter++)
1984     {
1985       application.SendNotification();
1986       application.Render(0);
1987       application.Render(750u); // step i/4
1988       application.SendNotification();
1989
1990       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
1991       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
1992       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1993       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1994       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
1995       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
1996       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
1997     }
1998
1999     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2000     application.Render(750u); // go to end
2001     application.SendNotification();
2002
2003     application.Render(10u); // finish
2004     application.SendNotification();
2005
2006     actor.Unparent();
2007     application.SendNotification();
2008     application.Render(0u);
2009     application.SendNotification();
2010   }
2011
2012   END_TEST;
2013 }
2014
2015 int UtcDaliVisualAnimatedGradientVisual02(void)
2016 {
2017   ToolkitTestApplication application;
2018   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
2019
2020   {
2021     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
2022     int _direction[2] = {0, 1};
2023     int _loop_count[3] = {-1, 0, 1};
2024     int _motion[2] = {0, 1};
2025     int _easing[4] = {0, 1, 2, 3};
2026
2027     int test_case_max = 4 * 2 * 3 * 2 * 4;
2028     int test_case = 0;
2029     int test_case_d = 7; // 7 is the number of animated properties.
2030
2031     float _duration = 0.4f;
2032     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2033     float noise_maker = 0.0f;
2034     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2035     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2036     {
2037       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2038
2039       VisualFactory factory = VisualFactory::Get();
2040       Property::Map propertyMap;
2041       Property::Map animationMap;
2042       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2043
2044       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2045       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2046       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2047
2048       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&
2049       {
2050         int tc = (test_case + tc_offset);
2051         int idx_easing = tc % 4; tc /= 4;
2052         int idx_motion = tc % 2; tc /= 2;
2053         int idx_loop_count = tc % 3; tc /= 3;
2054         int idx_direction = tc % 2; tc /= 2;
2055         int idx_delay = tc % 4; tc /= 4;
2056
2057         float duration = _duration - _repeat_delay;
2058         float repeat_delay = _repeat_delay;
2059         float delay = _delay[idx_delay] * _duration;
2060         int direction = _direction[idx_direction];
2061         int loop_count = _loop_count[idx_loop_count];
2062         int motion = _motion[idx_motion];
2063         int easing = _easing[idx_easing];
2064
2065         animationMap.Clear();
2066         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
2067         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
2068         if( direction == 0 )
2069         {
2070           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2071         }
2072         else
2073         {
2074           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2075         }
2076         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2077         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2078         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2079         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2080         if( motion == 0 )
2081         {
2082           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2083         }
2084         else
2085         {
2086           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2087         }
2088         if( easing == 0 )
2089         {
2090           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2091         }
2092         else if( easing == 1 )
2093         {
2094           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2095         }
2096         else if( easing == 2 )
2097         {
2098           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2099         }
2100         else
2101         {
2102           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2103         }
2104
2105         return animationMap;
2106       };
2107
2108       // Give different values for debuging
2109       noise_maker += 1.0f;
2110       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2111       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2112       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2113       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2114       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2115       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2116       float offset1 = 0.f + noise_maker * 0.1f;
2117
2118       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2119       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2120       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2121       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2122       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2123       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2124       float offset2 = 2.f + noise_maker * 0.1f;
2125
2126       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2127       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2128       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2129
2130       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2131       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2132       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2133       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2134       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2135       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2136       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2137
2138       Visual::Base visual = factory.CreateVisual( propertyMap );
2139
2140       DummyControl actor = DummyControl::New( true );
2141       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2142       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2143       actor.SetSize( 2000, 2000 );
2144       actor.SetParentOrigin(ParentOrigin::CENTER);
2145       actor.SetColor(Color::BLACK);
2146       Stage::GetCurrent().Add(actor);
2147
2148       application.SendNotification();
2149       application.Render( 0 );
2150       application.SendNotification();
2151
2152       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2153
2154       application.SendNotification();
2155
2156       //Compare between CPU calculated value and Shader Visual calculated value
2157       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
2158       {
2159         int tc = (test_case + tc_offset);
2160         int idx_easing = tc % 4; tc /= 4;
2161         int idx_motion = tc % 2; tc /= 2;
2162         int idx_loop_count = tc % 3; tc /= 3;
2163         int idx_direction = tc % 2; tc /= 2;
2164         int idx_delay = tc % 4; tc /= 4;
2165
2166         float duration = _duration - _repeat_delay;
2167         float repeat_delay = _repeat_delay;
2168         float delay = _delay[idx_delay] * _duration;
2169         int direction = _direction[idx_direction];
2170         int loop_count = _loop_count[idx_loop_count];
2171         int motion = _motion[idx_motion];
2172         int easing = _easing[idx_easing];
2173
2174         progress -= delay / _duration;
2175
2176         Property::Value s = start;
2177         Property::Value t = target;
2178         if( direction == 1 )
2179         {
2180           s = target;
2181           t = start;
2182         }
2183         float x; ///< Animator progress value
2184         if( loop_count == 0 )
2185         {
2186           x = 1.0f;
2187         }
2188         else if( loop_count > 0 && progress + 0.01f > loop_count )
2189         {
2190           x = ( motion == 0 ) ? 1.0f : 0.0f;
2191         }
2192         else
2193         {
2194           if( progress < 0.0f )
2195           {
2196             progress = 0.0f;
2197           }
2198           progress = fmodf( progress, 1.0f );
2199           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2200
2201           x = progress;
2202           if( motion == 1 )
2203           {
2204             x = progress * 2.0f;
2205             if( x > 1.0f )
2206             {
2207               x = 2.0f - x;
2208             }
2209           }
2210
2211           if( easing == 1 ) // EASE_IN
2212           {
2213             x = x*x;
2214           }
2215           else if( easing == 2 ) // EASE_OUT
2216           {
2217             x = 2.0f*x - x*x;
2218           }
2219           else if( easing == 3 ) // EASE_IN_OUT
2220           {
2221             x = x * x * (3.0f - 2.0f * x);
2222           }
2223         }
2224         if( value_type == 0 ) // result type is Float
2225         {
2226           float res;
2227           float cur;
2228           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2229           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2230           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2231         }
2232         else if( value_type == 1 ) // result type is Vector2
2233         {
2234           Vector2 res;
2235           Vector2 cur;
2236           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2237           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2238           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2239         }
2240         else if( value_type == 2 ) // result type is Vector3
2241         {
2242           Vector3 res;
2243           Vector3 cur;
2244           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2245           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2246           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2247         }
2248         else // result type is Vector4
2249         {
2250           Vector4 res;
2251           Vector4 cur;
2252           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2253           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2254           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2255         }
2256       };
2257
2258       float step = 0.0f;
2259       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2260       {
2261         for( int step_iter = 0; step_iter < 3; step_iter++ )
2262         {
2263           application.SendNotification();
2264           application.Render( _duration * 250.f );  // step i/4
2265           application.SendNotification();
2266           step += 0.25f;
2267
2268           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2269           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2270           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2271           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2272           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2273           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2274           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2275         }
2276         application.SendNotification();
2277         application.Render(_duration * 250.f);  // step 4/4 will not test
2278         application.SendNotification();
2279         step += 0.25f;
2280       }
2281
2282       application.SendNotification();
2283       actor.Unparent();
2284       application.SendNotification();
2285       application.Render(10.f);  // tempral time
2286       application.SendNotification();
2287     }
2288   }
2289
2290   END_TEST;
2291 }
2292
2293 int UtcDaliVisualAnimatedGradientVisual03(void)
2294 {
2295   ToolkitTestApplication application;
2296   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2297
2298   {
2299     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
2300     int _direction[2] = {0, 1};
2301     int _loop_count[3] = {-1, 0, 1};
2302     int _motion[2] = {0, 1};
2303     int _easing[4] = {0, 1, 2, 3};
2304
2305     int test_case_max = 4 * 2 * 3 * 2 * 4;
2306     int test_case = 0;
2307     int test_case_d = 7; // 7 is the number of animated properties.
2308
2309     float _duration = 0.4f;
2310     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2311     float noise_maker = 0.2f;
2312     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2313     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2314     {
2315       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2316
2317       VisualFactory factory = VisualFactory::Get();
2318       Property::Map propertyMap;
2319       Property::Map animationMap;
2320       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2321
2322       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&
2323       {
2324         int tc = (test_case + tc_offset);
2325         int idx_easing = tc % 4; tc /= 4;
2326         int idx_motion = tc % 2; tc /= 2;
2327         int idx_loop_count = tc % 3; tc /= 3;
2328         int idx_direction = tc % 2; tc /= 2;
2329         int idx_delay = tc % 4; tc /= 4;
2330
2331         float duration = _duration - _repeat_delay;
2332         float repeat_delay = _repeat_delay;
2333         float delay = _delay[idx_delay] * _duration;
2334         int direction = _direction[idx_direction];
2335         int loop_count = _loop_count[idx_loop_count];
2336         int motion = _motion[idx_motion];
2337         int easing = _easing[idx_easing];
2338
2339         animationMap.Clear();
2340         animationMap.Insert( "startValue", start );
2341         animationMap.Insert( "targetValue", target );
2342         if( direction == 0 )
2343         {
2344           animationMap.Insert("directionType", "FORWARD");
2345         }
2346         else
2347         {
2348           animationMap.Insert("directionType", "BACKWARD");
2349         }
2350         animationMap.Insert("duration", duration);
2351         animationMap.Insert("delay", delay);
2352         animationMap.Insert("repeat", loop_count);
2353         animationMap.Insert("repeatDelay", repeat_delay);
2354         if( motion == 0 )
2355         {
2356           animationMap.Insert("motionType", "LOOP");
2357         }
2358         else
2359         {
2360           animationMap.Insert("motionType", "MIRROR");
2361         }
2362         if( easing == 0 )
2363         {
2364           animationMap.Insert("easingType", "LINEAR");
2365         }
2366         else if( easing == 1 )
2367         {
2368           animationMap.Insert("easingType", "IN");
2369         }
2370         else if( easing == 2 )
2371         {
2372           animationMap.Insert("easingType", "OUT");
2373         }
2374         else
2375         {
2376           animationMap.Insert("easingType", "IN_OUT");
2377         }
2378
2379         return animationMap;
2380       };
2381
2382       // Give different values for debuging
2383       noise_maker += 0.8f;
2384       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2385       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2386       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2387       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2388       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2389       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2390       float offset1 = 0.f + noise_maker * 0.1f;
2391
2392       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2393       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2394       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2395       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2396       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2397       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2398       float offset2 = 2.f + noise_maker * 0.1f;
2399
2400       propertyMap.Insert("gradientType", "LINEAR");
2401       propertyMap.Insert("unitType",     "USER_SPACE");
2402       propertyMap.Insert("spreadType",   "CLAMP");
2403
2404       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2405       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2406       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2407       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2408       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2409       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2410       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2411
2412       Visual::Base visual = factory.CreateVisual( propertyMap );
2413
2414       DummyControl actor = DummyControl::New( true );
2415       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2416       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2417       actor.SetSize( 2000, 2000 );
2418       actor.SetParentOrigin(ParentOrigin::CENTER);
2419       actor.SetColor(Color::BLACK);
2420       Stage::GetCurrent().Add(actor);
2421
2422       application.SendNotification();
2423       application.Render( 0 );
2424       application.SendNotification();
2425
2426       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2427
2428       application.SendNotification();
2429
2430       //Compare between CPU calculated value and Shader Visual calculated value
2431       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
2432       {
2433         int tc = (test_case + tc_offset);
2434         int idx_easing = tc % 4; tc /= 4;
2435         int idx_motion = tc % 2; tc /= 2;
2436         int idx_loop_count = tc % 3; tc /= 3;
2437         int idx_direction = tc % 2; tc /= 2;
2438         int idx_delay = tc % 4; tc /= 4;
2439
2440         float duration = _duration - _repeat_delay;
2441         float repeat_delay = _repeat_delay;
2442         float delay = _delay[idx_delay] * _duration;
2443         int direction = _direction[idx_direction];
2444         int loop_count = _loop_count[idx_loop_count];
2445         int motion = _motion[idx_motion];
2446         int easing = _easing[idx_easing];
2447
2448         progress -= delay / _duration;
2449
2450         Property::Value s = start;
2451         Property::Value t = target;
2452         if( direction == 1 )
2453         {
2454           s = target;
2455           t = start;
2456         }
2457         float x; ///< Animator progress value
2458         if( loop_count == 0 )
2459         {
2460           x = 1.0f;
2461         }
2462         else if( loop_count > 0 && progress + 0.01f > loop_count )
2463         {
2464           x = ( motion == 0 ) ? 1.0f : 0.0f;
2465         }
2466         else
2467         {
2468           if( progress < 0.0f )
2469           {
2470             progress = 0.0f;
2471           }
2472           progress = fmodf( progress, 1.0f );
2473           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2474
2475           x = progress;
2476           if( motion == 1 )
2477           {
2478             x = progress * 2.0f;
2479             if( x > 1.0f )
2480             {
2481               x = 2.0f - x;
2482             }
2483           }
2484
2485           if( easing == 1 ) // EASE_IN
2486           {
2487             x = x*x;
2488           }
2489           else if( easing == 2 ) // EASE_OUT
2490           {
2491             x = 2.0f*x - x*x;
2492           }
2493           else if( easing == 3 ) // EASE_IN_OUT
2494           {
2495             x = x * x * (3.0f - 2.0f * x);
2496           }
2497         }
2498         if( value_type == 0 ) // result type is Float
2499         {
2500           float res;
2501           float cur;
2502           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2503           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2504           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2505         }
2506         else if( value_type == 1 ) // result type is Vector2
2507         {
2508           Vector2 res;
2509           Vector2 cur;
2510           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2511           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2512           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2513         }
2514         else if( value_type == 2 ) // result type is Vector3
2515         {
2516           Vector3 res;
2517           Vector3 cur;
2518           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2519           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2520           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2521         }
2522         else // result type is Vector4
2523         {
2524           Vector4 res;
2525           Vector4 cur;
2526           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2527           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2528           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2529         }
2530       };
2531
2532       float step = 0.0f;
2533       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2534       {
2535         for( int step_iter = 0; step_iter < 3; step_iter++ )
2536         {
2537           application.SendNotification();
2538           application.Render( _duration * 250.f );  // step i/4
2539           application.SendNotification();
2540           step += 0.25f;
2541
2542           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2543           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2544           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2545           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2546           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2547           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2548           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2549         }
2550         application.SendNotification();
2551         application.Render(_duration * 250.f);  // step 4/4 will not test
2552         application.SendNotification();
2553         step += 0.25f;
2554       }
2555
2556       application.SendNotification();
2557       actor.Unparent();
2558       application.SendNotification();
2559       application.Render(10.f);  // tempral time
2560       application.SendNotification();
2561     }
2562   }
2563
2564   END_TEST;
2565 }
2566
2567 int UtcDaliVisualWireframeVisual(void)
2568 {
2569   ToolkitTestApplication application;
2570
2571   VisualFactory factory = VisualFactory::Get();
2572   Property::Map propertyMap;
2573   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2574
2575   // Create the visual.
2576   Visual::Base visual = factory.CreateVisual( propertyMap );
2577
2578   DALI_TEST_CHECK( visual );
2579
2580   Property::Map resultMap;
2581   visual.CreatePropertyMap( resultMap );
2582
2583   // Check the property values from the returned map from visual
2584   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2585   DALI_TEST_CHECK( value );
2586   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2587
2588   END_TEST;
2589 }
2590
2591 int UtcDaliVisualGetTransform(void)
2592 {
2593   ToolkitTestApplication application;
2594   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2595
2596   VisualFactory factory = VisualFactory::Get();
2597   Property::Map propertyMap;
2598   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2599   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2600   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2601
2602   Dali::Property::Map visualMap;
2603   colorVisual.CreatePropertyMap( visualMap );
2604   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2605   Dali::Property::Map* map = value->GetMap();
2606   DALI_TEST_CHECK( map );
2607
2608   //Test default values
2609   {
2610     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2611     DALI_TEST_CHECK( typeValue );
2612     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2613   }
2614   {
2615     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2616     DALI_TEST_CHECK( typeValue );
2617     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2618   }
2619   {
2620     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2621     DALI_TEST_CHECK( typeValue );
2622     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2623   }
2624   {
2625     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2626     DALI_TEST_CHECK( typeValue );
2627     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2628   }
2629   {
2630     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2631     DALI_TEST_CHECK( typeValue );
2632     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2633   }
2634   {
2635     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2636     DALI_TEST_CHECK( typeValue );
2637     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2638   }
2639
2640   END_TEST;
2641 }
2642
2643 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2644 {
2645   Property::Map transform;
2646   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2647   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2648   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2649   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2650   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2651
2652   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2653
2654   Dali::Property::Map visualMap;
2655   visual.CreatePropertyMap( visualMap );
2656   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2657   Dali::Property::Map* map = value->GetMap();
2658   DALI_TEST_CHECK( map );
2659
2660   {
2661     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2662     DALI_TEST_CHECK( typeValue );
2663     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2664   }
2665   {
2666     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2667     DALI_TEST_CHECK( typeValue );
2668     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2669   }
2670   {
2671     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2672     DALI_TEST_CHECK( typeValue );
2673     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2674   }
2675   {
2676     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2677     DALI_TEST_CHECK( typeValue );
2678     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2679   }
2680   {
2681     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2682     DALI_TEST_CHECK( typeValue );
2683     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2684   }
2685   {
2686     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2687     DALI_TEST_CHECK( typeValue );
2688     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2689   }
2690
2691   //Put the visual on the stage
2692   DummyControl actor = DummyControl::New(true);
2693   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2694   actor.SetSize(2000, 2000);
2695   actor.SetParentOrigin(ParentOrigin::CENTER);
2696   Stage::GetCurrent().Add(actor);
2697
2698   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2699   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2700
2701   application.SendNotification();
2702   application.Render(0);
2703   Renderer renderer( actor.GetRendererAt(0) );
2704
2705   //Check that the properties have been registered on the Renderer
2706   Property::Index index = renderer.GetPropertyIndex( "offset" );
2707   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2708   Vector2 offset = renderer.GetProperty<Vector2>( index );
2709   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2710
2711   index = renderer.GetPropertyIndex( "size" );
2712   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2713   Vector2 size = renderer.GetProperty<Vector2>( index );
2714   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2715
2716   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2717   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2718   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2719   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2720
2721   index = renderer.GetPropertyIndex( "origin" );
2722   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2723   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2724   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2725
2726   index = renderer.GetPropertyIndex( "anchorPoint" );
2727   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2728   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2729   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2730
2731   //Set a new transform
2732   transform.Clear();
2733   transform = DefaultTransform();
2734   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2735   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2736   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2737   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2738   application.SendNotification();
2739   application.Render(0);
2740
2741   //Check that the values have changed in the renderer
2742   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2743   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2744
2745   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2746   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2747
2748   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2749   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2750
2751   //Parent origin and anchor point should have the default values
2752   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2753   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2754
2755   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2756   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2757 }
2758
2759 int UtcDaliVisualSetTransform0(void)
2760 {
2761   ToolkitTestApplication application;
2762   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2763
2764   VisualFactory factory = VisualFactory::Get();
2765   Property::Map propertyMap;
2766   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2767   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2768   Visual::Base visual = factory.CreateVisual( propertyMap );
2769   TestTransform( application, visual );
2770   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2771
2772   END_TEST;
2773 }
2774
2775 int UtcDaliVisualSetTransform1(void)
2776 {
2777   ToolkitTestApplication application;
2778   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2779
2780   VisualFactory factory = VisualFactory::Get();
2781   Property::Map propertyMap;
2782   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2783   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2784   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2785   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2786   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
2787   Visual::Base visual = factory.CreateVisual( propertyMap );
2788   TestTransform( application, visual );
2789   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
2790
2791   END_TEST;
2792 }
2793
2794 int UtcDaliVisualSetTransform2(void)
2795 {
2796   ToolkitTestApplication application;
2797   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
2798
2799   VisualFactory factory = VisualFactory::Get();
2800   Property::Map propertyMap;
2801   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
2802   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
2803
2804   Property::Array stopOffsets;
2805   stopOffsets.PushBack( 0.0f );
2806   stopOffsets.PushBack( 0.3f );
2807   stopOffsets.PushBack( 0.6f );
2808   stopOffsets.PushBack( 0.8f );
2809   stopOffsets.PushBack( 1.0f );
2810   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
2811
2812   Property::Array stopColors;
2813   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
2814   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
2815   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
2816   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
2817   stopColors.PushBack( Color::YELLOW );
2818   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
2819   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
2820   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
2821   Visual::Base visual = factory.CreateVisual( propertyMap );
2822   TestTransform( application, visual );
2823   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
2824
2825   END_TEST;
2826 }
2827
2828 int UtcDaliVisualSetTransform3(void)
2829 {
2830   ToolkitTestApplication application;
2831   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
2832
2833   VisualFactory factory = VisualFactory::Get();
2834   Property::Map propertyMap;
2835   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
2836   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
2837   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
2838   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
2839   Visual::Base visual = factory.CreateVisual( propertyMap );
2840   TestTransform( application, visual );
2841   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
2842
2843   END_TEST;
2844 }
2845
2846 int UtcDaliVisualSetTransform4(void)
2847 {
2848   ToolkitTestApplication application;
2849   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
2850
2851   VisualFactory factory = VisualFactory::Get();
2852   Property::Map propertyMap;
2853   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
2854   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
2855
2856   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
2857   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
2858   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
2859   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
2860   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
2861   Visual::Base visual = factory.CreateVisual( propertyMap );
2862   TestTransform( application, visual );
2863   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
2864
2865   END_TEST;
2866 }
2867
2868 int UtcDaliVisualSetTransform5(void)
2869 {
2870   ToolkitTestApplication application;
2871   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
2872
2873   VisualFactory factory = VisualFactory::Get();
2874   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
2875   Visual::Base visual = factory.CreateVisual(image);
2876   TestTransform( application, visual );
2877   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2878
2879   END_TEST;
2880 }
2881
2882 int UtcDaliVisualSetTransform6(void)
2883 {
2884   ToolkitTestApplication application;
2885   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
2886
2887   VisualFactory factory = VisualFactory::Get();
2888   Property::Map propertyMap;
2889   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
2890   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
2891   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2892   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
2893   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
2894   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
2895   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
2896   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
2897   Visual::Base visual = factory.CreateVisual(propertyMap);
2898   TestTransform( application, visual );
2899   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
2900
2901   END_TEST;
2902 }
2903
2904 int UtcDaliVisualSetTransform7(void)
2905 {
2906   ToolkitTestApplication application;
2907   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
2908
2909   VisualFactory factory = VisualFactory::Get();
2910   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
2911   Visual::Base visual = factory.CreateVisual(image);
2912   TestTransform( application, visual );
2913   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2914
2915   END_TEST;
2916 }
2917
2918 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
2919 {
2920   ToolkitTestApplication application;
2921   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
2922
2923   VisualFactory factory = VisualFactory::Get();
2924   Property::Map propertyMap;
2925   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2926   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2927   Visual::Base visual = factory.CreateVisual( propertyMap );
2928
2929   Property::Map transform;
2930   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
2931                                                  .Add( "RELATIVE" );
2932   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
2933                                                  .Add( "ABSOLUTE" );
2934   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2935
2936   Dali::Property::Map visualMap;
2937   visual.CreatePropertyMap( visualMap );
2938   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2939   Dali::Property::Map* map = value->GetMap();
2940   DALI_TEST_CHECK( map );
2941
2942   {
2943     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2944     DALI_TEST_CHECK( typeValue );
2945     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2946   }
2947   {
2948     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2949     DALI_TEST_CHECK( typeValue );
2950     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2951   }
2952
2953   END_TEST;
2954 }
2955
2956 int UtcDaliNPatchVisualCustomShader(void)
2957 {
2958   ToolkitTestApplication application;
2959   tet_infoline( "NPatchVisual with custom shader" );
2960
2961   VisualFactory factory = VisualFactory::Get();
2962   Property::Map properties;
2963   Property::Map shader;
2964   const std::string vertexShader = "Foobar";
2965   const std::string fragmentShader = "Foobar";
2966   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2967   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
2968
2969   Property::Map transformMap;
2970   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
2971   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
2972   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
2973   transformMap["anchorPoint"] = Align::CENTER;
2974   transformMap["origin"] = Align::CENTER;
2975   properties[Visual::Property::TRANSFORM] = transformMap;
2976
2977   properties[Visual::Property::TYPE] = Visual::IMAGE;
2978   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
2979   properties[Visual::Property::SHADER]=shader;
2980   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
2981
2982   Visual::Base visual = factory.CreateVisual( properties );
2983   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
2984
2985   // trigger creation through setting on stage
2986   DummyControl dummy = DummyControl::New(true);
2987   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
2988   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2989   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
2990   dummy.SetSize(2000, 2000);
2991   dummy.SetParentOrigin(ParentOrigin::CENTER);
2992   Stage::GetCurrent().Add(dummy);
2993   application.SendNotification();
2994
2995   Renderer renderer = dummy.GetRendererAt( 0 );
2996   Shader shader2 = renderer.GetShader();
2997   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
2998   Property::Map* map = value.GetMap();
2999   DALI_TEST_CHECK( map );
3000
3001   Property::Index index = renderer.GetPropertyIndex("size");
3002   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
3003
3004   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3005   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
3006
3007   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3008   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
3009
3010   END_TEST;
3011 }
3012
3013 int UtcDaliGradientVisualBlendMode(void)
3014 {
3015   ToolkitTestApplication application;
3016   VisualFactory factory = VisualFactory::Get();
3017
3018   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3019       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3020                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3021                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3022                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3023                                                                                   .Add( Color::GREEN ) ) );
3024
3025   Visual::Base alphaGradientVisual = factory.CreateVisual(
3026       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3027                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3028                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3029                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3030                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
3031
3032   DummyControl control = DummyControl::New(true);
3033   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3034   Stage::GetCurrent().Add( control );
3035
3036   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
3037   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
3038   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
3039
3040   application.SendNotification();
3041   application.Render();
3042
3043   // 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
3044   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
3045   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
3046   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
3047
3048   END_TEST;
3049 }
3050
3051 int UtcDaliVisualRendererRemovalAndReAddition(void)
3052 {
3053   ToolkitTestApplication application;
3054   tet_infoline( "UtcDaliVisualRendererRemoval" );
3055
3056   VisualFactory factory = VisualFactory::Get();
3057   Property::Map propertyMap;
3058   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3059   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3060   Visual::Base visual = factory.CreateVisual( propertyMap );
3061
3062   visual.SetDepthIndex( 1 );
3063
3064   DummyControl dummyControl = DummyControl::New(true);
3065   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3066   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3067   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3068
3069   dummyControl.SetSize(200.f, 200.f);
3070   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
3071
3072   Stage::GetCurrent().Add( dummyControl );
3073
3074   application.SendNotification();
3075   application.Render();
3076
3077   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3078
3079   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
3080   Stage::GetCurrent().Remove( dummyControl );
3081   application.SendNotification();
3082   application.Render();
3083
3084   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3085
3086   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
3087
3088   Stage::GetCurrent().Add( dummyControl );
3089
3090   application.SendNotification();
3091   application.Render();
3092
3093   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3094
3095   END_TEST;
3096 }
3097
3098
3099
3100 int UtcDaliVisualTextVisualRender(void)
3101 {
3102   ToolkitTestApplication application;
3103   tet_infoline( "UtcDaliVisualTextVisualRender" );
3104
3105   VisualFactory factory = VisualFactory::Get();
3106   Property::Map propertyMap;
3107   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3108   propertyMap.Insert( "mixColor", Color::WHITE );
3109   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3110   propertyMap.Insert( "enableMarkup", false );
3111   propertyMap.Insert( "text", "Hello world" );
3112   propertyMap.Insert( "fontFamily", "TizenSans" );
3113
3114   Property::Map fontStyleMapSet;
3115   fontStyleMapSet.Insert( "weight", "bold" );
3116   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3117
3118   propertyMap.Insert( "pointSize", 12.f );
3119   propertyMap.Insert( "multiLine", true );
3120   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3121   propertyMap.Insert( "verticalAlignment", "CENTER" );
3122   propertyMap.Insert( "textColor", Color::RED );
3123   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3124   textVisual.SetDepthIndex( 1 );
3125
3126   DummyControl dummyControl = DummyControl::New(true);
3127   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3128   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3129   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3130
3131   dummyControl.SetSize(200.f, 200.f);
3132   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3133
3134   Stage::GetCurrent().Add( dummyControl );
3135   application.SendNotification();
3136   application.Render();
3137
3138
3139   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3140   propertyMap.Clear();
3141   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3142   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3143   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3144   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3145
3146   Property::Map transformMap;
3147   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3148   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3149
3150   textVisual = factory.CreateVisual( propertyMap );
3151   textVisual.SetDepthIndex( 1 );
3152
3153   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3154   dummyControl.SetSize( 720.f, 640.f );
3155
3156   application.SendNotification(); // force process events to ensure text visual
3157   // adds renderer to the dummy control in OnRelayout
3158   application.Render();
3159
3160   Renderer renderer = dummyControl.GetRendererAt(0u);
3161   Property::Index index = renderer.GetPropertyIndex("size");
3162
3163   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3164   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3165
3166   END_TEST;
3167 }
3168
3169 int UtcDaliVisualTextVisualDisableEnable(void)
3170 {
3171   ToolkitTestApplication application;
3172   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3173
3174   VisualFactory factory = VisualFactory::Get();
3175   Property::Map propertyMap;
3176   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3177   propertyMap.Insert( "mixColor", Color::WHITE );
3178   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3179   propertyMap.Insert( "enableMarkup", false );
3180   propertyMap.Insert( "text", "Hello world" );
3181   propertyMap.Insert( "fontFamily", "TizenSans" );
3182
3183   Property::Map fontStyleMapSet;
3184   fontStyleMapSet.Insert( "weight", "bold" );
3185   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3186
3187   propertyMap.Insert( "pointSize", 12.f );
3188   propertyMap.Insert( "multiLine", true );
3189   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3190   propertyMap.Insert( "verticalAlignment", "CENTER" );
3191   propertyMap.Insert( "textColor", Color::RED );
3192   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3193   textVisual.SetDepthIndex( 1 );
3194
3195   DummyControl dummyControl = DummyControl::New(true);
3196   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3197   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3198   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3199
3200   dummyControl.SetSize(200.f, 200.f);
3201   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3202
3203   Stage::GetCurrent().Add( dummyControl );
3204   application.SendNotification();
3205   application.Render();
3206
3207   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3208
3209   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3210
3211   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3212
3213   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3214
3215   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3216
3217   END_TEST;
3218 }
3219
3220 int UtcDaliVisualPremultipliedAlpha(void)
3221 {
3222   ToolkitTestApplication application;
3223   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3224
3225   VisualFactory factory = VisualFactory::Get();
3226
3227   // image visual, test default value ( false )
3228   {
3229     Visual::Base imageVisual = factory.CreateVisual(
3230           Property::Map()
3231           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3232           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3233
3234     Dali::Property::Map visualMap;
3235     imageVisual.CreatePropertyMap( visualMap );
3236     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3237
3238     // test values
3239     DALI_TEST_CHECK( value );
3240     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
3241   }
3242
3243   // image visual, override premultiplied
3244   {
3245     Visual::Base imageVisual = factory.CreateVisual(
3246           Property::Map()
3247           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3248           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3249           .Add( Visual::Property::PREMULTIPLIED_ALPHA, true ) );
3250
3251     Dali::Property::Map visualMap;
3252     imageVisual.CreatePropertyMap( visualMap );
3253     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3254
3255     // test values
3256     DALI_TEST_CHECK( value );
3257     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
3258   }
3259
3260   // svg visual ( premultiplied alpha by default is true )
3261   {
3262     Visual::Base imageVisual = factory.CreateVisual(
3263           Property::Map()
3264           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3265           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3266
3267     Dali::Property::Map visualMap;
3268     imageVisual.CreatePropertyMap( visualMap );
3269     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3270
3271     // test values
3272     DALI_TEST_CHECK( value );
3273     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3274   }
3275
3276   END_TEST;
3277 }
3278
3279 int UtcDaliRegisterVisualOrder(void)
3280 {
3281   ToolkitTestApplication application;
3282   tet_infoline( "Register Visual Order" );
3283
3284   DummyControl dummyControl = DummyControl::New(true);
3285   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3286
3287   VisualFactory factory = VisualFactory::Get();
3288   Property::Map propertyMap;
3289   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3290   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3291
3292   tet_infoline( "Register visual, should have depth index of 0.0f" );
3293   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3294   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3295   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3296
3297   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3298
3299   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3300   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3301   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3302
3303   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3304   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3305   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3306
3307   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3308   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3309   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3310
3311   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3312   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3313   labelVisual.SetDepthIndex( -2000 );
3314   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3315   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3316
3317   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3318   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3319   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3320   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3321   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3322   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3323
3324   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3325   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3326   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3327   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3328   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3329
3330   dummyControl.SetSize(200.f, 200.f);
3331   Stage::GetCurrent().Add( dummyControl );
3332
3333   END_TEST;
3334 }
3335
3336 int UtcDaliRegisterVisualOrder02(void)
3337 {
3338   ToolkitTestApplication application;
3339   tet_infoline( "Register Visual Order with Background Set" );
3340
3341   DummyControl dummyControl = DummyControl::New(true);
3342   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3343
3344   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3345
3346   VisualFactory factory = VisualFactory::Get();
3347   Property::Map propertyMap;
3348   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3349   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3350
3351   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3352
3353   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3354
3355   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3356   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3357   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3358   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3359   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3360
3361   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3362   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3363   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3364   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3365
3366   dummyControl.SetSize(200.f, 200.f);
3367   Stage::GetCurrent().Add( dummyControl );
3368
3369   END_TEST;
3370 }
3371
3372 int UtcDaliRegisterVisualWithDepthIndex(void)
3373 {
3374   ToolkitTestApplication application;
3375   tet_infoline( "Register a Visual With Depth Index" );
3376
3377   DummyControl dummyControl = DummyControl::New(true);
3378   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3379
3380   VisualFactory factory = VisualFactory::Get();
3381   Property::Map propertyMap;
3382   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3383   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3384
3385   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3386   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3387   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3388   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3389   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3390
3391   tet_infoline( "Register another visual with a depth index and it disabled" );
3392   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3393   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3394   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3395   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3396
3397   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3398   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3399   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3400   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3401   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3402
3403   dummyControl.SetSize(200.f, 200.f);
3404   Stage::GetCurrent().Add( dummyControl );
3405
3406   END_TEST;
3407 }
3408
3409 int UtcDaliColorVisualRenderIfTransparentProperty(void)
3410 {
3411   ToolkitTestApplication application;
3412   tet_infoline( "Test the renderIfTransparent property of ColorVisual" );
3413
3414   VisualFactory factory = VisualFactory::Get();
3415   Property::Map propertyMap;
3416   propertyMap.Insert( Visual::Property::TYPE,  Visual::COLOR );
3417   propertyMap.Insert( ColorVisual::Property::MIX_COLOR, Color::BLUE );
3418
3419   tet_infoline( "Check default value" );
3420   {
3421     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3422     Property::Map returnedMap;
3423     testVisual.CreatePropertyMap( returnedMap );
3424
3425     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3426     DALI_TEST_CHECK( renderIfTransparentProperty );
3427     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3428   }
3429
3430   propertyMap.Insert( DevelColorVisual::Property::RENDER_IF_TRANSPARENT, true );
3431
3432   tet_infoline( "Ensure set to value required" );
3433   {
3434     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3435     Property::Map returnedMap;
3436     testVisual.CreatePropertyMap( returnedMap );
3437
3438     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3439     DALI_TEST_CHECK( renderIfTransparentProperty );
3440     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), true, TEST_LOCATION );
3441   }
3442
3443   propertyMap[ DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = Color::BLUE;
3444
3445   tet_infoline( "Ensure it returns default value if set to wrong type" );
3446   {
3447     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3448     Property::Map returnedMap;
3449     testVisual.CreatePropertyMap( returnedMap );
3450
3451     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3452     DALI_TEST_CHECK( renderIfTransparentProperty );
3453     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3454   }
3455
3456   END_TEST;
3457 }