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

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <iostream>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali/devel-api/object/handle-devel.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  25 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  27 #include <dali-toolkit/devel-api/visuals/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   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1132
1133   Property::Map resultMap;
1134   textVisual.CreatePropertyMap( resultMap );
1135
1136   //Check values in the result map are identical to the initial map's values.
1137   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1138   DALI_TEST_CHECK( value );
1139   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION );
1140
1141   value = resultMap.Find( Visual::Property::MIX_COLOR, Property::VECTOR4 );
1142   DALI_TEST_CHECK( value );
1143   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1144
1145   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1146   DALI_TEST_CHECK( value );
1147   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1148
1149   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1150   DALI_TEST_CHECK( value );
1151   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1152
1153   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1154   DALI_TEST_CHECK( value );
1155
1156   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1157   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1158   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1159
1160   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1161   DALI_TEST_CHECK( value );
1162   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1163
1164   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1165   DALI_TEST_CHECK( value );
1166   DALI_TEST_CHECK( value->Get<bool>() );
1167
1168   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER );
1169   DALI_TEST_CHECK( value );
1170   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION );
1171
1172   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER );
1173   DALI_TEST_CHECK( value );
1174   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION );
1175
1176   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1177   DALI_TEST_CHECK( value );
1178   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1179
1180   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1181   DALI_TEST_CHECK( value );
1182   DALI_TEST_CHECK( !value->Get<bool>() );
1183
1184   value = resultMap.Find( TextVisual::Property::SHADOW, Property::MAP );
1185   DALI_TEST_CHECK( value );
1186
1187   Property::Map shadowMapGet = value->Get<Property::Map>();
1188   DALI_TEST_EQUALS( shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION );
1189   DALI_TEST_EQUALS( DaliTestCheckMaps( shadowMapGet, shadowMapSet ), true, TEST_LOCATION );
1190
1191   value = resultMap.Find( TextVisual::Property::UNDERLINE, Property::MAP );
1192   DALI_TEST_CHECK( value );
1193
1194   Property::Map underlineMapGet = value->Get<Property::Map>();
1195   DALI_TEST_EQUALS( underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION );
1196   DALI_TEST_EQUALS( DaliTestCheckMaps( underlineMapGet, underlineMapSet ), true, TEST_LOCATION );
1197
1198   value = resultMap.Find( DevelTextVisual::Property::OUTLINE, Property::MAP );
1199   DALI_TEST_CHECK( value );
1200
1201   Property::Map outlineMapGet = value->Get<Property::Map>();
1202   DALI_TEST_EQUALS( outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION );
1203   DALI_TEST_EQUALS( DaliTestCheckMaps( outlineMapGet, outlineMapSet ), true, TEST_LOCATION );
1204
1205   END_TEST;
1206 }
1207
1208 int UtcDaliVisualGetPropertyMap11(void)
1209 {
1210   ToolkitTestApplication application;
1211   tet_infoline( "UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual" );
1212
1213   VisualFactory factory = VisualFactory::Get();
1214   DALI_TEST_CHECK( factory );
1215
1216   Property::Map propertyMap;
1217   propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1218
1219   Vector2 start(-0.5f, 0.5f);
1220   Vector2 end  (0.5f, -0.0f);
1221   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1222   Vector4 end_color  (0.7f, 0.5f, 1.0f, 1.0f);
1223   Vector2 rotate_center(0.0f, 0.4f);
1224   float rotate_amount = 1.57f;
1225   float offset = 100.f;
1226
1227   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::RADIAL);
1228   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1229   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::CLAMP);
1230
1231   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION,  start);
1232   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,  end);
1233   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,  start_color);
1234   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,  end_color);
1235   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  rotate_center);
1236   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  rotate_amount);
1237   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,  offset);
1238
1239   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1240   DALI_TEST_CHECK( animatedGradientVisual );
1241
1242   Property::Map resultMap;
1243   animatedGradientVisual.CreatePropertyMap( resultMap );
1244
1245   // check the property values from the returned map from visual
1246   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1247   DALI_TEST_CHECK( value );
1248   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1249
1250   value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1251   DALI_TEST_CHECK( value );
1252   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1253
1254   value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1255   DALI_TEST_CHECK( value );
1256   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1257
1258   value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1259   DALI_TEST_CHECK( value );
1260   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP );
1261
1262
1263   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1264   DALI_TEST_CHECK( value );
1265   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1266
1267   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1268   DALI_TEST_CHECK( value );
1269   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1270
1271   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1272   DALI_TEST_CHECK( value );
1273   DALI_TEST_EQUALS( value->Get<Vector4>(), start_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1274
1275   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1276   DALI_TEST_CHECK( value );
1277   DALI_TEST_EQUALS( value->Get<Vector4>(), end_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1278
1279   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1280   DALI_TEST_CHECK( value );
1281   DALI_TEST_EQUALS( value->Get<Vector2>(), rotate_center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1282
1283   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1284   DALI_TEST_CHECK( value );
1285   DALI_TEST_EQUALS( value->Get<float>(), rotate_amount , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1286
1287   value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1288   DALI_TEST_CHECK( value );
1289   DALI_TEST_EQUALS( value->Get<float>(), offset , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1290
1291   END_TEST;
1292 }
1293
1294 int UtcDaliVisualGetPropertyMap12(void)
1295 {
1296   ToolkitTestApplication application;
1297   tet_infoline( "UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param" );
1298
1299   // Case 1 : Set values by index
1300   {
1301     tet_printf( " - Set Values by Index\n" );
1302     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1303     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1304     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1305     {
1306       tet_printf( "test with delay [%f]\n", _delay );
1307       VisualFactory factory = VisualFactory::Get();
1308       DALI_TEST_CHECK( factory );
1309
1310       Property::Map propertyMap;
1311       Property::Map animationMap;
1312       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1313
1314       float duration = 1.1f;
1315       float delay = _delay;
1316       float repeat_delay = 0.4f;
1317
1318       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1319       int loop_count = 5;
1320       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1321       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1322
1323       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1324       {
1325         animationMap.Clear();
1326         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1327         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1328         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1329         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1330         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1331         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1332         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1333         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1334         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1335
1336         return animationMap;
1337       };
1338
1339       Vector2 start1(-0.5f, 0.5f);
1340       Vector2 end1  (0.5f, -0.5f);
1341       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1342       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1343       Vector2 rotate_center1(0.0f, 0.4f);
1344       float rotate_amount1 = 0.0f;
1345       float offset1 = 0.f;
1346
1347       Vector2 start2(-0.5f, -0.5f);
1348       Vector2 end2  (0.5f, 0.5f);
1349       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1350       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1351       Vector2 rotate_center2(0.0f, -0.4f);
1352       float rotate_amount2 = 6.2832f;
1353       float offset2 = 2.f;
1354
1355       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1356       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1357       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REPEAT);
1358
1359       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1360       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1361       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1362       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1363       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1364       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1365       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1366
1367       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1368       DALI_TEST_CHECK( animatedGradientVisual );
1369
1370       Property::Map resultMap;
1371       animatedGradientVisual.CreatePropertyMap( resultMap );
1372
1373       // check the property values from the returned map from visual
1374       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1375       DALI_TEST_CHECK( value );
1376       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1377
1378       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1379       DALI_TEST_CHECK( value );
1380       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1381
1382       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1383       DALI_TEST_CHECK( value );
1384       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1385
1386       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1387       DALI_TEST_CHECK( value );
1388       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT );
1389
1390       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
1391       {
1392         tet_printf("Check value at %d\n", line_num);
1393         value = resultMap.Find( index, Property::MAP );
1394         DALI_TEST_CHECK( value );
1395         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1396         Property::Map *temp_map = value->GetMap();
1397         DALI_TEST_CHECK( temp_map );
1398
1399         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1400         {
1401           Property::Value *res = temp_map->Find( index );
1402           DALI_TEST_CHECK( res );
1403           return *res;
1404         };
1405
1406         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1407         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1408         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1409         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1410         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1411         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1412         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1413         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1414         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1415       };
1416
1417       // check the animation map data is good
1418       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1419       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1420       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1421       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1422       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1423       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1424       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1425     }
1426   }
1427
1428   // Case 2 : Set values by string
1429   {
1430     tet_printf( " - Set Values by String\n" );
1431     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1432     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1433     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1434     {
1435       tet_printf( "test with delay [%f]\n", _delay );
1436       VisualFactory factory = VisualFactory::Get();
1437       DALI_TEST_CHECK( factory );
1438
1439       Property::Map propertyMap;
1440       Property::Map animationMap;
1441       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1442
1443       float duration = 1.1f;
1444       float delay = _delay;
1445       float repeat_delay = 0.4f;
1446
1447       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1448       int loop_count = 5;
1449       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1450       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1451
1452       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value &start, const Property::Value &target)->Property::Map&
1453       {
1454         animationMap.Clear();
1455         animationMap.Insert("startValue"   , start);
1456         animationMap.Insert("targetValue"  , target);
1457         animationMap.Insert("directionType", "BACKWARD");
1458         animationMap.Insert("duration"     , duration);
1459         animationMap.Insert("delay"        , delay);
1460         animationMap.Insert("repeat"       , loop_count);
1461         animationMap.Insert("repeatDelay"  , repeat_delay);
1462         animationMap.Insert("motionType"   , "MIRROR");
1463         animationMap.Insert("easingType"   , "IN_OUT");
1464
1465         return animationMap;
1466       };
1467
1468       Vector2 start1(-0.5f, 0.5f);
1469       Vector2 end1  (0.5f, -0.5f);
1470       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1471       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1472       Vector2 rotate_center1(0.0f, 0.4f);
1473       float rotate_amount1 = 0.0f;
1474       float offset1 = 0.f;
1475
1476       Vector2 start2(-0.5f, -0.5f);
1477       Vector2 end2  (0.5f, 0.5f);
1478       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1479       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1480       Vector2 rotate_center2(0.0f, -0.4f);
1481       float rotate_amount2 = 6.2832f;
1482       float offset2 = 2.f;
1483
1484       // For test mix the type string/index key and string/index value works well.
1485       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  "RADIAL");
1486       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1487       propertyMap.Insert("spreadType"  , DevelAnimatedGradientVisual::SpreadType::REFLECT);
1488
1489       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ));
1490       propertyMap.Insert("endPosition"  , buildAnimatedMap(end1          , end2          ));
1491       propertyMap.Insert("startColor"   , buildAnimatedMap(start_color1  , start_color2  ));
1492       propertyMap.Insert("endColor"     , buildAnimatedMap(end_color1    , end_color2    ));
1493       propertyMap.Insert("rotateCenter" , buildAnimatedMap(rotate_center1, rotate_center2));
1494       propertyMap.Insert("rotateAmount" , buildAnimatedMap(rotate_amount1, rotate_amount2));
1495       propertyMap.Insert("offset"       , buildAnimatedMap(offset1       , offset2       ));
1496
1497       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1498       DALI_TEST_CHECK( animatedGradientVisual );
1499
1500       Property::Map resultMap;
1501       animatedGradientVisual.CreatePropertyMap( resultMap );
1502
1503       // check the property values from the returned map from visual
1504       // Note : resultMap from CreatePropertyMap only contain indexKey
1505       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1506       DALI_TEST_CHECK( value );
1507       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1508
1509       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1510       DALI_TEST_CHECK( value );
1511       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1512
1513       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1514       DALI_TEST_CHECK( value );
1515       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1516
1517       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1518       DALI_TEST_CHECK( value );
1519       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1520
1521       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
1522       {
1523         tet_printf("Check value at %d\n", line_num);
1524         value = resultMap.Find( index, Property::MAP );
1525         DALI_TEST_CHECK( value );
1526         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1527         Property::Map *temp_map = value->GetMap();
1528         DALI_TEST_CHECK( temp_map );
1529
1530         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1531         {
1532           Property::Value *res = temp_map->Find( index );
1533           DALI_TEST_CHECK( res );
1534           return *res;
1535         };
1536
1537         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1538         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1539         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1540         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1541         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1542         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1543         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1544         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1545         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1546       };
1547
1548       // check the animation map data is good
1549       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1550       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1551       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1552       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1553       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1554       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1555       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1556     }
1557   }
1558
1559   END_TEST;
1560 }
1561 int UtcDaliVisualGetPropertyMap13(void)
1562 {
1563   ToolkitTestApplication application;
1564   tet_infoline( "UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0" );
1565
1566   for(int _direction = 0; _direction <= 1; ++_direction)
1567   {
1568     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1569     {
1570       tet_printf( ((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n") , _delay );
1571       VisualFactory factory = VisualFactory::Get();
1572       DALI_TEST_CHECK( factory );
1573
1574       Property::Map propertyMap;
1575       Property::Map animationMap;
1576       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1577
1578       float duration = 1.0f;
1579       float delay = _delay;
1580       float repeat_delay = 0.5f;
1581
1582       int direction = _direction;
1583       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1584       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1585       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1586
1587       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1588       {
1589         animationMap.Clear();
1590         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1591         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1592         if(direction == 0)animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1593         else animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1594         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1595         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1596         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1597         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1598         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1599         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1600         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1601
1602         return animationMap;
1603       };
1604
1605       Vector2 start1(-0.5f, 0.5f);
1606       Vector2 end1  (0.5f, -0.5f);
1607       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1608       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1609       Vector2 rotate_center1(1.0f, 0.4f);
1610       float rotate_amount1 = 2.0f;
1611       float offset1 = 1.f;
1612
1613       Vector2 start2(-0.5f, -0.5f);
1614       Vector2 end2  (0.5f, 0.5f);
1615       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1616       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1617       Vector2 rotate_center2(1.0f, -0.4f);
1618       float rotate_amount2 = 1.0f;
1619       float offset2 = 3.f;
1620
1621       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1622       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1623       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REFLECT);
1624
1625       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1626       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1627       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1628       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1629       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1630       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1631       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1632
1633       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1634       DALI_TEST_CHECK( animatedGradientVisual );
1635
1636       Property::Map resultMap;
1637       animatedGradientVisual.CreatePropertyMap( resultMap );
1638
1639       // check the property values from the returned map from visual
1640       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1641       DALI_TEST_CHECK( value );
1642       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1643
1644       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1645       DALI_TEST_CHECK( value );
1646       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1647
1648       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1649       DALI_TEST_CHECK( value );
1650       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1651
1652       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1653       DALI_TEST_CHECK( value );
1654       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1655
1656       // If loop_count = 0, Animation doesn't created.
1657       // Optimized resultMap only have one value, which is target value
1658       // Note: target value will be changed by direction option.
1659       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1660       DALI_TEST_CHECK( value );
1661       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? start1 : start2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1662
1663       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1664       DALI_TEST_CHECK( value );
1665       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? end1 : end2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1666
1667       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1668       DALI_TEST_CHECK( value );
1669       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? start_color1 : start_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1670
1671       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1672       DALI_TEST_CHECK( value );
1673       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? end_color1 : end_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1674
1675       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1676       DALI_TEST_CHECK( value );
1677       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1678
1679       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1680       DALI_TEST_CHECK( value );
1681       DALI_TEST_EQUALS( value->Get<float>(), direction ? rotate_amount1 : rotate_amount2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1682
1683       value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1684       DALI_TEST_CHECK( value );
1685       DALI_TEST_EQUALS( value->Get<float>(), direction ? offset1 : offset2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1686     }
1687   }
1688
1689   END_TEST;
1690 }
1691
1692 int UtcDaliVisualAnimateBorderVisual01(void)
1693 {
1694   ToolkitTestApplication application;
1695   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1696
1697   VisualFactory factory = VisualFactory::Get();
1698   Property::Map propertyMap;
1699   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1700   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1701   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1702   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1703   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1704
1705   Property::Map map;
1706   map["target"] = "testVisual";
1707   map["property"] = "mixColor";
1708   map["targetValue"] = Vector4(1,1,1,0);
1709   map["animator"] = Property::Map()
1710     .Add("alphaFunction", "LINEAR")
1711     .Add("timePeriod", Property::Map()
1712          .Add("delay", 0.0f)
1713          .Add("duration", 4.0f));
1714
1715   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1716
1717   DummyControl actor = DummyControl::New(true);
1718   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1719   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1720   actor.SetSize(2000, 2000);
1721   actor.SetParentOrigin(ParentOrigin::CENTER);
1722   Stage::GetCurrent().Add(actor);
1723
1724   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1725
1726   Renderer renderer = actor.GetRendererAt(0);
1727   Property::Index borderColorIndex = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::COLOR );
1728   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, Visual::Property::MIX_COLOR );
1729
1730   Animation animation = dummyImpl.CreateTransition( transition );
1731
1732   // Animate the mix color through the transition, and the border color through
1733   // programmatic method.
1734   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1735   animation.Play();
1736
1737   application.SendNotification();
1738   application.Render(0);
1739   application.Render(2000u); // halfway point between blue and white
1740
1741   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1742   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1743   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1744   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1745
1746   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1747   testColor = Vector4( 1,1,1,0.4f );
1748   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1749   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1750   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ) , true, TEST_LOCATION );
1751
1752   application.Render(2000u);
1753
1754   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1755   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1756   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1757
1758   color = renderer.GetCurrentProperty< Vector4 >( mixColorIndex );
1759   testColor = Vector4(1,1,1,0);
1760   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1761   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1762   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ), true, TEST_LOCATION );
1763
1764   END_TEST;
1765 }
1766
1767
1768 int UtcDaliVisualAnimateBorderVisual02(void)
1769 {
1770   ToolkitTestApplication application;
1771   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1772
1773   VisualFactory factory = VisualFactory::Get();
1774   Property::Map propertyMap;
1775   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1776   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1777   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1778   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1779
1780   DummyControl actor = DummyControl::New(true);
1781   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1782   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1783   actor.SetSize(2000, 2000);
1784   actor.SetParentOrigin(ParentOrigin::CENTER);
1785   Stage::GetCurrent().Add(actor);
1786
1787   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1788
1789   Renderer renderer = actor.GetRendererAt(0);
1790   Property::Index index = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::SIZE );
1791
1792   Animation animation = Animation::New(4.0f);
1793   animation.AnimateTo( Property(renderer, index), 9.0f );
1794   animation.Play();
1795
1796   application.SendNotification();
1797   application.Render(0);
1798   application.Render(2000u); // halfway point
1799
1800   float size = renderer.GetCurrentProperty< float >( index );
1801   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1802   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1803
1804   application.Render(2000u); // halfway point between blue and white
1805
1806   size = renderer.GetCurrentProperty< float >( index );
1807   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1808   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1809
1810   END_TEST;
1811 }
1812
1813 int UtcDaliVisualAnimateColorVisual(void)
1814 {
1815   ToolkitTestApplication application;
1816   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1817
1818   VisualFactory factory = VisualFactory::Get();
1819   Property::Map propertyMap;
1820   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1821   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1822   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1823
1824   DummyControl actor = DummyControl::New(true);
1825   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1826   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1827   actor.SetSize(2000, 2000);
1828   actor.SetParentOrigin(ParentOrigin::CENTER);
1829   Stage::GetCurrent().Add(actor);
1830
1831   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1832
1833   Renderer renderer = actor.GetRendererAt(0);
1834   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
1835
1836   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1837   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1838
1839   Animation animation = Animation::New(4.0f);
1840   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1841   animation.Play();
1842
1843   application.SendNotification();
1844   application.Render(0);
1845   application.Render(2000u); // halfway point
1846
1847   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1848   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1849   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1850
1851   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1852
1853   application.Render(2000u); // halfway point between blue and white
1854
1855   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1856   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1857
1858   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1859
1860   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1861   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1862
1863   END_TEST;
1864 }
1865
1866 int UtcDaliVisualAnimatePrimitiveVisual(void)
1867 {
1868   ToolkitTestApplication application;
1869   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1870
1871   {
1872     VisualFactory factory = VisualFactory::Get();
1873     Property::Map propertyMap;
1874     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1875     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1876     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1877     Visual::Base visual = factory.CreateVisual( propertyMap );
1878
1879     DummyControl actor = DummyControl::New(true);
1880     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1881     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1882     actor.SetSize(2000, 2000);
1883     actor.SetParentOrigin(ParentOrigin::CENTER);
1884     actor.SetColor(Color::BLACK);
1885     Stage::GetCurrent().Add(actor);
1886
1887     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1888
1889     Renderer renderer = actor.GetRendererAt(0);
1890     Property::Index index = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
1891
1892     tet_infoline("Test that the renderer has the Primitive mix color");
1893     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1894
1895     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1896     const Vector4 TARGET_MIX_COLOR( Color::RED );
1897
1898     Property::Map map;
1899     map["target"] = "testVisual";
1900     map["property"] = "mixColor";
1901     map["initialValue"] = INITIAL_MIX_COLOR;
1902     map["targetValue"] = TARGET_MIX_COLOR;
1903     map["animator"] = Property::Map()
1904       .Add("alphaFunction", "LINEAR")
1905       .Add("timePeriod", Property::Map()
1906            .Add("delay", 0.0f)
1907            .Add("duration", 4.0f));
1908
1909     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1910
1911     Animation animation = dummyImpl.CreateTransition( transition );
1912     Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1913     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
1914
1915     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1916     animation.Play();
1917
1918     application.SendNotification();
1919     application.Render(0);
1920     application.Render(2000u); // halfway point
1921     application.SendNotification();
1922
1923     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
1924
1925     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1926     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1927     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", halfwayColor.a ), true, TEST_LOCATION );
1928
1929     application.Render(2001u); // go past end
1930     application.SendNotification(); // Trigger signals
1931
1932     DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1933     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
1934     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1935     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a ), true, TEST_LOCATION );
1936
1937     blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1938     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1939
1940     actor.Unparent();
1941   }
1942
1943   END_TEST;
1944 }
1945
1946 int UtcDaliVisualAnimatedGradientVisual01(void)
1947 {
1948   ToolkitTestApplication application;
1949   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
1950
1951   {
1952     VisualFactory factory = VisualFactory::Get();
1953     Property::Map propertyMap;
1954     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1955     Visual::Base visual = factory.CreateVisual( propertyMap );
1956
1957     DummyControl actor = DummyControl::New(true);
1958     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1959     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1960     actor.SetSize(2000, 2000);
1961     actor.SetParentOrigin(ParentOrigin::CENTER);
1962     actor.SetColor(Color::BLACK);
1963     Stage::GetCurrent().Add(actor);
1964
1965     application.SendNotification();
1966     application.Render(0);
1967     application.SendNotification();
1968
1969     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1970
1971     for(int step_iter = 0; step_iter < 3; step_iter++)
1972     {
1973       application.SendNotification();
1974       application.Render(0);
1975       application.Render(750u); // step i/4
1976       application.SendNotification();
1977
1978       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
1979       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
1980       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1981       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1982       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
1983       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
1984       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
1985     }
1986
1987     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
1988     application.Render(750u); // go to end
1989     application.SendNotification();
1990
1991     application.Render(10u); // finish
1992     application.SendNotification();
1993
1994     actor.Unparent();
1995     application.SendNotification();
1996     application.Render(0u);
1997     application.SendNotification();
1998   }
1999
2000   END_TEST;
2001 }
2002
2003 int UtcDaliVisualAnimatedGradientVisual02(void)
2004 {
2005   ToolkitTestApplication application;
2006   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
2007
2008   {
2009     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
2010     int _direction[2] = {0, 1};
2011     int _loop_count[3] = {-1, 0, 1};
2012     int _motion[2] = {0, 1};
2013     int _easing[4] = {0, 1, 2, 3};
2014
2015     int test_case_max = 4 * 2 * 3 * 2 * 4;
2016     int test_case = 0;
2017     int test_case_d = 7; // 7 is the number of animated properties.
2018
2019     float _duration = 0.4f;
2020     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2021     float noise_maker = 0.0f;
2022     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2023     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2024     {
2025       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2026
2027       VisualFactory factory = VisualFactory::Get();
2028       Property::Map propertyMap;
2029       Property::Map animationMap;
2030       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2031
2032       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2033       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2034       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2035
2036       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&
2037       {
2038         int tc = (test_case + tc_offset);
2039         int idx_easing = tc % 4; tc /= 4;
2040         int idx_motion = tc % 2; tc /= 2;
2041         int idx_loop_count = tc % 3; tc /= 3;
2042         int idx_direction = tc % 2; tc /= 2;
2043         int idx_delay = tc % 4; tc /= 4;
2044
2045         float duration = _duration - _repeat_delay;
2046         float repeat_delay = _repeat_delay;
2047         float delay = _delay[idx_delay] * _duration;
2048         int direction = _direction[idx_direction];
2049         int loop_count = _loop_count[idx_loop_count];
2050         int motion = _motion[idx_motion];
2051         int easing = _easing[idx_easing];
2052
2053         animationMap.Clear();
2054         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
2055         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
2056         if( direction == 0 )
2057         {
2058           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2059         }
2060         else
2061         {
2062           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2063         }
2064         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2065         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2066         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2067         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2068         if( motion == 0 )
2069         {
2070           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2071         }
2072         else
2073         {
2074           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2075         }
2076         if( easing == 0 )
2077         {
2078           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2079         }
2080         else if( easing == 1 )
2081         {
2082           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2083         }
2084         else if( easing == 2 )
2085         {
2086           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2087         }
2088         else
2089         {
2090           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2091         }
2092
2093         return animationMap;
2094       };
2095
2096       // Give different values for debuging
2097       noise_maker += 1.0f;
2098       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2099       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2100       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2101       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2102       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2103       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2104       float offset1 = 0.f + noise_maker * 0.1f;
2105
2106       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2107       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2108       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2109       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2110       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2111       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2112       float offset2 = 2.f + noise_maker * 0.1f;
2113
2114       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2115       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2116       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2117
2118       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2119       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2120       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2121       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2122       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2123       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2124       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2125
2126       Visual::Base visual = factory.CreateVisual( propertyMap );
2127
2128       DummyControl actor = DummyControl::New( true );
2129       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2130       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2131       actor.SetSize( 2000, 2000 );
2132       actor.SetParentOrigin(ParentOrigin::CENTER);
2133       actor.SetColor(Color::BLACK);
2134       Stage::GetCurrent().Add(actor);
2135
2136       application.SendNotification();
2137       application.Render( 0 );
2138       application.SendNotification();
2139
2140       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2141
2142       application.SendNotification();
2143
2144       //Compare between CPU calculated value and Shader Visual calculated value
2145       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
2146       {
2147         int tc = (test_case + tc_offset);
2148         int idx_easing = tc % 4; tc /= 4;
2149         int idx_motion = tc % 2; tc /= 2;
2150         int idx_loop_count = tc % 3; tc /= 3;
2151         int idx_direction = tc % 2; tc /= 2;
2152         int idx_delay = tc % 4; tc /= 4;
2153
2154         float duration = _duration - _repeat_delay;
2155         float repeat_delay = _repeat_delay;
2156         float delay = _delay[idx_delay] * _duration;
2157         int direction = _direction[idx_direction];
2158         int loop_count = _loop_count[idx_loop_count];
2159         int motion = _motion[idx_motion];
2160         int easing = _easing[idx_easing];
2161
2162         progress -= delay / _duration;
2163
2164         Property::Value s = start;
2165         Property::Value t = target;
2166         if( direction == 1 )
2167         {
2168           s = target;
2169           t = start;
2170         }
2171         float x; ///< Animator progress value
2172         if( loop_count == 0 )
2173         {
2174           x = 1.0f;
2175         }
2176         else if( loop_count > 0 && progress + 0.01f > loop_count )
2177         {
2178           x = ( motion == 0 ) ? 1.0f : 0.0f;
2179         }
2180         else
2181         {
2182           if( progress < 0.0f )
2183           {
2184             progress = 0.0f;
2185           }
2186           progress = fmodf( progress, 1.0f );
2187           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2188
2189           x = progress;
2190           if( motion == 1 )
2191           {
2192             x = progress * 2.0f;
2193             if( x > 1.0f )
2194             {
2195               x = 2.0f - x;
2196             }
2197           }
2198
2199           if( easing == 1 ) // EASE_IN
2200           {
2201             x = x*x;
2202           }
2203           else if( easing == 2 ) // EASE_OUT
2204           {
2205             x = 2.0f*x - x*x;
2206           }
2207           else if( easing == 3 ) // EASE_IN_OUT
2208           {
2209             x = x * x * (3.0f - 2.0f * x);
2210           }
2211         }
2212         if( value_type == 0 ) // result type is Float
2213         {
2214           float res;
2215           float cur;
2216           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2217           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2218           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2219         }
2220         else if( value_type == 1 ) // result type is Vector2
2221         {
2222           Vector2 res;
2223           Vector2 cur;
2224           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2225           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2226           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2227         }
2228         else if( value_type == 2 ) // result type is Vector3
2229         {
2230           Vector3 res;
2231           Vector3 cur;
2232           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2233           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2234           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2235         }
2236         else // result type is Vector4
2237         {
2238           Vector4 res;
2239           Vector4 cur;
2240           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2241           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2242           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2243         }
2244       };
2245
2246       float step = 0.0f;
2247       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2248       {
2249         for( int step_iter = 0; step_iter < 3; step_iter++ )
2250         {
2251           application.SendNotification();
2252           application.Render( _duration * 250.f );  // step i/4
2253           application.SendNotification();
2254           step += 0.25f;
2255
2256           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2257           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2258           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2259           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2260           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2261           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2262           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2263         }
2264         application.SendNotification();
2265         application.Render(_duration * 250.f);  // step 4/4 will not test
2266         application.SendNotification();
2267         step += 0.25f;
2268       }
2269
2270       application.SendNotification();
2271       actor.Unparent();
2272       application.SendNotification();
2273       application.Render(10.f);  // tempral time
2274       application.SendNotification();
2275     }
2276   }
2277
2278   END_TEST;
2279 }
2280
2281 int UtcDaliVisualAnimatedGradientVisual03(void)
2282 {
2283   ToolkitTestApplication application;
2284   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2285
2286   {
2287     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
2288     int _direction[2] = {0, 1};
2289     int _loop_count[3] = {-1, 0, 1};
2290     int _motion[2] = {0, 1};
2291     int _easing[4] = {0, 1, 2, 3};
2292
2293     int test_case_max = 4 * 2 * 3 * 2 * 4;
2294     int test_case = 0;
2295     int test_case_d = 7; // 7 is the number of animated properties.
2296
2297     float _duration = 0.4f;
2298     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2299     float noise_maker = 0.2f;
2300     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2301     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2302     {
2303       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2304
2305       VisualFactory factory = VisualFactory::Get();
2306       Property::Map propertyMap;
2307       Property::Map animationMap;
2308       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2309
2310       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&
2311       {
2312         int tc = (test_case + tc_offset);
2313         int idx_easing = tc % 4; tc /= 4;
2314         int idx_motion = tc % 2; tc /= 2;
2315         int idx_loop_count = tc % 3; tc /= 3;
2316         int idx_direction = tc % 2; tc /= 2;
2317         int idx_delay = tc % 4; tc /= 4;
2318
2319         float duration = _duration - _repeat_delay;
2320         float repeat_delay = _repeat_delay;
2321         float delay = _delay[idx_delay] * _duration;
2322         int direction = _direction[idx_direction];
2323         int loop_count = _loop_count[idx_loop_count];
2324         int motion = _motion[idx_motion];
2325         int easing = _easing[idx_easing];
2326
2327         animationMap.Clear();
2328         animationMap.Insert( "startValue", start );
2329         animationMap.Insert( "targetValue", target );
2330         if( direction == 0 )
2331         {
2332           animationMap.Insert("directionType", "FORWARD");
2333         }
2334         else
2335         {
2336           animationMap.Insert("directionType", "BACKWARD");
2337         }
2338         animationMap.Insert("duration", duration);
2339         animationMap.Insert("delay", delay);
2340         animationMap.Insert("repeat", loop_count);
2341         animationMap.Insert("repeatDelay", repeat_delay);
2342         if( motion == 0 )
2343         {
2344           animationMap.Insert("motionType", "LOOP");
2345         }
2346         else
2347         {
2348           animationMap.Insert("motionType", "MIRROR");
2349         }
2350         if( easing == 0 )
2351         {
2352           animationMap.Insert("easingType", "LINEAR");
2353         }
2354         else if( easing == 1 )
2355         {
2356           animationMap.Insert("easingType", "IN");
2357         }
2358         else if( easing == 2 )
2359         {
2360           animationMap.Insert("easingType", "OUT");
2361         }
2362         else
2363         {
2364           animationMap.Insert("easingType", "IN_OUT");
2365         }
2366
2367         return animationMap;
2368       };
2369
2370       // Give different values for debuging
2371       noise_maker += 0.8f;
2372       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2373       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2374       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2375       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2376       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2377       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2378       float offset1 = 0.f + noise_maker * 0.1f;
2379
2380       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2381       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2382       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2383       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2384       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2385       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2386       float offset2 = 2.f + noise_maker * 0.1f;
2387
2388       propertyMap.Insert("gradientType", "LINEAR");
2389       propertyMap.Insert("unitType",     "USER_SPACE");
2390       propertyMap.Insert("spreadType",   "CLAMP");
2391
2392       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2393       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2394       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2395       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2396       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2397       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2398       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2399
2400       Visual::Base visual = factory.CreateVisual( propertyMap );
2401
2402       DummyControl actor = DummyControl::New( true );
2403       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2404       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2405       actor.SetSize( 2000, 2000 );
2406       actor.SetParentOrigin(ParentOrigin::CENTER);
2407       actor.SetColor(Color::BLACK);
2408       Stage::GetCurrent().Add(actor);
2409
2410       application.SendNotification();
2411       application.Render( 0 );
2412       application.SendNotification();
2413
2414       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2415
2416       application.SendNotification();
2417
2418       //Compare between CPU calculated value and Shader Visual calculated value
2419       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
2420       {
2421         int tc = (test_case + tc_offset);
2422         int idx_easing = tc % 4; tc /= 4;
2423         int idx_motion = tc % 2; tc /= 2;
2424         int idx_loop_count = tc % 3; tc /= 3;
2425         int idx_direction = tc % 2; tc /= 2;
2426         int idx_delay = tc % 4; tc /= 4;
2427
2428         float duration = _duration - _repeat_delay;
2429         float repeat_delay = _repeat_delay;
2430         float delay = _delay[idx_delay] * _duration;
2431         int direction = _direction[idx_direction];
2432         int loop_count = _loop_count[idx_loop_count];
2433         int motion = _motion[idx_motion];
2434         int easing = _easing[idx_easing];
2435
2436         progress -= delay / _duration;
2437
2438         Property::Value s = start;
2439         Property::Value t = target;
2440         if( direction == 1 )
2441         {
2442           s = target;
2443           t = start;
2444         }
2445         float x; ///< Animator progress value
2446         if( loop_count == 0 )
2447         {
2448           x = 1.0f;
2449         }
2450         else if( loop_count > 0 && progress + 0.01f > loop_count )
2451         {
2452           x = ( motion == 0 ) ? 1.0f : 0.0f;
2453         }
2454         else
2455         {
2456           if( progress < 0.0f )
2457           {
2458             progress = 0.0f;
2459           }
2460           progress = fmodf( progress, 1.0f );
2461           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2462
2463           x = progress;
2464           if( motion == 1 )
2465           {
2466             x = progress * 2.0f;
2467             if( x > 1.0f )
2468             {
2469               x = 2.0f - x;
2470             }
2471           }
2472
2473           if( easing == 1 ) // EASE_IN
2474           {
2475             x = x*x;
2476           }
2477           else if( easing == 2 ) // EASE_OUT
2478           {
2479             x = 2.0f*x - x*x;
2480           }
2481           else if( easing == 3 ) // EASE_IN_OUT
2482           {
2483             x = x * x * (3.0f - 2.0f * x);
2484           }
2485         }
2486         if( value_type == 0 ) // result type is Float
2487         {
2488           float res;
2489           float cur;
2490           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2491           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2492           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2493         }
2494         else if( value_type == 1 ) // result type is Vector2
2495         {
2496           Vector2 res;
2497           Vector2 cur;
2498           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2499           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2500           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2501         }
2502         else if( value_type == 2 ) // result type is Vector3
2503         {
2504           Vector3 res;
2505           Vector3 cur;
2506           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2507           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2508           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2509         }
2510         else // result type is Vector4
2511         {
2512           Vector4 res;
2513           Vector4 cur;
2514           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2515           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2516           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2517         }
2518       };
2519
2520       float step = 0.0f;
2521       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2522       {
2523         for( int step_iter = 0; step_iter < 3; step_iter++ )
2524         {
2525           application.SendNotification();
2526           application.Render( _duration * 250.f );  // step i/4
2527           application.SendNotification();
2528           step += 0.25f;
2529
2530           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2531           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2532           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2533           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2534           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2535           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2536           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2537         }
2538         application.SendNotification();
2539         application.Render(_duration * 250.f);  // step 4/4 will not test
2540         application.SendNotification();
2541         step += 0.25f;
2542       }
2543
2544       application.SendNotification();
2545       actor.Unparent();
2546       application.SendNotification();
2547       application.Render(10.f);  // tempral time
2548       application.SendNotification();
2549     }
2550   }
2551
2552   END_TEST;
2553 }
2554
2555 int UtcDaliVisualWireframeVisual(void)
2556 {
2557   ToolkitTestApplication application;
2558
2559   VisualFactory factory = VisualFactory::Get();
2560   Property::Map propertyMap;
2561   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2562
2563   // Create the visual.
2564   Visual::Base visual = factory.CreateVisual( propertyMap );
2565
2566   DALI_TEST_CHECK( visual );
2567
2568   Property::Map resultMap;
2569   visual.CreatePropertyMap( resultMap );
2570
2571   // Check the property values from the returned map from visual
2572   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2573   DALI_TEST_CHECK( value );
2574   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2575
2576   END_TEST;
2577 }
2578
2579 int UtcDaliVisualGetTransform(void)
2580 {
2581   ToolkitTestApplication application;
2582   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2583
2584   VisualFactory factory = VisualFactory::Get();
2585   Property::Map propertyMap;
2586   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2587   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2588   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2589
2590   Dali::Property::Map visualMap;
2591   colorVisual.CreatePropertyMap( visualMap );
2592   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2593   Dali::Property::Map* map = value->GetMap();
2594   DALI_TEST_CHECK( map );
2595
2596   //Test default values
2597   {
2598     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2599     DALI_TEST_CHECK( typeValue );
2600     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2601   }
2602   {
2603     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2604     DALI_TEST_CHECK( typeValue );
2605     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2606   }
2607   {
2608     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2609     DALI_TEST_CHECK( typeValue );
2610     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2611   }
2612   {
2613     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2614     DALI_TEST_CHECK( typeValue );
2615     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2616   }
2617   {
2618     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2619     DALI_TEST_CHECK( typeValue );
2620     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2621   }
2622   {
2623     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2624     DALI_TEST_CHECK( typeValue );
2625     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2626   }
2627
2628   END_TEST;
2629 }
2630
2631 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2632 {
2633   Property::Map transform;
2634   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2635   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2636   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2637   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2638   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2639
2640   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2641
2642   Dali::Property::Map visualMap;
2643   visual.CreatePropertyMap( visualMap );
2644   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2645   Dali::Property::Map* map = value->GetMap();
2646   DALI_TEST_CHECK( map );
2647
2648   {
2649     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2650     DALI_TEST_CHECK( typeValue );
2651     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2652   }
2653   {
2654     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2655     DALI_TEST_CHECK( typeValue );
2656     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2657   }
2658   {
2659     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2660     DALI_TEST_CHECK( typeValue );
2661     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2662   }
2663   {
2664     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2665     DALI_TEST_CHECK( typeValue );
2666     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2667   }
2668   {
2669     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2670     DALI_TEST_CHECK( typeValue );
2671     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2672   }
2673   {
2674     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2675     DALI_TEST_CHECK( typeValue );
2676     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2677   }
2678
2679   //Put the visual on the stage
2680   DummyControl actor = DummyControl::New(true);
2681   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2682   actor.SetSize(2000, 2000);
2683   actor.SetParentOrigin(ParentOrigin::CENTER);
2684   Stage::GetCurrent().Add(actor);
2685
2686   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2687   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2688
2689   application.SendNotification();
2690   application.Render(0);
2691   Renderer renderer( actor.GetRendererAt(0) );
2692
2693   //Check that the properties have been registered on the Renderer
2694   Property::Index index = renderer.GetPropertyIndex( "offset" );
2695   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2696   Vector2 offset = renderer.GetProperty<Vector2>( index );
2697   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2698
2699   index = renderer.GetPropertyIndex( "size" );
2700   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2701   Vector2 size = renderer.GetProperty<Vector2>( index );
2702   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2703
2704   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2705   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2706   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2707   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2708
2709   index = renderer.GetPropertyIndex( "origin" );
2710   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2711   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2712   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2713
2714   index = renderer.GetPropertyIndex( "anchorPoint" );
2715   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2716   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2717   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2718
2719   //Set a new transform
2720   transform.Clear();
2721   transform = DefaultTransform();
2722   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2723   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2724   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2725   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2726   application.SendNotification();
2727   application.Render(0);
2728
2729   //Check that the values have changed in the renderer
2730   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2731   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2732
2733   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2734   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2735
2736   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2737   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2738
2739   //Parent origin and anchor point should have the default values
2740   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2741   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2742
2743   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2744   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2745 }
2746
2747 int UtcDaliVisualSetTransform0(void)
2748 {
2749   ToolkitTestApplication application;
2750   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2751
2752   VisualFactory factory = VisualFactory::Get();
2753   Property::Map propertyMap;
2754   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2755   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2756   Visual::Base visual = factory.CreateVisual( propertyMap );
2757   TestTransform( application, visual );
2758   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2759
2760   END_TEST;
2761 }
2762
2763 int UtcDaliVisualSetTransform1(void)
2764 {
2765   ToolkitTestApplication application;
2766   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2767
2768   VisualFactory factory = VisualFactory::Get();
2769   Property::Map propertyMap;
2770   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2771   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2772   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2773   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2774   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
2775   Visual::Base visual = factory.CreateVisual( propertyMap );
2776   TestTransform( application, visual );
2777   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
2778
2779   END_TEST;
2780 }
2781
2782 int UtcDaliVisualSetTransform2(void)
2783 {
2784   ToolkitTestApplication application;
2785   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
2786
2787   VisualFactory factory = VisualFactory::Get();
2788   Property::Map propertyMap;
2789   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
2790   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
2791
2792   Property::Array stopOffsets;
2793   stopOffsets.PushBack( 0.0f );
2794   stopOffsets.PushBack( 0.3f );
2795   stopOffsets.PushBack( 0.6f );
2796   stopOffsets.PushBack( 0.8f );
2797   stopOffsets.PushBack( 1.0f );
2798   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
2799
2800   Property::Array stopColors;
2801   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
2802   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
2803   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
2804   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
2805   stopColors.PushBack( Color::YELLOW );
2806   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
2807   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
2808   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
2809   Visual::Base visual = factory.CreateVisual( propertyMap );
2810   TestTransform( application, visual );
2811   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
2812
2813   END_TEST;
2814 }
2815
2816 int UtcDaliVisualSetTransform3(void)
2817 {
2818   ToolkitTestApplication application;
2819   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
2820
2821   VisualFactory factory = VisualFactory::Get();
2822   Property::Map propertyMap;
2823   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
2824   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
2825   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
2826   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
2827   Visual::Base visual = factory.CreateVisual( propertyMap );
2828   TestTransform( application, visual );
2829   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
2830
2831   END_TEST;
2832 }
2833
2834 int UtcDaliVisualSetTransform4(void)
2835 {
2836   ToolkitTestApplication application;
2837   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
2838
2839   VisualFactory factory = VisualFactory::Get();
2840   Property::Map propertyMap;
2841   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
2842   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
2843
2844   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
2845   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
2846   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
2847   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
2848   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
2849   Visual::Base visual = factory.CreateVisual( propertyMap );
2850   TestTransform( application, visual );
2851   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
2852
2853   END_TEST;
2854 }
2855
2856 int UtcDaliVisualSetTransform5(void)
2857 {
2858   ToolkitTestApplication application;
2859   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
2860
2861   VisualFactory factory = VisualFactory::Get();
2862   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
2863   Visual::Base visual = factory.CreateVisual(image);
2864   TestTransform( application, visual );
2865   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2866
2867   END_TEST;
2868 }
2869
2870 int UtcDaliVisualSetTransform6(void)
2871 {
2872   ToolkitTestApplication application;
2873   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
2874
2875   VisualFactory factory = VisualFactory::Get();
2876   Property::Map propertyMap;
2877   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
2878   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
2879   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2880   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
2881   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
2882   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
2883   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
2884   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
2885   Visual::Base visual = factory.CreateVisual(propertyMap);
2886   TestTransform( application, visual );
2887   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
2888
2889   END_TEST;
2890 }
2891
2892 int UtcDaliVisualSetTransform7(void)
2893 {
2894   ToolkitTestApplication application;
2895   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
2896
2897   VisualFactory factory = VisualFactory::Get();
2898   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
2899   Visual::Base visual = factory.CreateVisual(image);
2900   TestTransform( application, visual );
2901   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2902
2903   END_TEST;
2904 }
2905
2906 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
2907 {
2908   ToolkitTestApplication application;
2909   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
2910
2911   VisualFactory factory = VisualFactory::Get();
2912   Property::Map propertyMap;
2913   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2914   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2915   Visual::Base visual = factory.CreateVisual( propertyMap );
2916
2917   Property::Map transform;
2918   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
2919                                                  .Add( "RELATIVE" );
2920   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
2921                                                  .Add( "ABSOLUTE" );
2922   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2923
2924   Dali::Property::Map visualMap;
2925   visual.CreatePropertyMap( visualMap );
2926   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2927   Dali::Property::Map* map = value->GetMap();
2928   DALI_TEST_CHECK( map );
2929
2930   {
2931     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2932     DALI_TEST_CHECK( typeValue );
2933     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2934   }
2935   {
2936     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2937     DALI_TEST_CHECK( typeValue );
2938     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2939   }
2940
2941   END_TEST;
2942 }
2943
2944 int UtcDaliNPatchVisualCustomShader(void)
2945 {
2946   ToolkitTestApplication application;
2947   tet_infoline( "NPatchVisual with custom shader" );
2948
2949   VisualFactory factory = VisualFactory::Get();
2950   Property::Map properties;
2951   Property::Map shader;
2952   const std::string vertexShader = "Foobar";
2953   const std::string fragmentShader = "Foobar";
2954   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2955   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
2956
2957   Property::Map transformMap;
2958   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
2959   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
2960   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
2961   transformMap["anchorPoint"] = Align::CENTER;
2962   transformMap["origin"] = Align::CENTER;
2963   properties[Visual::Property::TRANSFORM] = transformMap;
2964
2965   properties[Visual::Property::TYPE] = Visual::IMAGE;
2966   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
2967   properties[Visual::Property::SHADER]=shader;
2968   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
2969
2970   Visual::Base visual = factory.CreateVisual( properties );
2971   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
2972
2973   // trigger creation through setting on stage
2974   DummyControl dummy = DummyControl::New(true);
2975   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
2976   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2977   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
2978   dummy.SetSize(2000, 2000);
2979   dummy.SetParentOrigin(ParentOrigin::CENTER);
2980   Stage::GetCurrent().Add(dummy);
2981   application.SendNotification();
2982
2983   Renderer renderer = dummy.GetRendererAt( 0 );
2984   Shader shader2 = renderer.GetShader();
2985   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
2986   Property::Map* map = value.GetMap();
2987   DALI_TEST_CHECK( map );
2988
2989   Property::Index index = renderer.GetPropertyIndex("size");
2990   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
2991
2992   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
2993   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
2994
2995   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
2996   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
2997
2998   END_TEST;
2999 }
3000
3001 int UtcDaliGradientVisualBlendMode(void)
3002 {
3003   ToolkitTestApplication application;
3004   VisualFactory factory = VisualFactory::Get();
3005
3006   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3007       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3008                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3009                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3010                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3011                                                                                   .Add( Color::GREEN ) ) );
3012
3013   Visual::Base alphaGradientVisual = factory.CreateVisual(
3014       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3015                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3016                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3017                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3018                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
3019
3020   DummyControl control = DummyControl::New(true);
3021   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3022   Stage::GetCurrent().Add( control );
3023
3024   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
3025   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
3026   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
3027
3028   application.SendNotification();
3029   application.Render();
3030
3031   // 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
3032   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
3033   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
3034   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
3035
3036   END_TEST;
3037 }
3038
3039 int UtcDaliVisualRendererRemovalAndReAddition(void)
3040 {
3041   ToolkitTestApplication application;
3042   tet_infoline( "UtcDaliVisualRendererRemoval" );
3043
3044   VisualFactory factory = VisualFactory::Get();
3045   Property::Map propertyMap;
3046   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3047   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3048   Visual::Base visual = factory.CreateVisual( propertyMap );
3049
3050   visual.SetDepthIndex( 1 );
3051
3052   DummyControl dummyControl = DummyControl::New(true);
3053   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3054   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3055   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3056
3057   dummyControl.SetSize(200.f, 200.f);
3058   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
3059
3060   Stage::GetCurrent().Add( dummyControl );
3061
3062   application.SendNotification();
3063   application.Render();
3064
3065   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3066
3067   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
3068   Stage::GetCurrent().Remove( dummyControl );
3069   application.SendNotification();
3070   application.Render();
3071
3072   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3073
3074   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
3075
3076   Stage::GetCurrent().Add( dummyControl );
3077
3078   application.SendNotification();
3079   application.Render();
3080
3081   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3082
3083   END_TEST;
3084 }
3085
3086
3087
3088 int UtcDaliVisualTextVisualRender(void)
3089 {
3090   ToolkitTestApplication application;
3091   tet_infoline( "UtcDaliVisualTextVisualRender" );
3092
3093   VisualFactory factory = VisualFactory::Get();
3094   Property::Map propertyMap;
3095   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3096   propertyMap.Insert( "mixColor", Color::WHITE );
3097   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3098   propertyMap.Insert( "enableMarkup", false );
3099   propertyMap.Insert( "text", "Hello world" );
3100   propertyMap.Insert( "fontFamily", "TizenSans" );
3101
3102   Property::Map fontStyleMapSet;
3103   fontStyleMapSet.Insert( "weight", "bold" );
3104   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3105
3106   propertyMap.Insert( "pointSize", 12.f );
3107   propertyMap.Insert( "multiLine", true );
3108   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3109   propertyMap.Insert( "verticalAlignment", "CENTER" );
3110   propertyMap.Insert( "textColor", Color::RED );
3111   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3112   textVisual.SetDepthIndex( 1 );
3113
3114   DummyControl dummyControl = DummyControl::New(true);
3115   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3116   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3117   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3118
3119   dummyControl.SetSize(200.f, 200.f);
3120   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3121
3122   Stage::GetCurrent().Add( dummyControl );
3123   application.SendNotification();
3124   application.Render();
3125
3126
3127   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3128   propertyMap.Clear();
3129   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3130   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3131   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3132   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3133
3134   Property::Map transformMap;
3135   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3136   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3137
3138   textVisual = factory.CreateVisual( propertyMap );
3139   textVisual.SetDepthIndex( 1 );
3140
3141   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3142   dummyControl.SetSize( 720.f, 640.f );
3143
3144   application.SendNotification(); // force process events to ensure text visual
3145   // adds renderer to the dummy control in OnRelayout
3146   application.Render();
3147
3148   Renderer renderer = dummyControl.GetRendererAt(0u);
3149   Property::Index index = renderer.GetPropertyIndex("size");
3150
3151   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3152   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3153
3154   END_TEST;
3155 }
3156
3157 int UtcDaliVisualTextVisualDisableEnable(void)
3158 {
3159   ToolkitTestApplication application;
3160   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3161
3162   VisualFactory factory = VisualFactory::Get();
3163   Property::Map propertyMap;
3164   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3165   propertyMap.Insert( "mixColor", Color::WHITE );
3166   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3167   propertyMap.Insert( "enableMarkup", false );
3168   propertyMap.Insert( "text", "Hello world" );
3169   propertyMap.Insert( "fontFamily", "TizenSans" );
3170
3171   Property::Map fontStyleMapSet;
3172   fontStyleMapSet.Insert( "weight", "bold" );
3173   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3174
3175   propertyMap.Insert( "pointSize", 12.f );
3176   propertyMap.Insert( "multiLine", true );
3177   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3178   propertyMap.Insert( "verticalAlignment", "CENTER" );
3179   propertyMap.Insert( "textColor", Color::RED );
3180   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3181   textVisual.SetDepthIndex( 1 );
3182
3183   DummyControl dummyControl = DummyControl::New(true);
3184   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3185   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3186   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3187
3188   dummyControl.SetSize(200.f, 200.f);
3189   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3190
3191   Stage::GetCurrent().Add( dummyControl );
3192   application.SendNotification();
3193   application.Render();
3194
3195   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3196
3197   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3198
3199   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3200
3201   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3202
3203   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3204
3205   END_TEST;
3206 }
3207
3208 int UtcDaliVisualPremultipliedAlpha(void)
3209 {
3210   ToolkitTestApplication application;
3211   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3212
3213   VisualFactory factory = VisualFactory::Get();
3214
3215   // image visual, test default value ( false )
3216   {
3217     Visual::Base imageVisual = factory.CreateVisual(
3218           Property::Map()
3219           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3220           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3221
3222     Dali::Property::Map visualMap;
3223     imageVisual.CreatePropertyMap( visualMap );
3224     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3225
3226     // test values
3227     DALI_TEST_CHECK( value );
3228     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
3229   }
3230
3231   // image visual, override premultiplied
3232   {
3233     Visual::Base imageVisual = factory.CreateVisual(
3234           Property::Map()
3235           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3236           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3237           .Add( Visual::Property::PREMULTIPLIED_ALPHA, true ) );
3238
3239     Dali::Property::Map visualMap;
3240     imageVisual.CreatePropertyMap( visualMap );
3241     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3242
3243     // test values
3244     DALI_TEST_CHECK( value );
3245     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
3246   }
3247
3248   // svg visual ( premultiplied alpha by default is true )
3249   {
3250     Visual::Base imageVisual = factory.CreateVisual(
3251           Property::Map()
3252           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3253           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3254
3255     Dali::Property::Map visualMap;
3256     imageVisual.CreatePropertyMap( visualMap );
3257     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3258
3259     // test values
3260     DALI_TEST_CHECK( value );
3261     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3262   }
3263
3264   END_TEST;
3265 }
3266
3267 int UtcDaliRegisterVisualOrder(void)
3268 {
3269   ToolkitTestApplication application;
3270   tet_infoline( "Register Visual Order" );
3271
3272   DummyControl dummyControl = DummyControl::New(true);
3273   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3274
3275   VisualFactory factory = VisualFactory::Get();
3276   Property::Map propertyMap;
3277   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3278   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3279
3280   tet_infoline( "Register visual, should have depth index of 0.0f" );
3281   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3282   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3283   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3284
3285   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3286
3287   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3288   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3289   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3290
3291   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3292   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3293   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3294
3295   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3296   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3297   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3298
3299   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3300   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3301   labelVisual.SetDepthIndex( -2000 );
3302   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3303   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3304
3305   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3306   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3307   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3308   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3309   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3310   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3311
3312   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3313   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3314   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3315   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3316   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3317
3318   dummyControl.SetSize(200.f, 200.f);
3319   Stage::GetCurrent().Add( dummyControl );
3320
3321   END_TEST;
3322 }
3323
3324 int UtcDaliRegisterVisualOrder02(void)
3325 {
3326   ToolkitTestApplication application;
3327   tet_infoline( "Register Visual Order with Background Set" );
3328
3329   DummyControl dummyControl = DummyControl::New(true);
3330   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3331
3332   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3333
3334   VisualFactory factory = VisualFactory::Get();
3335   Property::Map propertyMap;
3336   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3337   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3338
3339   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3340
3341   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3342
3343   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3344   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3345   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3346   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3347   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3348
3349   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3350   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3351   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3352   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3353
3354   dummyControl.SetSize(200.f, 200.f);
3355   Stage::GetCurrent().Add( dummyControl );
3356
3357   END_TEST;
3358 }
3359
3360 int UtcDaliRegisterVisualWithDepthIndex(void)
3361 {
3362   ToolkitTestApplication application;
3363   tet_infoline( "Register a Visual With Depth Index" );
3364
3365   DummyControl dummyControl = DummyControl::New(true);
3366   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3367
3368   VisualFactory factory = VisualFactory::Get();
3369   Property::Map propertyMap;
3370   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3371   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3372
3373   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3374   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3375   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3376   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3377   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3378
3379   tet_infoline( "Register another visual with a depth index and it disabled" );
3380   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3381   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3382   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3383   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3384
3385   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3386   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3387   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3388   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3389   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3390
3391   dummyControl.SetSize(200.f, 200.f);
3392   Stage::GetCurrent().Add( dummyControl );
3393
3394   END_TEST;
3395 }
3396
3397 int UtcDaliColorVisualRenderIfTransparentProperty(void)
3398 {
3399   ToolkitTestApplication application;
3400   tet_infoline( "Test the renderIfTransparent property of ColorVisual" );
3401
3402   VisualFactory factory = VisualFactory::Get();
3403   Property::Map propertyMap;
3404   propertyMap.Insert( Visual::Property::TYPE,  Visual::COLOR );
3405   propertyMap.Insert( ColorVisual::Property::MIX_COLOR, Color::BLUE );
3406
3407   tet_infoline( "Check default value" );
3408   {
3409     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3410     Property::Map returnedMap;
3411     testVisual.CreatePropertyMap( returnedMap );
3412
3413     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3414     DALI_TEST_CHECK( renderIfTransparentProperty );
3415     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3416   }
3417
3418   propertyMap.Insert( DevelColorVisual::Property::RENDER_IF_TRANSPARENT, true );
3419
3420   tet_infoline( "Ensure set to value required" );
3421   {
3422     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3423     Property::Map returnedMap;
3424     testVisual.CreatePropertyMap( returnedMap );
3425
3426     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3427     DALI_TEST_CHECK( renderIfTransparentProperty );
3428     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), true, TEST_LOCATION );
3429   }
3430
3431   propertyMap[ DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = Color::BLUE;
3432
3433   tet_infoline( "Ensure it returns default value if set to wrong type" );
3434   {
3435     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3436     Property::Map returnedMap;
3437     testVisual.CreatePropertyMap( returnedMap );
3438
3439     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3440     DALI_TEST_CHECK( renderIfTransparentProperty );
3441     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3442   }
3443
3444   END_TEST;
3445 }