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

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <iostream>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <toolkit-event-thread-callback.h>
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <dali/devel-api/actors/actor-devel.h>
  24 #include <dali/devel-api/object/handle-devel.h>
  25 #include <dali/devel-api/text-abstraction/font-client.h>
  26 #include <dali-toolkit/devel-api/controls/control-devel.h>
  27 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  28 #include <dali-toolkit/devel-api/text/rendering-backend.h>
  29 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  30 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  31 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  33 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  34 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
  35 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
  36 #include <dali-toolkit/dali-toolkit.h>
  37
  38 #include "dummy-control.h"
  39
  40 using namespace Dali;
  41 using namespace Dali::Toolkit;
  42
  43 namespace
  44 {
  45 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  46 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  47 const char* TEST_NPATCH_FILE_NAME =  TEST_RESOURCE_DIR "/button-up.9.png";
  48 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  49 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  50 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  51 const char* TEST_VECTOR_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/insta_camera.json";
  52 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
  53
  54
  55 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
  56
  57 Property::Map DefaultTransform()
  58 {
  59   Property::Map transformMap;
  60   transformMap
  61     .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  62     .Add( Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  63     .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
  64     .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN )
  65     .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) )
  66     .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
  67   return transformMap;
  68 }
  69
  70 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
  71 {
  72   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
  73   {
  74     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
  75     {
  76       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
  77
  78       Property::Value* valueSet = NULL;
  79       if ( valueGet.first.type == Property::Key::INDEX )
  80       {
  81         valueSet = fontStyleMapSet.Find( valueGet.first.indexKey );
  82       }
  83       else
  84       {
  85         // Get Key is a string so searching Set Map for a string key
  86         valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
  87       }
  88
  89       if( NULL != valueSet )
  90       {
  91         if( valueSet->GetType() == Dali::Property::STRING && ( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() ) )
  92         {
  93           tet_printf( "Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
  94           return false;
  95         }
  96         else if( valueSet->GetType() == Dali::Property::BOOLEAN && ( valueGet.second.Get<bool>() != valueSet->Get<bool>() ) )
  97         {
  98           tet_printf( "Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>() );
  99           return false;
 100         }
 101         else if( valueSet->GetType() == Dali::Property::INTEGER && ( valueGet.second.Get<int>() != valueSet->Get<int>() ) )
 102         {
 103           tet_printf( "Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>() );
 104           return false;
 105         }
 106         else if( valueSet->GetType() == Dali::Property::FLOAT && ( valueGet.second.Get<float>() != valueSet->Get<float>() ) )
 107         {
 108           tet_printf( "Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>() );
 109           return false;
 110         }
 111         else if( valueSet->GetType() == Dali::Property::VECTOR2 && ( valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>() ) )
 112         {
 113           Vector2 vector2Get = valueGet.second.Get<Vector2>();
 114           Vector2 vector2Set = valueSet->Get<Vector2>();
 115           tet_printf( "Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y );
 116           return false;
 117         }
 118         else if( valueSet->GetType() == Dali::Property::VECTOR4 && ( valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>() ) )
 119         {
 120           Vector4 vector4Get = valueGet.second.Get<Vector4>();
 121           Vector4 vector4Set = valueSet->Get<Vector4>();
 122           tet_printf( "Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a );
 123           return false;
 124         }
 125       }
 126       else
 127       {
 128         if ( valueGet.first.type == Property::Key::INDEX )
 129         {
 130           tet_printf( "  The key %d doesn't exist.", valueGet.first.indexKey );
 131         }
 132         else
 133         {
 134           tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
 135         }
 136         return false;
 137       }
 138     }
 139   }
 140
 141   return true;
 142 }
 143
 144 } //namespace
 145
 146 void dali_visual_startup(void)
 147 {
 148   test_return_value = TET_UNDEF;
 149 }
 150
 151 void dali_visual_cleanup(void)
 152 {
 153   test_return_value = TET_PASS;
 154 }
 155
 156
 157 static void TestMixColor( Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor )
 158 {
 159   Property::Map map;
 160   visual.CreatePropertyMap(map);
 161   Property::Value* value = map.Find( mixColorIndex );
 162   DALI_TEST_CHECK( value );
 163   Vector3 mixColor1;
 164   DALI_TEST_CHECK( value->Get( mixColor1 ) );
 165   DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
 166
 167   value = map.Find( Visual::Property::MIX_COLOR );
 168   DALI_TEST_CHECK( value );
 169   Vector4 mixColor2;
 170   DALI_TEST_CHECK( value->Get( mixColor2 ) );
 171   DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
 172
 173   value = map.Find( Visual::Property::OPACITY );
 174   DALI_TEST_CHECK( value );
 175   float opacity;
 176   DALI_TEST_CHECK( value->Get( opacity ) );
 177   DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
 178 }
 179
 180
 181 int UtcDaliVisualCopyAndAssignment(void)
 182 {
 183   ToolkitTestApplication application;
 184   tet_infoline( "UtcDaliVisualCopyAndAssignment" );
 185
 186   VisualFactory factory = VisualFactory::Get();
 187   Property::Map propertyMap;
 188   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 189   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 190   Visual::Base visual = factory.CreateVisual( propertyMap );
 191
 192   Visual::Base visualCopy( visual );
 193   DALI_TEST_CHECK(visual == visualCopy);
 194
 195   Visual::Base emptyVisual;
 196   Visual::Base emptyVisualCopy( emptyVisual );
 197   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 198
 199   Visual::Base visualEquals;
 200   visualEquals = visual;
 201   DALI_TEST_CHECK(visual == visualEquals);
 202
 203   Visual::Base emptyVisualEquals;
 204   emptyVisualEquals = emptyVisual;
 205   DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
 206
 207   //self assignment
 208   visual = visual;
 209   DALI_TEST_CHECK( visual = visualCopy );
 210
 211   END_TEST;
 212 }
 213
 214 int UtcDaliVisualSetName01(void)
 215 {
 216   ToolkitTestApplication application;
 217   tet_infoline( "UtcDaliVisualSetName" );
 218
 219   VisualFactory factory = VisualFactory::Get();
 220   Property::Map propertyMap;
 221   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 222   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 223   Visual::Base visual = factory.CreateVisual( propertyMap );
 224
 225   const char* visualName = "backgroundVisual";
 226   visual.SetName( visualName );
 227
 228   DALI_TEST_EQUALS( visual.GetName(), visualName, TEST_LOCATION );
 229
 230   END_TEST;
 231 }
 232
 233 int UtcDaliVisualSetGetDepthIndex(void)
 234 {
 235   ToolkitTestApplication application;
 236   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 237
 238   VisualFactory factory = VisualFactory::Get();
 239   Property::Map propertyMap;
 240   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 241   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 242   Visual::Base visual = factory.CreateVisual( propertyMap );
 243
 244   visual.SetDepthIndex( 1 );
 245
 246   DummyControl dummyControl = DummyControl::New(true);
 247   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 248   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 249
 250   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 251   application.GetScene().Add( dummyControl );
 252
 253
 254   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 255   DALI_TEST_EQUALS( depthIndex, 1, TEST_LOCATION );
 256   DALI_TEST_EQUALS( visual.GetDepthIndex(), 1, TEST_LOCATION );
 257
 258   visual.SetDepthIndex( -1 );
 259   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 260   DALI_TEST_EQUALS( depthIndex, -1, TEST_LOCATION );
 261   DALI_TEST_EQUALS( visual.GetDepthIndex(), -1, TEST_LOCATION );
 262
 263   END_TEST;
 264 }
 265
 266 int UtcDaliVisualSize(void)
 267 {
 268   ToolkitTestApplication application;
 269   tet_infoline( "UtcDaliVisualSize" );
 270
 271   VisualFactory factory = VisualFactory::Get();
 272   Vector2 controlSize( 20.f, 30.f );
 273   Vector2 naturalSize;
 274
 275   // color colorVisual
 276   Dali::Property::Map map;
 277   map[ Toolkit::Visual::Property::TYPE ] = Visual::COLOR;
 278   map[ ColorVisual::Property::MIX_COLOR ] = Color::MAGENTA;
 279
 280   Visual::Base colorVisual = factory.CreateVisual( map );
 281   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 282
 283   colorVisual.GetNaturalSize(naturalSize);
 284   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 285
 286   // image visual
 287   map.Clear();
 288   map[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
 289   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
 290   map[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
 291   map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
 292   Visual::Base imageVisual = factory.CreateVisual( map );
 293   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 294
 295   imageVisual.GetNaturalSize(naturalSize);
 296   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
 297
 298   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 299
 300   // border visual
 301   float borderSize = 5.f;
 302   map.Clear();
 303   map[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 304   map[ BorderVisual::Property::COLOR  ] = Color::RED;
 305   map[ BorderVisual::Property::SIZE   ] = borderSize;
 306   Visual::Base borderVisual = factory.CreateVisual( map );
 307   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 308   borderVisual.GetNaturalSize(naturalSize);
 309   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 310
 311   // gradient gradientVisual
 312   Property::Map propertyMap;
 313   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 314   Vector2 start(-1.f, -1.f);
 315   Vector2 end(1.f, 1.f);
 316   propertyMap.Insert( "mixColor", Color::MAGENTA );
 317   propertyMap.Insert( GradientVisual::Property::START_POSITION,   start) ;
 318   propertyMap.Insert( GradientVisual::Property::END_POSITION,   end );
 319   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET,   Vector2(0.f, 1.f) );
 320   propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
 321   Property::Array stopColors;
 322   stopColors.PushBack( Color::RED );
 323   stopColors.PushBack( Color::GREEN );
 324   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 325   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 326   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 327   gradientVisual.GetNaturalSize(naturalSize);
 328   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
 329
 330   // animated gradient visual
 331   Vector2 animated_gradient_visual_size(10.f, 10.f);
 332   propertyMap.Clear();
 333   propertyMap.Insert( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT );
 334   Visual::Base animatedGradientVisual = factory.CreateVisual( propertyMap );
 335   animatedGradientVisual.GetNaturalSize(naturalSize);
 336   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 337   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 338
 339   // svg visual
 340   Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 341   svgVisual.GetNaturalSize(naturalSize);
 342   // TEST_SVG_FILE:
 343   //  <svg width="100" height="100">
 344   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 345   //  </svg>
 346   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION );
 347
 348   // svg visual with a size
 349   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions(200, 200) );
 350   svgVisual2.GetNaturalSize(naturalSize);
 351   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
 352
 353   // Text visual.
 354
 355   // Load some fonts to get the same metrics on different platforms.
 356   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 357   fontClient.SetDpi( 96u, 96u );
 358
 359   char* pathNamePtr = get_current_dir_name();
 360   const std::string pathName( pathNamePtr );
 361   free( pathNamePtr );
 362
 363   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf" );
 364
 365   // Create a TextVisual with a font size of 12 first
 366   propertyMap.Clear();
 367   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
 368   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
 369   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
 370   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
 371
 372   Visual::Base smallTextVisual = factory.CreateVisual( propertyMap );
 373   Vector2 smallTextVisualNaturalSize;
 374   smallTextVisual.GetNaturalSize( smallTextVisualNaturalSize );
 375
 376   // Then create a TextVisual with a font size of 20
 377   propertyMap[ TextVisual::Property::TEXT ] = "<font family='TizenSans' size='20'>Hello world</font>";
 378   Visual::Base largeTextVisual = factory.CreateVisual( propertyMap );
 379   Vector2 largeTextVisualNaturalSize;
 380   largeTextVisual.GetNaturalSize( largeTextVisualNaturalSize );
 381
 382   // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
 383   DALI_TEST_CHECK( smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
 384                    smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height );
 385
 386   // The height returned for a particular width should also be greater for the large text visual
 387   DALI_TEST_CHECK( smallTextVisual.GetHeightForWidth( 40.f ) < largeTextVisual.GetHeightForWidth( 40.f ) );
 388
 389   //AnimatedImageVisual
 390   Visual::Base animatedImageVisual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
 391   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 392   animatedImageVisual.GetNaturalSize(naturalSize);
 393   // TEST_GIF_FILE: anim.gif
 394   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 395   DALI_TEST_EQUALS( naturalSize, Vector2(50.f, 50.f), TEST_LOCATION );
 396
 397   END_TEST;
 398 }
 399
 400 int UtcDaliVisualSetOnOffScene(void)
 401 {
 402   ToolkitTestApplication application;
 403   tet_infoline( "UtcDaliVisualSetOnOffScene" );
 404
 405   VisualFactory factory = VisualFactory::Get();
 406   Property::Map propertyMap;
 407   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 408   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 409   Visual::Base visual = factory.CreateVisual( propertyMap );
 410
 411   DummyControl actor = DummyControl::New(true);
 412   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 413   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 414
 415   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 416
 417   application.SendNotification();
 418   application.Render(0);
 419   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 420
 421   application.GetScene().Add( actor );
 422
 423   application.SendNotification();
 424   application.Render(0);
 425   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 426
 427   application.GetScene().Remove( actor );
 428
 429   application.SendNotification();
 430   application.Render(0);
 431   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 432
 433   END_TEST;
 434 }
 435
 436 int UtcDaliVisualSetOnOffScene2(void)
 437 {
 438   ToolkitTestApplication application;
 439   tet_infoline( "UtcDaliVisualSetOnOffScene2" );
 440
 441   VisualFactory factory = VisualFactory::Get();
 442   Property::Map propertyMap;
 443   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
 444   propertyMap.Insert( ImageVisual::Property::URL,  TEST_SVG_FILE_NAME );
 445   Visual::Base visual = factory.CreateVisual( propertyMap );
 446
 447   DummyControl actor = DummyControl::New(true);
 448   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 449   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 450
 451   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 452
 453   application.SendNotification();
 454   application.Render(0);
 455   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 456
 457   // First on/off
 458   application.GetScene().Add( actor );
 459
 460   application.SendNotification();
 461   application.Render(0);
 462   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 463   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 464   Renderer renderer = actor.GetRendererAt( 0 );
 465   auto textures = renderer.GetTextures();
 466   DALI_TEST_CHECK( textures.GetTextureCount() != 0u );
 467
 468   application.GetScene().Remove( actor );
 469
 470   application.SendNotification();
 471   application.Render(0);
 472   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 473
 474   // Second on/off
 475   application.GetScene().Add( actor );
 476
 477   application.SendNotification();
 478   application.Render(0);
 479   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 480   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 481   renderer = actor.GetRendererAt( 0 );
 482   textures = renderer.GetTextures();
 483   DALI_TEST_CHECK( textures.GetTextureCount() != 0u );
 484
 485   application.GetScene().Remove( actor );
 486
 487   application.SendNotification();
 488   application.Render(0);
 489   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 490
 491   END_TEST;
 492 }
 493
 494 int UtcDaliVisualGetPropertyMap1(void)
 495 {
 496   ToolkitTestApplication application;
 497   tet_infoline( "UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor" );
 498
 499   VisualFactory factory = VisualFactory::Get();
 500   Property::Map propertyMap;
 501   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 502   propertyMap.Insert(Visual::Property::MIX_COLOR,  Color::BLUE);
 503   propertyMap.Insert( DevelVisual::Property::CORNER_RADIUS, 10.0f );
 504   propertyMap.Insert( DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE );
 505   propertyMap.Insert( DevelVisual::Property::BORDERLINE_WIDTH, 20.0f );
 506   propertyMap.Insert( DevelVisual::Property::BORDERLINE_COLOR, Color::RED );
 507   propertyMap.Insert( DevelVisual::Property::BORDERLINE_OFFSET, -1.0f );
 508   propertyMap.Insert( DevelColorVisual::Property::BLUR_RADIUS, 20.0f );
 509   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 510
 511   Property::Map resultMap;
 512   colorVisual.CreatePropertyMap( resultMap );
 513
 514   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 515   DALI_TEST_CHECK( typeValue );
 516   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 517
 518   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 519   DALI_TEST_CHECK( colorValue );
 520   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 521
 522   Property::Value* cornerRadiusValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4 );
 523   DALI_TEST_CHECK( cornerRadiusValue );
 524   DALI_TEST_CHECK( cornerRadiusValue->Get< Vector4 >() == Vector4(10.0f, 10.0f, 10.0f, 10.0f) );
 525
 526   Property::Value* cornerRadiusPolicyValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER );
 527   DALI_TEST_CHECK( cornerRadiusPolicyValue );
 528   DALI_TEST_CHECK( cornerRadiusPolicyValue->Get< int >() == Toolkit::Visual::Transform::Policy::RELATIVE );
 529
 530   Property::Value* borderlineWidthValue = resultMap.Find( DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT );
 531   DALI_TEST_CHECK( borderlineWidthValue );
 532   DALI_TEST_CHECK( borderlineWidthValue->Get< float >() == 20.0f );
 533
 534   Property::Value* borderlineColorValue = resultMap.Find( DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4 );
 535   DALI_TEST_CHECK( borderlineColorValue );
 536   DALI_TEST_CHECK( borderlineColorValue->Get< Vector4 >() == Color::RED );
 537
 538   Property::Value* borderlineOffsetValue = resultMap.Find( DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT );
 539   DALI_TEST_CHECK( borderlineOffsetValue );
 540   DALI_TEST_CHECK( borderlineOffsetValue->Get< float >() == -1.0f );
 541
 542   Property::Value* blurRadiusValue = resultMap.Find( DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT );
 543   DALI_TEST_CHECK( blurRadiusValue );
 544   DALI_TEST_CHECK( blurRadiusValue->Get< float >() == 20.0f );
 545
 546   // change the blend color
 547   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 548   colorVisual = factory.CreateVisual( propertyMap  );
 549   colorVisual.CreatePropertyMap( resultMap );
 550
 551   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 552   DALI_TEST_CHECK( colorValue );
 553   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 554
 555   // Test wrong values
 556   propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
 557
 558   colorVisual = factory.CreateVisual( propertyMap  );
 559   colorVisual.CreatePropertyMap( resultMap );
 560
 561   blurRadiusValue = resultMap.Find( DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT );
 562   DALI_TEST_CHECK( blurRadiusValue );
 563   DALI_TEST_CHECK( blurRadiusValue->Get< float >() == 0.0f );
 564
 565   END_TEST;
 566 }
 567
 568 int UtcDaliVisualGetPropertyMap2(void)
 569 {
 570   ToolkitTestApplication application;
 571   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 572
 573   VisualFactory factory = VisualFactory::Get();
 574   Property::Map propertyMap;
 575   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 576   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
 577   propertyMap.Insert("borderColor",  Color::BLUE);
 578   propertyMap.Insert("borderSize",  5.f);
 579   propertyMap.Insert("antiAliasing",  true);
 580   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 581
 582   Property::Map resultMap;
 583   borderVisual.CreatePropertyMap( resultMap );
 584
 585   // check the property values from the returned map from visual
 586   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 587   DALI_TEST_CHECK( typeValue );
 588   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 589
 590   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 591   DALI_TEST_CHECK( colorValue );
 592   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 593
 594   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 595   DALI_TEST_CHECK( sizeValue );
 596   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 597
 598   Property::Value* AAValue = resultMap.Find( BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN );
 599   DALI_TEST_CHECK( AAValue );
 600   DALI_TEST_CHECK( AAValue->Get<bool>() == true );
 601
 602   Property::Map propertyMap1;
 603   propertyMap1[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 604   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 605   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 606   borderVisual = factory.CreateVisual( propertyMap1 );
 607   borderVisual.CreatePropertyMap( resultMap );
 608
 609   typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 610   DALI_TEST_CHECK( typeValue );
 611   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 612
 613   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 614   DALI_TEST_CHECK( colorValue );
 615   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 616
 617   sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 618   DALI_TEST_CHECK( sizeValue );
 619   DALI_TEST_CHECK( sizeValue->Get<float>() == 10.f );
 620
 621   // Get default value of borderline values here
 622
 623   sizeValue = resultMap.Find( DevelVisual::Property::BORDERLINE_WIDTH,  Property::FLOAT );
 624   DALI_TEST_CHECK( sizeValue );
 625   DALI_TEST_CHECK( sizeValue->Get<float>() == 0.0f );
 626
 627   colorValue = resultMap.Find( DevelVisual::Property::BORDERLINE_COLOR,  Property::VECTOR4 );
 628   DALI_TEST_CHECK( colorValue );
 629   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLACK );
 630
 631   sizeValue = resultMap.Find( DevelVisual::Property::BORDERLINE_OFFSET,  Property::FLOAT );
 632   DALI_TEST_CHECK( sizeValue );
 633   DALI_TEST_CHECK( sizeValue->Get<float>() == 0.0f );
 634
 635   END_TEST;
 636 }
 637
 638 int UtcDaliVisualGetPropertyMap2N(void)
 639 {
 640   ToolkitTestApplication application;
 641   tet_infoline( "UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties" );
 642
 643   VisualFactory factory = VisualFactory::Get();
 644   Property::Map propertyMap;
 645   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 646   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 647
 648   tet_infoline( "Test that the visual is created, with a default renderer" );
 649   DALI_TEST_CHECK( borderVisual );
 650
 651   DummyControl dummyControl = DummyControl::New(true);
 652   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 653   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
 654   application.GetScene().Add( dummyControl );
 655
 656   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
 657
 658   END_TEST;
 659 }
 660
 661
 662 int UtcDaliVisualGetPropertyMap3(void)
 663 {
 664   ToolkitTestApplication application;
 665   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 666
 667   VisualFactory factory = VisualFactory::Get();
 668   DALI_TEST_CHECK( factory );
 669
 670   Property::Map propertyMap;
 671   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 672
 673   Vector2 start(-1.f, -1.f);
 674   Vector2 end(1.f, 1.f);
 675   propertyMap.Insert( "startPosition", start);
 676   propertyMap.Insert( "endPosition", end);
 677   propertyMap.Insert( "spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 678
 679   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 680
 681   Property::Array stopColors;
 682   stopColors.PushBack( Color::RED );
 683   stopColors.PushBack( Color::GREEN );
 684   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 685
 686   float borderlineWidth = 4.0f;
 687   Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
 688   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH,  borderlineWidth);
 689   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS,  cornerRadius);
 690
 691   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 692
 693   Property::Map resultMap;
 694   gradientVisual.CreatePropertyMap( resultMap );
 695
 696   // check the property values from the returned map from visual
 697   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 698   DALI_TEST_CHECK( value );
 699   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 700
 701   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 702   DALI_TEST_CHECK( value );
 703   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 704
 705   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 706   DALI_TEST_CHECK( value );
 707   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 708
 709   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 710   DALI_TEST_CHECK( value );
 711   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 712
 713   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 714   DALI_TEST_CHECK( value );
 715   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 716
 717   value = resultMap.Find( DevelVisual::Property::BORDERLINE_WIDTH,   Property::FLOAT );
 718   DALI_TEST_CHECK( value );
 719   DALI_TEST_EQUALS( value->Get<float>(), borderlineWidth , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 720
 721   value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS,   Property::VECTOR4 );
 722   DALI_TEST_CHECK( value );
 723   DALI_TEST_EQUALS( value->Get<Vector4>(), cornerRadius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 724
 725   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 726   DALI_TEST_CHECK( value );
 727   Property::Array* offsetArray = value->GetArray();
 728   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 729   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 730   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 731
 732   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 733   DALI_TEST_CHECK( value );
 734   Property::Array* colorArray = value->GetArray();
 735   DALI_TEST_CHECK( colorArray->Count() == 2 );
 736   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 737   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 738
 739   END_TEST;
 740 }
 741
 742 int UtcDaliVisualGetPropertyMap4(void)
 743 {
 744   ToolkitTestApplication application;
 745   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 746
 747   VisualFactory factory = VisualFactory::Get();
 748   DALI_TEST_CHECK( factory );
 749
 750   Property::Map propertyMap;
 751   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 752
 753   Vector2 center(100.f, 100.f);
 754   float radius = 100.f;
 755   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 756   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 757   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 758   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 759
 760   Property::Array stopColors;
 761   stopColors.PushBack( Color::RED );
 762   stopColors.PushBack( Color::BLACK );
 763   stopColors.PushBack( Color::GREEN );
 764   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 765
 766   float borderlineWidth = 8.0f;
 767   Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
 768   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH,  borderlineWidth);
 769   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS,  cornerRadius);
 770
 771   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 772   DALI_TEST_CHECK( gradientVisual );
 773
 774   Property::Map resultMap;
 775   gradientVisual.CreatePropertyMap( resultMap );
 776
 777   // check the property values from the returned map from visual
 778   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 779   DALI_TEST_CHECK( value );
 780   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 781
 782   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 783   DALI_TEST_CHECK( value );
 784   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 785
 786   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 787   DALI_TEST_CHECK( value );
 788   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 789
 790   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 791   DALI_TEST_CHECK( value );
 792   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 793
 794   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 795   DALI_TEST_CHECK( value );
 796   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 797
 798   value = resultMap.Find( DevelVisual::Property::BORDERLINE_WIDTH,   Property::FLOAT );
 799   DALI_TEST_CHECK( value );
 800   DALI_TEST_EQUALS( value->Get<float>(), borderlineWidth , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 801
 802   value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS,   Property::VECTOR4 );
 803   DALI_TEST_CHECK( value );
 804   DALI_TEST_EQUALS( value->Get<Vector4>(), cornerRadius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 805
 806   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 807   DALI_TEST_CHECK( value );
 808   Property::Array* offsetArray = value->GetArray();
 809   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 810   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 811   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 812   // any stop value will be clamped to [0.0, 1.0];
 813   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 814
 815   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 816   DALI_TEST_CHECK( value );
 817   Property::Array* colorArray = value->GetArray();
 818   DALI_TEST_CHECK( colorArray->Count() == 3 );
 819   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 820   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 821   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 822
 823   END_TEST;
 824 }
 825
 826 int UtcDaliVisualGetPropertyMap5(void)
 827 {
 828   ToolkitTestApplication application;
 829   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 830
 831   VisualFactory factory = VisualFactory::Get();
 832   Property::Map propertyMap;
 833   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 834   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
 835   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 836   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 837   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 838   propertyMap.Insert( "fittingMode",   FittingMode::FIT_HEIGHT );
 839   propertyMap.Insert( "samplingMode",   SamplingMode::BOX_THEN_NEAREST );
 840   propertyMap.Insert( "pixelArea", Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 841   propertyMap.Insert( "wrapModeU", WrapMode::REPEAT );
 842   propertyMap.Insert( "wrapModeV", WrapMode::MIRRORED_REPEAT );
 843   propertyMap.Insert( "synchronousLoading",   true );
 844
 845   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 846   DALI_TEST_CHECK( imageVisual );
 847
 848   Property::Map resultMap;
 849   imageVisual.CreatePropertyMap( resultMap );
 850
 851   // check the property values from the returned map from visual
 852   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 853   DALI_TEST_CHECK( value );
 854   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 855
 856   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 857   DALI_TEST_CHECK( value );
 858   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 859
 860   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 861   DALI_TEST_CHECK( value );
 862   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 863
 864   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 865   DALI_TEST_CHECK( value );
 866   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 867
 868   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 869   DALI_TEST_CHECK( value );
 870   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX_THEN_NEAREST );
 871
 872   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 873   DALI_TEST_CHECK( value );
 874   DALI_TEST_CHECK( value->Get<int>() == 20 );
 875
 876   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 877   DALI_TEST_CHECK( value );
 878   DALI_TEST_CHECK( value->Get<int>() == 30 );
 879
 880   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 881   DALI_TEST_CHECK( value );
 882   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.25f, 0.25f, 0.5f, 0.5f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 883
 884   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 885   DALI_TEST_CHECK( value );
 886   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::REPEAT);
 887
 888   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 889   DALI_TEST_CHECK( value );
 890   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 891
 892   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 893   DALI_TEST_CHECK( value );
 894   DALI_TEST_CHECK( value->Get<bool>() == true );
 895
 896   END_TEST;
 897 }
 898
 899 int UtcDaliVisualGetPropertyMap6(void)
 900 {
 901   ToolkitTestApplication application;
 902   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 903
 904   Rect< int > border( 1, 1, 1, 1 );
 905
 906   VisualFactory factory = VisualFactory::Get();
 907   Property::Map propertyMap;
 908   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 909   propertyMap.Insert( "mixColor",  Color::MAGENTA );
 910   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 911   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 912   propertyMap.Insert( ImageVisual::Property::BORDER, border );
 913   propertyMap.Insert( DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png" );
 914   propertyMap.Insert( DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f );
 915   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 916
 917   Property::Map resultMap;
 918   nPatchVisual.CreatePropertyMap( resultMap );
 919
 920   // check the property values from the returned map from visual
 921   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 922   DALI_TEST_CHECK( value );
 923   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 924
 925   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 926   DALI_TEST_CHECK( value );
 927   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 928
 929   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 930   DALI_TEST_CHECK( value );
 931   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 932
 933   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 934   DALI_TEST_CHECK( value );
 935   DALI_TEST_CHECK( value->Get<bool>() );
 936
 937   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 938   DALI_TEST_CHECK( value );
 939   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 940
 941   value = resultMap.Find( DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING );
 942   DALI_TEST_CHECK( value );
 943   DALI_TEST_CHECK( value->Get<std::string>() == "application-icon-30.png" );
 944
 945   value = resultMap.Find( DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT );
 946   DALI_TEST_CHECK( value );
 947   DALI_TEST_CHECK( value->Get<float>() == 0.9f );
 948
 949   Vector4 border1( 1.0f, 1.0f, 1.0f, 1.0f );
 950
 951   Property::Map propertyMap1;
 952   propertyMap1.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 953   propertyMap1.Insert( "mixColor",  Color::MAGENTA );
 954   propertyMap1.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 955   propertyMap1.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 956   propertyMap1.Insert( ImageVisual::Property::BORDER, border1 );
 957   nPatchVisual = factory.CreateVisual( propertyMap1 );
 958
 959   nPatchVisual.CreatePropertyMap( resultMap );
 960
 961   // check the property values from the returned map from visual
 962   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 963   DALI_TEST_CHECK( value );
 964   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 965
 966   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 967   DALI_TEST_CHECK( value );
 968   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 969
 970   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 971   DALI_TEST_CHECK( value );
 972   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 973
 974   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 975   DALI_TEST_CHECK( value );
 976   DALI_TEST_CHECK( value->Get<bool>() );
 977
 978   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 979   DALI_TEST_CHECK( value );
 980   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 981
 982   END_TEST;
 983 }
 984
 985 int UtcDaliVisualGetPropertyMap7(void)
 986 {
 987   ToolkitTestApplication application;
 988   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 989
 990   // request SvgVisual with a property map
 991   VisualFactory factory = VisualFactory::Get();
 992   Property::Map propertyMap;
 993   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
 994   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::WHITE );
 995   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 996   propertyMap.Insert( ImageVisual::Property::ATLASING, false );
 997   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 998
 999   Property::Map resultMap;
1000   svgVisual.CreatePropertyMap( resultMap );
1001   // check the property values from the returned map from a visual
1002   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1003   DALI_TEST_CHECK( value );
1004   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
1005
1006   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
1007   DALI_TEST_CHECK( value );
1008   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
1009
1010   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
1011   DALI_TEST_CHECK( value );
1012   DALI_TEST_CHECK( value->Get<bool>() == false );
1013
1014   // request SvgVisual with a property map 2
1015   propertyMap.Clear();
1016   propertyMap[ "visualType" ] = Visual::SVG;
1017   propertyMap[ "mixColor" ] = Color::WHITE;
1018   propertyMap[ "url" ] = TEST_SVG_FILE_NAME;
1019   propertyMap[ "atlasing" ] = true;
1020   Visual::Base svgVisual1 = factory.CreateVisual( propertyMap );
1021
1022   resultMap.Clear();
1023   svgVisual1.CreatePropertyMap( resultMap );
1024   // check the property values from the returned map from a visual
1025   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1026   DALI_TEST_CHECK( value );
1027   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
1028
1029   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
1030   DALI_TEST_CHECK( value );
1031   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
1032
1033   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
1034   DALI_TEST_CHECK( value );
1035   DALI_TEST_CHECK( value->Get<bool>() == true );
1036
1037   // request SvgVisual with an URL
1038   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
1039   resultMap.Clear();
1040   svgVisual2.CreatePropertyMap( resultMap );
1041   // check the property values from the returned map from a visual
1042   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1043   DALI_TEST_CHECK( value );
1044   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
1045
1046   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
1047   DALI_TEST_CHECK( value );
1048   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
1049
1050   END_TEST;
1051 }
1052
1053 //Mesh visual
1054 int UtcDaliVisualGetPropertyMap8(void)
1055 {
1056   ToolkitTestApplication application;
1057   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
1058
1059   //Request MeshVisual using a property map.
1060   VisualFactory factory = VisualFactory::Get();
1061   Property::Map propertyMap;
1062   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1063   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLUE );
1064   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1065   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1066   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
1067   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1068   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
1069   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
1070
1071   Property::Map resultMap;
1072   meshVisual.CreatePropertyMap( resultMap );
1073   TestMixColor( meshVisual, Visual::Property::MIX_COLOR, Color::BLUE );
1074
1075   //Check values in the result map are identical to the initial map's values.
1076   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1077   DALI_TEST_CHECK( value );
1078   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
1079
1080   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
1081   DALI_TEST_CHECK( value );
1082   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
1083
1084   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
1085   DALI_TEST_CHECK( value );
1086   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
1087
1088   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
1089   DALI_TEST_CHECK( value );
1090   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
1091
1092   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
1093   DALI_TEST_CHECK( value );
1094   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
1095
1096   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1097   DALI_TEST_CHECK( value );
1098   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1099
1100  END_TEST;
1101 }
1102
1103 //Primitive shape visual
1104 int UtcDaliVisualGetPropertyMap9(void)
1105 {
1106   ToolkitTestApplication application;
1107   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
1108
1109   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
1110   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
1111
1112   //Request PrimitiveVisual using a property map.
1113   VisualFactory factory = VisualFactory::Get();
1114   Property::Map propertyMap;
1115   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1116   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1117   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
1118   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1119   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1120   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1121   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1122   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1123   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
1124   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
1125   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
1126   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
1127   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
1128   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
1129
1130   Property::Map resultMap;
1131   primitiveVisual.CreatePropertyMap( resultMap );
1132
1133   //Check values in the result map are identical to the initial map's values.
1134   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1135   DALI_TEST_CHECK( value );
1136   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
1137
1138   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
1139   DALI_TEST_CHECK( value );
1140   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
1141
1142   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
1143   DALI_TEST_CHECK( value );
1144   DALI_TEST_CHECK( value->Get<Vector4>() == color );
1145   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1146
1147   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
1148   DALI_TEST_CHECK( value );
1149   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
1150
1151   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
1152   DALI_TEST_CHECK( value );
1153   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
1154
1155   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
1156   DALI_TEST_CHECK( value );
1157   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1158
1159   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
1160   DALI_TEST_CHECK( value );
1161   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1162
1163   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
1164   DALI_TEST_CHECK( value );
1165   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1166
1167   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
1168   DALI_TEST_CHECK( value );
1169   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1170
1171   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
1172   DALI_TEST_CHECK( value );
1173   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1174
1175   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
1176   DALI_TEST_CHECK( value );
1177   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1178
1179   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
1180   DALI_TEST_CHECK( value );
1181   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1182
1183   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1184   DALI_TEST_CHECK( value );
1185   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1186
1187   END_TEST;
1188 }
1189
1190 //Text shape visual
1191 int UtcDaliVisualGetPropertyMap10(void)
1192 {
1193   ToolkitTestApplication application;
1194   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
1195
1196   //Request PrimitiveVisual using a property map.
1197   VisualFactory factory = VisualFactory::Get();
1198
1199   Property::Map propertyMap;
1200   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1201   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLACK );
1202   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
1203   propertyMap.Insert( "enableMarkup", false );
1204   propertyMap.Insert( "text", "Hello world" );
1205   propertyMap.Insert( "fontFamily", "TizenSans" );
1206
1207   Property::Map fontStyleMapSet;
1208   fontStyleMapSet.Insert( "weight", "bold" );
1209   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1210
1211   propertyMap.Insert( "pointSize", 12.f );
1212   propertyMap.Insert( "multiLine", true );
1213   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1214   propertyMap.Insert( "verticalAlignment", "CENTER" );
1215   propertyMap.Insert( "textColor", Color::RED );
1216
1217   Property::Map shadowMapSet;
1218   propertyMap.Insert( "shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f) );
1219
1220   Property::Map underlineMapSet;
1221   propertyMap.Insert( "underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1) );
1222
1223   Property::Map outlineMapSet;
1224   propertyMap.Insert( "outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1) );
1225
1226   Property::Map backgroundMapSet;
1227   propertyMap.Insert( "textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN) );
1228
1229   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1230
1231   Property::Map resultMap;
1232   textVisual.CreatePropertyMap( resultMap );
1233
1234   //Check values in the result map are identical to the initial map's values.
1235   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1236   DALI_TEST_CHECK( value );
1237   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION );
1238
1239   value = resultMap.Find( Visual::Property::MIX_COLOR, Property::VECTOR4 );
1240   DALI_TEST_CHECK( value );
1241   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1242
1243   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1244   DALI_TEST_CHECK( value );
1245   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1246
1247   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1248   DALI_TEST_CHECK( value );
1249   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1250
1251   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1252   DALI_TEST_CHECK( value );
1253
1254   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1255   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1256   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1257
1258   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1259   DALI_TEST_CHECK( value );
1260   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1261
1262   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1263   DALI_TEST_CHECK( value );
1264   DALI_TEST_CHECK( value->Get<bool>() );
1265
1266   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER );
1267   DALI_TEST_CHECK( value );
1268   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION );
1269
1270   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER );
1271   DALI_TEST_CHECK( value );
1272   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION );
1273
1274   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1275   DALI_TEST_CHECK( value );
1276   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1277
1278   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1279   DALI_TEST_CHECK( value );
1280   DALI_TEST_CHECK( !value->Get<bool>() );
1281
1282   value = resultMap.Find( TextVisual::Property::SHADOW, Property::MAP );
1283   DALI_TEST_CHECK( value );
1284
1285   Property::Map shadowMapGet = value->Get<Property::Map>();
1286   DALI_TEST_EQUALS( shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION );
1287   DALI_TEST_EQUALS( DaliTestCheckMaps( shadowMapGet, shadowMapSet ), true, TEST_LOCATION );
1288
1289   value = resultMap.Find( TextVisual::Property::UNDERLINE, Property::MAP );
1290   DALI_TEST_CHECK( value );
1291
1292   Property::Map underlineMapGet = value->Get<Property::Map>();
1293   DALI_TEST_EQUALS( underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION );
1294   DALI_TEST_EQUALS( DaliTestCheckMaps( underlineMapGet, underlineMapSet ), true, TEST_LOCATION );
1295
1296   value = resultMap.Find( DevelTextVisual::Property::OUTLINE, Property::MAP );
1297   DALI_TEST_CHECK( value );
1298
1299   Property::Map outlineMapGet = value->Get<Property::Map>();
1300   DALI_TEST_EQUALS( outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION );
1301   DALI_TEST_EQUALS( DaliTestCheckMaps( outlineMapGet, outlineMapSet ), true, TEST_LOCATION );
1302
1303   value = resultMap.Find( DevelTextVisual::Property::BACKGROUND, Property::MAP );
1304   DALI_TEST_CHECK( value );
1305
1306   Property::Map backgroundMapGet = value->Get<Property::Map>();
1307   DALI_TEST_EQUALS( backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION );
1308   DALI_TEST_EQUALS( DaliTestCheckMaps( backgroundMapGet, backgroundMapSet ), true, TEST_LOCATION );
1309
1310   END_TEST;
1311 }
1312
1313 int UtcDaliVisualGetPropertyMap11(void)
1314 {
1315   ToolkitTestApplication application;
1316   tet_infoline( "UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual" );
1317
1318   VisualFactory factory = VisualFactory::Get();
1319   DALI_TEST_CHECK( factory );
1320
1321   Property::Map propertyMap;
1322   propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1323
1324   Vector2 start(-0.5f, 0.5f);
1325   Vector2 end  (0.5f, -0.0f);
1326   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1327   Vector4 end_color  (0.7f, 0.5f, 1.0f, 1.0f);
1328   Vector2 rotate_center(0.0f, 0.4f);
1329   float rotate_amount = 1.57f;
1330   float offset = 100.f;
1331
1332   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::RADIAL);
1333   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1334   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::CLAMP);
1335
1336   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION,  start);
1337   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,  end);
1338   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,  start_color);
1339   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,  end_color);
1340   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  rotate_center);
1341   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  rotate_amount);
1342   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,  offset);
1343
1344   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1345   DALI_TEST_CHECK( animatedGradientVisual );
1346
1347   Property::Map resultMap;
1348   animatedGradientVisual.CreatePropertyMap( resultMap );
1349
1350   // check the property values from the returned map from visual
1351   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1352   DALI_TEST_CHECK( value );
1353   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1354
1355   value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1356   DALI_TEST_CHECK( value );
1357   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1358
1359   value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1360   DALI_TEST_CHECK( value );
1361   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1362
1363   value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1364   DALI_TEST_CHECK( value );
1365   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP );
1366
1367
1368   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1369   DALI_TEST_CHECK( value );
1370   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1371
1372   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1373   DALI_TEST_CHECK( value );
1374   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1375
1376   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1377   DALI_TEST_CHECK( value );
1378   DALI_TEST_EQUALS( value->Get<Vector4>(), start_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1379
1380   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1381   DALI_TEST_CHECK( value );
1382   DALI_TEST_EQUALS( value->Get<Vector4>(), end_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1383
1384   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1385   DALI_TEST_CHECK( value );
1386   DALI_TEST_EQUALS( value->Get<Vector2>(), rotate_center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1387
1388   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1389   DALI_TEST_CHECK( value );
1390   DALI_TEST_EQUALS( value->Get<float>(), rotate_amount , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1391
1392   value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1393   DALI_TEST_CHECK( value );
1394   DALI_TEST_EQUALS( value->Get<float>(), offset , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1395
1396   END_TEST;
1397 }
1398
1399 int UtcDaliVisualGetPropertyMap12(void)
1400 {
1401   ToolkitTestApplication application;
1402   tet_infoline( "UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param" );
1403
1404   // Case 1 : Set values by index
1405   {
1406     tet_printf( " - Set Values by Index\n" );
1407     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1408     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1409     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1410     {
1411       tet_printf( "test with delay [%f]\n", _delay );
1412       VisualFactory factory = VisualFactory::Get();
1413       DALI_TEST_CHECK( factory );
1414
1415       Property::Map propertyMap;
1416       Property::Map animationMap;
1417       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1418
1419       float duration = 1.1f;
1420       float delay = _delay;
1421       float repeat_delay = 0.4f;
1422
1423       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1424       int loop_count = 5;
1425       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1426       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1427
1428       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1429       {
1430         animationMap.Clear();
1431         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1432         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1433         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1434         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1435         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1436         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1437         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1438         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1439         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1440
1441         return animationMap;
1442       };
1443
1444       Vector2 start1(-0.5f, 0.5f);
1445       Vector2 end1  (0.5f, -0.5f);
1446       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1447       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1448       Vector2 rotate_center1(0.0f, 0.4f);
1449       float rotate_amount1 = 0.0f;
1450       float offset1 = 0.f;
1451
1452       Vector2 start2(-0.5f, -0.5f);
1453       Vector2 end2  (0.5f, 0.5f);
1454       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1455       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1456       Vector2 rotate_center2(0.0f, -0.4f);
1457       float rotate_amount2 = 6.2832f;
1458       float offset2 = 2.f;
1459
1460       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1461       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1462       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REPEAT);
1463
1464       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1465       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1466       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1467       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1468       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1469       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1470       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1471
1472       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1473       DALI_TEST_CHECK( animatedGradientVisual );
1474
1475       Property::Map resultMap;
1476       animatedGradientVisual.CreatePropertyMap( resultMap );
1477
1478       // check the property values from the returned map from visual
1479       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1480       DALI_TEST_CHECK( value );
1481       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1482
1483       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1484       DALI_TEST_CHECK( value );
1485       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1486
1487       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1488       DALI_TEST_CHECK( value );
1489       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1490
1491       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1492       DALI_TEST_CHECK( value );
1493       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT );
1494
1495       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
1496       {
1497         tet_printf("Check value at %d\n", line_num);
1498         value = resultMap.Find( index, Property::MAP );
1499         DALI_TEST_CHECK( value );
1500         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1501         Property::Map *temp_map = value->GetMap();
1502         DALI_TEST_CHECK( temp_map );
1503
1504         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1505         {
1506           Property::Value *res = temp_map->Find( index );
1507           DALI_TEST_CHECK( res );
1508           return *res;
1509         };
1510
1511         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1512         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1513         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1514         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1515         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1516         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1517         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1518         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1519         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1520       };
1521
1522       // check the animation map data is good
1523       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1524       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1525       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1526       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1527       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1528       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1529       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1530     }
1531   }
1532
1533   // Case 2 : Set values by string
1534   {
1535     tet_printf( " - Set Values by String\n" );
1536     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1537     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1538     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1539     {
1540       tet_printf( "test with delay [%f]\n", _delay );
1541       VisualFactory factory = VisualFactory::Get();
1542       DALI_TEST_CHECK( factory );
1543
1544       Property::Map propertyMap;
1545       Property::Map animationMap;
1546       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1547
1548       float duration = 1.1f;
1549       float delay = _delay;
1550       float repeat_delay = 0.4f;
1551
1552       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1553       int loop_count = 5;
1554       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1555       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1556
1557       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value &start, const Property::Value &target)->Property::Map&
1558       {
1559         animationMap.Clear();
1560         animationMap.Insert("startValue"   , start);
1561         animationMap.Insert("targetValue"  , target);
1562         animationMap.Insert("directionType", "BACKWARD");
1563         animationMap.Insert("duration"     , duration);
1564         animationMap.Insert("delay"        , delay);
1565         animationMap.Insert("repeat"       , loop_count);
1566         animationMap.Insert("repeatDelay"  , repeat_delay);
1567         animationMap.Insert("motionType"   , "MIRROR");
1568         animationMap.Insert("easingType"   , "IN_OUT");
1569
1570         return animationMap;
1571       };
1572
1573       Vector2 start1(-0.5f, 0.5f);
1574       Vector2 end1  (0.5f, -0.5f);
1575       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1576       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1577       Vector2 rotate_center1(0.0f, 0.4f);
1578       float rotate_amount1 = 0.0f;
1579       float offset1 = 0.f;
1580
1581       Vector2 start2(-0.5f, -0.5f);
1582       Vector2 end2  (0.5f, 0.5f);
1583       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1584       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1585       Vector2 rotate_center2(0.0f, -0.4f);
1586       float rotate_amount2 = 6.2832f;
1587       float offset2 = 2.f;
1588
1589       // For test mix the type string/index key and string/index value works well.
1590       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  "RADIAL");
1591       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1592       propertyMap.Insert("spreadType"  , DevelAnimatedGradientVisual::SpreadType::REFLECT);
1593
1594       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ));
1595       propertyMap.Insert("endPosition"  , buildAnimatedMap(end1          , end2          ));
1596       propertyMap.Insert("startColor"   , buildAnimatedMap(start_color1  , start_color2  ));
1597       propertyMap.Insert("endColor"     , buildAnimatedMap(end_color1    , end_color2    ));
1598       propertyMap.Insert("rotateCenter" , buildAnimatedMap(rotate_center1, rotate_center2));
1599       propertyMap.Insert("rotateAmount" , buildAnimatedMap(rotate_amount1, rotate_amount2));
1600       propertyMap.Insert("offset"       , buildAnimatedMap(offset1       , offset2       ));
1601
1602       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1603       DALI_TEST_CHECK( animatedGradientVisual );
1604
1605       Property::Map resultMap;
1606       animatedGradientVisual.CreatePropertyMap( resultMap );
1607
1608       // check the property values from the returned map from visual
1609       // Note : resultMap from CreatePropertyMap only contain indexKey
1610       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1611       DALI_TEST_CHECK( value );
1612       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1613
1614       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1615       DALI_TEST_CHECK( value );
1616       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1617
1618       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1619       DALI_TEST_CHECK( value );
1620       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1621
1622       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1623       DALI_TEST_CHECK( value );
1624       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1625
1626       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
1627       {
1628         tet_printf("Check value at %d\n", line_num);
1629         value = resultMap.Find( index, Property::MAP );
1630         DALI_TEST_CHECK( value );
1631         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1632         Property::Map *temp_map = value->GetMap();
1633         DALI_TEST_CHECK( temp_map );
1634
1635         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1636         {
1637           Property::Value *res = temp_map->Find( index );
1638           DALI_TEST_CHECK( res );
1639           return *res;
1640         };
1641
1642         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1643         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1644         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1645         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1646         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1647         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1648         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1649         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1650         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1651       };
1652
1653       // check the animation map data is good
1654       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1655       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1656       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1657       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1658       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1659       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1660       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1661     }
1662   }
1663
1664   END_TEST;
1665 }
1666 int UtcDaliVisualGetPropertyMap13(void)
1667 {
1668   ToolkitTestApplication application;
1669   tet_infoline( "UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0" );
1670
1671   for(int _direction = 0; _direction <= 1; ++_direction)
1672   {
1673     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1674     {
1675       tet_printf( ((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n") , _delay );
1676       VisualFactory factory = VisualFactory::Get();
1677       DALI_TEST_CHECK( factory );
1678
1679       Property::Map propertyMap;
1680       Property::Map animationMap;
1681       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1682
1683       float duration = 1.0f;
1684       float delay = _delay;
1685       float repeat_delay = 0.5f;
1686
1687       int direction = _direction;
1688       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1689       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1690       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1691
1692       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1693       {
1694         animationMap.Clear();
1695         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1696         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1697         if(direction == 0)animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1698         else animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1699         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1700         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1701         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1702         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1703         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1704         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1705         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1706
1707         return animationMap;
1708       };
1709
1710       Vector2 start1(-0.5f, 0.5f);
1711       Vector2 end1  (0.5f, -0.5f);
1712       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1713       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1714       Vector2 rotate_center1(1.0f, 0.4f);
1715       float rotate_amount1 = 2.0f;
1716       float offset1 = 1.f;
1717
1718       Vector2 start2(-0.5f, -0.5f);
1719       Vector2 end2  (0.5f, 0.5f);
1720       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1721       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1722       Vector2 rotate_center2(1.0f, -0.4f);
1723       float rotate_amount2 = 1.0f;
1724       float offset2 = 3.f;
1725
1726       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1727       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1728       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REFLECT);
1729
1730       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1731       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1732       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1733       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1734       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1735       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1736       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1737
1738       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1739       DALI_TEST_CHECK( animatedGradientVisual );
1740
1741       Property::Map resultMap;
1742       animatedGradientVisual.CreatePropertyMap( resultMap );
1743
1744       // check the property values from the returned map from visual
1745       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1746       DALI_TEST_CHECK( value );
1747       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1748
1749       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1750       DALI_TEST_CHECK( value );
1751       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1752
1753       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1754       DALI_TEST_CHECK( value );
1755       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1756
1757       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1758       DALI_TEST_CHECK( value );
1759       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1760
1761       // If loop_count = 0, Animation doesn't created.
1762       // Optimized resultMap only have one value, which is target value
1763       // Note: target value will be changed by direction option.
1764       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1765       DALI_TEST_CHECK( value );
1766       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? start1 : start2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1767
1768       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1769       DALI_TEST_CHECK( value );
1770       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? end1 : end2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1771
1772       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1773       DALI_TEST_CHECK( value );
1774       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? start_color1 : start_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1775
1776       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1777       DALI_TEST_CHECK( value );
1778       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? end_color1 : end_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1779
1780       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1781       DALI_TEST_CHECK( value );
1782       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1783
1784       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1785       DALI_TEST_CHECK( value );
1786       DALI_TEST_EQUALS( value->Get<float>(), direction ? rotate_amount1 : rotate_amount2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1787
1788       value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1789       DALI_TEST_CHECK( value );
1790       DALI_TEST_EQUALS( value->Get<float>(), direction ? offset1 : offset2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1791     }
1792   }
1793
1794   END_TEST;
1795 }
1796
1797 int UtcDaliVisualAnimateBorderVisual01(void)
1798 {
1799   ToolkitTestApplication application;
1800   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1801
1802   static std::vector<UniformData> customUniforms =
1803   {
1804     UniformData("borderColor", Property::Type::VECTOR4),
1805     UniformData("mixColor", Property::Type::VECTOR3),
1806   };
1807
1808   TestGraphicsController& graphics = application.GetGraphicsController();
1809   graphics.AddCustomUniforms(customUniforms);
1810
1811   VisualFactory factory = VisualFactory::Get();
1812   Property::Map propertyMap;
1813   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1814   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1815   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1816   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1817   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1818
1819   Property::Map map;
1820   map["target"] = "testVisual";
1821   map["property"] = "mixColor";
1822   map["targetValue"] = Vector4(1,1,1,0.1);
1823   map["animator"] = Property::Map()
1824     .Add("alphaFunction", "LINEAR")
1825     .Add("timePeriod", Property::Map()
1826          .Add("delay", 0.0f)
1827          .Add("duration", 4.0f));
1828
1829   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1830
1831   DummyControl actor = DummyControl::New(true);
1832   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1833   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1834   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1835   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1836   application.GetScene().Add(actor);
1837
1838   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1839
1840   Renderer renderer = actor.GetRendererAt(0);
1841   Property::Index borderColorIndex = renderer.GetPropertyIndex( BorderVisual::Property::COLOR );
1842   Property::Index mixColorIndex = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1843
1844   Animation animation = dummyImpl.CreateTransition( transition );
1845
1846   // Animate the mix color through the transition, and the border color through
1847   // programmatic method.
1848   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1849   animation.Play();
1850
1851   application.SendNotification();
1852   application.Render(0);
1853   application.Render(2000u); // halfway point between blue and white
1854
1855   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1856   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1857   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1858   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1859
1860   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1861   testColor = Vector4( 1,1,1,0.45f );
1862   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1863   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1864
1865   Vector4 uColor;
1866   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1867   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1868
1869   application.Render(2000u);
1870
1871   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1872   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1873   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1874
1875   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1876   testColor = Vector4(1,1,1,0.1);
1877   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), TEST_LOCATION );
1878   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1879
1880   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1881   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1882
1883   END_TEST;
1884 }
1885
1886
1887 int UtcDaliVisualAnimateBorderVisual02(void)
1888 {
1889   ToolkitTestApplication application;
1890   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1891
1892   static std::vector<UniformData> customUniforms =
1893   {
1894     UniformData("borderSize", Property::Type::FLOAT),
1895   };
1896
1897   TestGraphicsController& graphics = application.GetGraphicsController();
1898   graphics.AddCustomUniforms(customUniforms);
1899
1900   VisualFactory factory = VisualFactory::Get();
1901   Property::Map propertyMap;
1902   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1903   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1904   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1905   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1906
1907   DummyControl actor = DummyControl::New(true);
1908   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1909   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1910   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1911   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1912   application.GetScene().Add(actor);
1913
1914   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1915
1916   Renderer renderer = actor.GetRendererAt(0);
1917   Property::Index index = renderer.GetPropertyIndex( BorderVisual::Property::SIZE );
1918
1919   Animation animation = Animation::New(4.0f);
1920   animation.AnimateTo( Property(renderer, index), 9.0f );
1921   animation.Play();
1922
1923   application.SendNotification();
1924   application.Render(0);
1925   application.Render(2000u); // halfway point
1926
1927   float size = renderer.GetCurrentProperty< float >( index );
1928   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1929   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1930
1931   application.Render(2000u); // halfway point between blue and white
1932
1933   size = renderer.GetCurrentProperty< float >( index );
1934   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1935   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1936
1937   END_TEST;
1938 }
1939
1940 int UtcDaliVisualAnimateColorVisual(void)
1941 {
1942   ToolkitTestApplication application;
1943   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1944
1945   static std::vector<UniformData> customUniforms =
1946   {
1947     UniformData("mixColor", Property::Type::VECTOR3),
1948   };
1949
1950   TestGraphicsController& graphics = application.GetGraphicsController();
1951   graphics.AddCustomUniforms(customUniforms);
1952
1953   VisualFactory factory = VisualFactory::Get();
1954   Property::Map propertyMap;
1955   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1956   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1957   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1958
1959   DummyControl actor = DummyControl::New(true);
1960   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1961   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1962   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1963   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1964   application.GetScene().Add(actor);
1965
1966   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1967
1968   Renderer renderer = actor.GetRendererAt(0);
1969   Property::Index mixColorIndex = renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1970
1971   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1972   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1973
1974   Animation animation = Animation::New(4.0f);
1975   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1976   animation.Play();
1977
1978   application.SendNotification();
1979   application.Render(0);
1980   application.Render(2000u); // halfway point
1981
1982   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1983   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1984   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1985
1986   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1987
1988   application.Render(2000u); // halfway point between blue and white
1989
1990   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1991   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1992
1993   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1994
1995   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1996   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1997
1998   END_TEST;
1999 }
2000
2001 int UtcDaliVisualAnimatePrimitiveVisual(void)
2002 {
2003   ToolkitTestApplication application;
2004   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
2005
2006   static std::vector<UniformData> customUniforms =
2007   {
2008     UniformData("mixColor", Property::Type::VECTOR3),
2009   };
2010
2011   TestGraphicsController& graphics = application.GetGraphicsController();
2012   graphics.AddCustomUniforms(customUniforms);
2013
2014   {
2015     VisualFactory factory = VisualFactory::Get();
2016     Property::Map propertyMap;
2017     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
2018     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2019     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2020     Visual::Base visual = factory.CreateVisual( propertyMap );
2021
2022     DummyControl actor = DummyControl::New(true);
2023     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2024     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2025     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2026     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2027     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2028     application.GetScene().Add(actor);
2029
2030     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2031
2032     Renderer renderer = actor.GetRendererAt(0);
2033     Property::Index index = renderer.GetPropertyIndex( PrimitiveVisual::Property::MIX_COLOR );
2034
2035     tet_infoline("Test that the renderer has the Primitive mix color");
2036     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2037
2038     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
2039     const Vector4 TARGET_MIX_COLOR( Color::RED );
2040
2041     Property::Map map;
2042     map["target"] = "testVisual";
2043     map["property"] = "mixColor";
2044     map["initialValue"] = INITIAL_MIX_COLOR;
2045     map["targetValue"] = TARGET_MIX_COLOR;
2046     map["animator"] = Property::Map()
2047       .Add("alphaFunction", "LINEAR")
2048       .Add("timePeriod", Property::Map()
2049            .Add("delay", 0.0f)
2050            .Add("duration", 4.0f));
2051
2052     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
2053
2054     Animation animation = dummyImpl.CreateTransition( transition );
2055     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
2056     animation.Play();
2057
2058     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2059     glAbstraction.EnableEnableDisableCallTrace( true );
2060     TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2061     std::ostringstream blendStr;
2062     blendStr << std::hex << GL_BLEND;
2063
2064     application.SendNotification();
2065     application.Render(0);
2066     application.Render(2000u); // halfway point
2067     application.SendNotification();
2068
2069     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
2070     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a )), true, TEST_LOCATION );
2071     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
2072
2073     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
2074
2075     glEnableStack.Reset();
2076
2077     application.Render(2001u); // go past end
2078     application.SendNotification(); // Trigger signals
2079
2080     DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
2081     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4( 1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a ) ), true, TEST_LOCATION );
2082     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
2083
2084     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
2085
2086     actor.Unparent();
2087   }
2088
2089   END_TEST;
2090 }
2091
2092 int UtcDaliVisualAnimatedGradientVisual01(void)
2093 {
2094   ToolkitTestApplication application;
2095   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
2096
2097   static std::vector<UniformData> customUniforms =
2098   {
2099     UniformData("start_point", Property::Type::VECTOR2),
2100     UniformData("end_point", Property::Type::VECTOR2),
2101     UniformData("start_color", Property::Type::VECTOR4),
2102     UniformData("end_color", Property::Type::VECTOR4),
2103     UniformData("rotate_center", Property::Type::VECTOR2),
2104     UniformData("rotate_angle", Property::Type::FLOAT),
2105     UniformData("gradient_offset", Property::Type::FLOAT),
2106   };
2107
2108   TestGraphicsController& graphics = application.GetGraphicsController();
2109   graphics.AddCustomUniforms(customUniforms);
2110
2111   {
2112     VisualFactory factory = VisualFactory::Get();
2113     Property::Map propertyMap;
2114     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2115     Visual::Base visual = factory.CreateVisual( propertyMap );
2116
2117     DummyControl actor = DummyControl::New(true);
2118     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2119     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2120     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2121     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2122     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2123     application.GetScene().Add(actor);
2124
2125     application.SendNotification();
2126     application.Render(0);
2127     application.SendNotification();
2128
2129     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2130
2131     for(int step_iter = 0; step_iter < 3; step_iter++)
2132     {
2133       application.SendNotification();
2134       application.Render(0);
2135       application.Render(750u); // step i/4
2136       application.SendNotification();
2137
2138       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
2139       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
2140       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2141       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2142       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
2143       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
2144       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
2145     }
2146
2147     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2148     application.Render(750u); // go to end
2149     application.SendNotification();
2150
2151     application.Render(10u); // finish
2152     application.SendNotification();
2153
2154     actor.Unparent();
2155     application.SendNotification();
2156     application.Render(0u);
2157     application.SendNotification();
2158   }
2159
2160   END_TEST;
2161 }
2162
2163 int UtcDaliVisualAnimatedGradientVisual02(void)
2164 {
2165   ToolkitTestApplication application;
2166   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
2167
2168   static std::vector<UniformData> customUniforms =
2169   {
2170     UniformData("start_point", Property::Type::VECTOR2),
2171     UniformData("end_point", Property::Type::VECTOR2),
2172     UniformData("start_color", Property::Type::VECTOR4),
2173     UniformData("end_color", Property::Type::VECTOR4),
2174     UniformData("rotate_center", Property::Type::VECTOR2),
2175     UniformData("rotate_angle", Property::Type::FLOAT),
2176     UniformData("gradient_offset", Property::Type::FLOAT),
2177   };
2178
2179   TestGraphicsController& graphics = application.GetGraphicsController();
2180   graphics.AddCustomUniforms(customUniforms);
2181
2182   {
2183     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
2184     int _direction[2] = {0, 1};
2185     int _loop_count[3] = {-1, 0, 1};
2186     int _motion[2] = {0, 1};
2187     int _easing[4] = {0, 1, 2, 3};
2188
2189     int test_case_max = 4 * 2 * 3 * 2 * 4;
2190     int test_case = 0;
2191     int test_case_d = 7; // 7 is the number of animated properties.
2192
2193     float _duration = 0.4f;
2194     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2195     float noise_maker = 0.0f;
2196     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2197     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2198     {
2199       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2200
2201       VisualFactory factory = VisualFactory::Get();
2202       Property::Map propertyMap;
2203       Property::Map animationMap;
2204       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2205
2206       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2207       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2208       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2209
2210       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&
2211       {
2212         int tc = (test_case + tc_offset);
2213         int idx_easing = tc % 4; tc /= 4;
2214         int idx_motion = tc % 2; tc /= 2;
2215         int idx_loop_count = tc % 3; tc /= 3;
2216         int idx_direction = tc % 2; tc /= 2;
2217         int idx_delay = tc % 4; tc /= 4;
2218
2219         float duration = _duration - _repeat_delay;
2220         float repeat_delay = _repeat_delay;
2221         float delay = _delay[idx_delay] * _duration;
2222         int direction = _direction[idx_direction];
2223         int loop_count = _loop_count[idx_loop_count];
2224         int motion = _motion[idx_motion];
2225         int easing = _easing[idx_easing];
2226
2227         animationMap.Clear();
2228         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
2229         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
2230         if( direction == 0 )
2231         {
2232           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2233         }
2234         else
2235         {
2236           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2237         }
2238         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2239         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2240         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2241         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2242         if( motion == 0 )
2243         {
2244           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2245         }
2246         else
2247         {
2248           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2249         }
2250         if( easing == 0 )
2251         {
2252           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2253         }
2254         else if( easing == 1 )
2255         {
2256           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2257         }
2258         else if( easing == 2 )
2259         {
2260           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2261         }
2262         else
2263         {
2264           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2265         }
2266
2267         return animationMap;
2268       };
2269
2270       // Give different values for debuging
2271       noise_maker += 1.0f;
2272       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2273       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2274       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2275       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2276       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2277       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2278       float offset1 = 0.f + noise_maker * 0.1f;
2279
2280       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2281       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2282       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2283       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2284       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2285       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2286       float offset2 = 2.f + noise_maker * 0.1f;
2287
2288       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2289       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2290       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2291
2292       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2293       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2294       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2295       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2296       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2297       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2298       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2299
2300       Visual::Base visual = factory.CreateVisual( propertyMap );
2301
2302       DummyControl actor = DummyControl::New( true );
2303       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2304       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2305       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2306       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2307       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2308       application.GetScene().Add(actor);
2309
2310       application.SendNotification();
2311       application.Render( 0 );
2312       application.SendNotification();
2313
2314       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2315
2316       application.SendNotification();
2317
2318       //Compare between CPU calculated value and Shader Visual calculated value
2319       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
2320       {
2321         int tc = (test_case + tc_offset);
2322         int idx_easing = tc % 4; tc /= 4;
2323         int idx_motion = tc % 2; tc /= 2;
2324         int idx_loop_count = tc % 3; tc /= 3;
2325         int idx_direction = tc % 2; tc /= 2;
2326         int idx_delay = tc % 4; tc /= 4;
2327
2328         float duration = _duration - _repeat_delay;
2329         float repeat_delay = _repeat_delay;
2330         float delay = _delay[idx_delay] * _duration;
2331         int direction = _direction[idx_direction];
2332         int loop_count = _loop_count[idx_loop_count];
2333         int motion = _motion[idx_motion];
2334         int easing = _easing[idx_easing];
2335
2336         progress -= delay / _duration;
2337
2338         Property::Value s = start;
2339         Property::Value t = target;
2340         if( direction == 1 )
2341         {
2342           s = target;
2343           t = start;
2344         }
2345         float x; ///< Animator progress value
2346         if( loop_count == 0 )
2347         {
2348           x = 1.0f;
2349         }
2350         else if( loop_count > 0 && progress + 0.01f > loop_count )
2351         {
2352           x = ( motion == 0 ) ? 1.0f : 0.0f;
2353         }
2354         else
2355         {
2356           if( progress < 0.0f )
2357           {
2358             progress = 0.0f;
2359           }
2360           progress = fmodf( progress, 1.0f );
2361           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2362
2363           x = progress;
2364           if( motion == 1 )
2365           {
2366             x = progress * 2.0f;
2367             if( x > 1.0f )
2368             {
2369               x = 2.0f - x;
2370             }
2371           }
2372
2373           if( easing == 1 ) // EASE_IN
2374           {
2375             x = x*x;
2376           }
2377           else if( easing == 2 ) // EASE_OUT
2378           {
2379             x = 2.0f*x - x*x;
2380           }
2381           else if( easing == 3 ) // EASE_IN_OUT
2382           {
2383             x = x * x * (3.0f - 2.0f * x);
2384           }
2385         }
2386         if( value_type == 0 ) // result type is Float
2387         {
2388           float res;
2389           float cur;
2390           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2391           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2392           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2393         }
2394         else if( value_type == 1 ) // result type is Vector2
2395         {
2396           Vector2 res;
2397           Vector2 cur;
2398           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2399           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2400           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2401         }
2402         else if( value_type == 2 ) // result type is Vector3
2403         {
2404           Vector3 res;
2405           Vector3 cur;
2406           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2407           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2408           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2409         }
2410         else // result type is Vector4
2411         {
2412           Vector4 res;
2413           Vector4 cur;
2414           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2415           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2416           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2417         }
2418       };
2419
2420       float step = 0.0f;
2421       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2422       {
2423         for( int step_iter = 0; step_iter < 3; step_iter++ )
2424         {
2425           application.SendNotification();
2426           application.Render( _duration * 250.f );  // step i/4
2427           application.SendNotification();
2428           step += 0.25f;
2429
2430           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2431           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2432           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2433           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2434           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2435           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2436           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2437         }
2438         application.SendNotification();
2439         application.Render(_duration * 250.f);  // step 4/4 will not test
2440         application.SendNotification();
2441         step += 0.25f;
2442       }
2443
2444       application.SendNotification();
2445       actor.Unparent();
2446       application.SendNotification();
2447       application.Render(10.f);  // tempral time
2448       application.SendNotification();
2449     }
2450   }
2451
2452   END_TEST;
2453 }
2454
2455 int UtcDaliVisualAnimatedGradientVisual03(void)
2456 {
2457   ToolkitTestApplication application;
2458   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2459
2460   static std::vector<UniformData> customUniforms =
2461   {
2462     UniformData("start_point", Property::Type::VECTOR2),
2463     UniformData("end_point", Property::Type::VECTOR2),
2464     UniformData("start_color", Property::Type::VECTOR4),
2465     UniformData("end_color", Property::Type::VECTOR4),
2466     UniformData("rotate_center", Property::Type::VECTOR2),
2467     UniformData("rotate_angle", Property::Type::FLOAT),
2468     UniformData("gradient_offset", Property::Type::FLOAT),
2469   };
2470
2471   TestGraphicsController& graphics = application.GetGraphicsController();
2472   graphics.AddCustomUniforms(customUniforms);
2473
2474   {
2475     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
2476     int _direction[2] = {0, 1};
2477     int _loop_count[3] = {-1, 0, 1};
2478     int _motion[2] = {0, 1};
2479     int _easing[4] = {0, 1, 2, 3};
2480
2481     int test_case_max = 4 * 2 * 3 * 2 * 4;
2482     int test_case = 0;
2483     int test_case_d = 7; // 7 is the number of animated properties.
2484
2485     float _duration = 0.4f;
2486     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2487     float noise_maker = 0.2f;
2488     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2489     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2490     {
2491       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2492
2493       VisualFactory factory = VisualFactory::Get();
2494       Property::Map propertyMap;
2495       Property::Map animationMap;
2496       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2497
2498       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&
2499       {
2500         int tc = (test_case + tc_offset);
2501         int idx_easing = tc % 4; tc /= 4;
2502         int idx_motion = tc % 2; tc /= 2;
2503         int idx_loop_count = tc % 3; tc /= 3;
2504         int idx_direction = tc % 2; tc /= 2;
2505         int idx_delay = tc % 4; tc /= 4;
2506
2507         float duration = _duration - _repeat_delay;
2508         float repeat_delay = _repeat_delay;
2509         float delay = _delay[idx_delay] * _duration;
2510         int direction = _direction[idx_direction];
2511         int loop_count = _loop_count[idx_loop_count];
2512         int motion = _motion[idx_motion];
2513         int easing = _easing[idx_easing];
2514
2515         animationMap.Clear();
2516         animationMap.Insert( "startValue", start );
2517         animationMap.Insert( "targetValue", target );
2518         if( direction == 0 )
2519         {
2520           animationMap.Insert("directionType", "FORWARD");
2521         }
2522         else
2523         {
2524           animationMap.Insert("directionType", "BACKWARD");
2525         }
2526         animationMap.Insert("duration", duration);
2527         animationMap.Insert("delay", delay);
2528         animationMap.Insert("repeat", loop_count);
2529         animationMap.Insert("repeatDelay", repeat_delay);
2530         if( motion == 0 )
2531         {
2532           animationMap.Insert("motionType", "LOOP");
2533         }
2534         else
2535         {
2536           animationMap.Insert("motionType", "MIRROR");
2537         }
2538         if( easing == 0 )
2539         {
2540           animationMap.Insert("easingType", "LINEAR");
2541         }
2542         else if( easing == 1 )
2543         {
2544           animationMap.Insert("easingType", "IN");
2545         }
2546         else if( easing == 2 )
2547         {
2548           animationMap.Insert("easingType", "OUT");
2549         }
2550         else
2551         {
2552           animationMap.Insert("easingType", "IN_OUT");
2553         }
2554
2555         return animationMap;
2556       };
2557
2558       // Give different values for debuging
2559       noise_maker += 0.8f;
2560       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2561       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2562       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2563       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2564       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2565       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2566       float offset1 = 0.f + noise_maker * 0.1f;
2567
2568       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2569       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2570       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2571       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2572       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2573       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2574       float offset2 = 2.f + noise_maker * 0.1f;
2575
2576       propertyMap.Insert("gradientType", "LINEAR");
2577       propertyMap.Insert("unitType",     "USER_SPACE");
2578       propertyMap.Insert("spreadType",   "CLAMP");
2579
2580       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2581       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2582       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2583       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2584       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2585       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2586       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2587
2588       Visual::Base visual = factory.CreateVisual( propertyMap );
2589
2590       DummyControl actor = DummyControl::New( true );
2591       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2592       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2593       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2594       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2595       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2596       application.GetScene().Add(actor);
2597
2598       application.SendNotification();
2599       application.Render( 0 );
2600       application.SendNotification();
2601
2602       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2603
2604       application.SendNotification();
2605
2606       //Compare between CPU calculated value and Shader Visual calculated value
2607       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
2608       {
2609         int tc = (test_case + tc_offset);
2610         int idx_easing = tc % 4; tc /= 4;
2611         int idx_motion = tc % 2; tc /= 2;
2612         int idx_loop_count = tc % 3; tc /= 3;
2613         int idx_direction = tc % 2; tc /= 2;
2614         int idx_delay = tc % 4; tc /= 4;
2615
2616         float duration = _duration - _repeat_delay;
2617         float repeat_delay = _repeat_delay;
2618         float delay = _delay[idx_delay] * _duration;
2619         int direction = _direction[idx_direction];
2620         int loop_count = _loop_count[idx_loop_count];
2621         int motion = _motion[idx_motion];
2622         int easing = _easing[idx_easing];
2623
2624         progress -= delay / _duration;
2625
2626         Property::Value s = start;
2627         Property::Value t = target;
2628         if( direction == 1 )
2629         {
2630           s = target;
2631           t = start;
2632         }
2633         float x; ///< Animator progress value
2634         if( loop_count == 0 )
2635         {
2636           x = 1.0f;
2637         }
2638         else if( loop_count > 0 && progress + 0.01f > loop_count )
2639         {
2640           x = ( motion == 0 ) ? 1.0f : 0.0f;
2641         }
2642         else
2643         {
2644           if( progress < 0.0f )
2645           {
2646             progress = 0.0f;
2647           }
2648           progress = fmodf( progress, 1.0f );
2649           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2650
2651           x = progress;
2652           if( motion == 1 )
2653           {
2654             x = progress * 2.0f;
2655             if( x > 1.0f )
2656             {
2657               x = 2.0f - x;
2658             }
2659           }
2660
2661           if( easing == 1 ) // EASE_IN
2662           {
2663             x = x*x;
2664           }
2665           else if( easing == 2 ) // EASE_OUT
2666           {
2667             x = 2.0f*x - x*x;
2668           }
2669           else if( easing == 3 ) // EASE_IN_OUT
2670           {
2671             x = x * x * (3.0f - 2.0f * x);
2672           }
2673         }
2674         if( value_type == 0 ) // result type is Float
2675         {
2676           float res;
2677           float cur;
2678           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2679           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2680           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2681         }
2682         else if( value_type == 1 ) // result type is Vector2
2683         {
2684           Vector2 res;
2685           Vector2 cur;
2686           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2687           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2688           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2689         }
2690         else if( value_type == 2 ) // result type is Vector3
2691         {
2692           Vector3 res;
2693           Vector3 cur;
2694           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2695           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2696           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2697         }
2698         else // result type is Vector4
2699         {
2700           Vector4 res;
2701           Vector4 cur;
2702           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2703           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2704           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2705         }
2706       };
2707
2708       float step = 0.0f;
2709       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2710       {
2711         for( int step_iter = 0; step_iter < 3; step_iter++ )
2712         {
2713           application.SendNotification();
2714           application.Render( _duration * 250.f );  // step i/4
2715           application.SendNotification();
2716           step += 0.25f;
2717
2718           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2719           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2720           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2721           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2722           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2723           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2724           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2725         }
2726         application.SendNotification();
2727         application.Render(_duration * 250.f);  // step 4/4 will not test
2728         application.SendNotification();
2729         step += 0.25f;
2730       }
2731
2732       application.SendNotification();
2733       actor.Unparent();
2734       application.SendNotification();
2735       application.Render(10.f);  // tempral time
2736       application.SendNotification();
2737     }
2738   }
2739
2740   END_TEST;
2741 }
2742
2743 int UtcDaliVisualWireframeVisual(void)
2744 {
2745   ToolkitTestApplication application;
2746
2747   VisualFactory factory = VisualFactory::Get();
2748   Property::Map propertyMap;
2749   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2750
2751   // Create the visual.
2752   Visual::Base visual = factory.CreateVisual( propertyMap );
2753
2754   DALI_TEST_CHECK( visual );
2755
2756   Property::Map resultMap;
2757   visual.CreatePropertyMap( resultMap );
2758
2759   // Check the property values from the returned map from visual
2760   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2761   DALI_TEST_CHECK( value );
2762   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2763
2764   END_TEST;
2765 }
2766
2767 int UtcDaliVisualGetTransform(void)
2768 {
2769   ToolkitTestApplication application;
2770   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2771
2772   VisualFactory factory = VisualFactory::Get();
2773   Property::Map propertyMap;
2774   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2775   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2776   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2777
2778   Dali::Property::Map visualMap;
2779   colorVisual.CreatePropertyMap( visualMap );
2780   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2781   Dali::Property::Map* map = value->GetMap();
2782   DALI_TEST_CHECK( map );
2783
2784   //Test default values
2785   {
2786     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2787     DALI_TEST_CHECK( typeValue );
2788     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2789   }
2790   {
2791     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2792     DALI_TEST_CHECK( typeValue );
2793     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2794   }
2795   {
2796     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2797     DALI_TEST_CHECK( typeValue );
2798     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2799   }
2800   {
2801     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2802     DALI_TEST_CHECK( typeValue );
2803     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2804   }
2805   {
2806     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2807     DALI_TEST_CHECK( typeValue );
2808     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2809   }
2810   {
2811     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2812     DALI_TEST_CHECK( typeValue );
2813     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2814   }
2815   {
2816     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2817     DALI_TEST_CHECK( typeValue );
2818     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2819   }
2820
2821   END_TEST;
2822 }
2823
2824 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2825 {
2826   Property::Map transform;
2827   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2828   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2829   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2830   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2831   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2832   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f) );
2833
2834   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2835
2836   Dali::Property::Map visualMap;
2837   visual.CreatePropertyMap( visualMap );
2838   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2839   Dali::Property::Map* map = value->GetMap();
2840   DALI_TEST_CHECK( map );
2841
2842   {
2843     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2844     DALI_TEST_CHECK( typeValue );
2845     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2846   }
2847   {
2848     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2849     DALI_TEST_CHECK( typeValue );
2850     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2851   }
2852   {
2853     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2854     DALI_TEST_CHECK( typeValue );
2855     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2856   }
2857   {
2858     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2859     DALI_TEST_CHECK( typeValue );
2860     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2861   }
2862   {
2863     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2864     DALI_TEST_CHECK( typeValue );
2865     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2866   }
2867   {
2868     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2869     DALI_TEST_CHECK( typeValue );
2870     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2871   }
2872   {
2873     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2874     DALI_TEST_CHECK( typeValue );
2875     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(50.0f,50.0f), TEST_LOCATION );
2876   }
2877
2878   //Put the visual on the stage
2879   DummyControl actor = DummyControl::New(true);
2880   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2881   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2882   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2883   application.GetScene().Add(actor);
2884
2885   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2886   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2887
2888   application.SendNotification();
2889   application.Render(0);
2890   Renderer renderer( actor.GetRendererAt(0) );
2891
2892   //Check that the properties have been registered on the Renderer
2893   Property::Index index = renderer.GetPropertyIndex( "offset" );
2894   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2895   Vector2 offset = renderer.GetProperty<Vector2>( index );
2896   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2897
2898   index = renderer.GetPropertyIndex( "size" );
2899   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2900   Vector2 size = renderer.GetProperty<Vector2>( index );
2901   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2902
2903   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2904   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2905   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2906   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2907
2908   index = renderer.GetPropertyIndex( "origin" );
2909   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2910   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2911   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2912
2913   index = renderer.GetPropertyIndex( "anchorPoint" );
2914   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2915   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2916   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2917
2918   index = renderer.GetPropertyIndex( "extraSize" );
2919   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2920   Vector2 extraSize = renderer.GetProperty<Vector2>( index );
2921   DALI_TEST_EQUALS( extraSize, Vector2(50.0f,50.0f), TEST_LOCATION );
2922
2923   //Set a new transform
2924   transform.Clear();
2925   transform = DefaultTransform();
2926   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2927   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2928   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2929   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f) );
2930   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2931   application.SendNotification();
2932   application.Render(0);
2933
2934   //Check that the values have changed in the renderer
2935   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2936   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2937
2938   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2939   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2940
2941   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2942   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2943
2944   //Parent origin and anchor point should have the default values
2945   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2946   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2947
2948   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2949   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2950
2951   extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
2952   DALI_TEST_EQUALS( extraSize, Vector2(0.5f,0.5f), TEST_LOCATION );
2953 }
2954
2955 int UtcDaliVisualSetTransform01(void)
2956 {
2957   ToolkitTestApplication application;
2958   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2959
2960   VisualFactory factory = VisualFactory::Get();
2961   Property::Map propertyMap;
2962   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2963   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2964   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2965   Visual::Base visual = factory.CreateVisual( propertyMap );
2966   TestTransform( application, visual );
2967   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2968
2969   END_TEST;
2970 }
2971
2972 int UtcDaliVisualSetTransform0(void)
2973 {
2974   ToolkitTestApplication application;
2975   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2976
2977   VisualFactory factory = VisualFactory::Get();
2978   Property::Map propertyMap;
2979   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2980   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2981   Visual::Base visual = factory.CreateVisual( propertyMap );
2982   TestTransform( application, visual );
2983   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2984
2985   END_TEST;
2986 }
2987
2988 int UtcDaliVisualSetTransform1(void)
2989 {
2990   ToolkitTestApplication application;
2991   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2992
2993   VisualFactory factory = VisualFactory::Get();
2994   Property::Map propertyMap;
2995   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2996   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2997   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2998   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2999   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
3000   Visual::Base visual = factory.CreateVisual( propertyMap );
3001   TestTransform( application, visual );
3002   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
3003
3004   END_TEST;
3005 }
3006
3007 int UtcDaliVisualSetTransform2(void)
3008 {
3009   ToolkitTestApplication application;
3010   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
3011
3012   VisualFactory factory = VisualFactory::Get();
3013   Property::Map propertyMap;
3014   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
3015   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
3016
3017   Property::Array stopOffsets;
3018   stopOffsets.PushBack( 0.0f );
3019   stopOffsets.PushBack( 0.3f );
3020   stopOffsets.PushBack( 0.6f );
3021   stopOffsets.PushBack( 0.8f );
3022   stopOffsets.PushBack( 1.0f );
3023   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
3024
3025   Property::Array stopColors;
3026   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
3027   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
3028   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
3029   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
3030   stopColors.PushBack( Color::YELLOW );
3031   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
3032   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
3033   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
3034   Visual::Base visual = factory.CreateVisual( propertyMap );
3035   TestTransform( application, visual );
3036   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
3037
3038   END_TEST;
3039 }
3040
3041 int UtcDaliVisualSetTransform3(void)
3042 {
3043   ToolkitTestApplication application;
3044   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
3045
3046   VisualFactory factory = VisualFactory::Get();
3047   Property::Map propertyMap;
3048   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
3049   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
3050   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
3051   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
3052   Visual::Base visual = factory.CreateVisual( propertyMap );
3053   TestTransform( application, visual );
3054   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
3055
3056   END_TEST;
3057 }
3058
3059 int UtcDaliVisualSetTransform4(void)
3060 {
3061   ToolkitTestApplication application;
3062   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
3063
3064   VisualFactory factory = VisualFactory::Get();
3065   Property::Map propertyMap;
3066   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
3067   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
3068
3069   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
3070   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
3071   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
3072   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
3073   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
3074   Visual::Base visual = factory.CreateVisual( propertyMap );
3075   TestTransform( application, visual );
3076   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
3077
3078   END_TEST;
3079 }
3080
3081 int UtcDaliVisualSetTransform5(void)
3082 {
3083   ToolkitTestApplication application;
3084   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
3085
3086   VisualFactory factory = VisualFactory::Get();
3087   Property::Map propertyMap;
3088   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3089   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3090   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3091   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3092   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3093   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3094   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3095   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3096   Visual::Base visual = factory.CreateVisual(propertyMap);
3097   TestTransform( application, visual );
3098   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
3099
3100   END_TEST;
3101 }
3102
3103 int UtcDaliVisualSetTransform6(void)
3104 {
3105   ToolkitTestApplication application;
3106   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
3107
3108   VisualFactory factory = VisualFactory::Get();
3109   Property::Map propertyMap;
3110   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3111   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3112   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3113   Visual::Base visual = factory.CreateVisual(propertyMap);
3114   TestTransform( application, visual );
3115   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
3116
3117   END_TEST;
3118 }
3119
3120 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3121 {
3122   ToolkitTestApplication application;
3123   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
3124
3125   VisualFactory factory = VisualFactory::Get();
3126   Property::Map propertyMap;
3127   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3128   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3129   Visual::Base visual = factory.CreateVisual( propertyMap );
3130
3131   Property::Map transform;
3132   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
3133                                                  .Add( "RELATIVE" );
3134   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
3135                                                  .Add( "ABSOLUTE" );
3136   visual.SetTransformAndSize( transform, Vector2(100, 100) );
3137
3138   Dali::Property::Map visualMap;
3139   visual.CreatePropertyMap( visualMap );
3140   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
3141   Dali::Property::Map* map = value->GetMap();
3142   DALI_TEST_CHECK( map );
3143
3144   {
3145     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
3146     DALI_TEST_CHECK( typeValue );
3147     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
3148   }
3149   {
3150     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
3151     DALI_TEST_CHECK( typeValue );
3152     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
3153   }
3154
3155   END_TEST;
3156 }
3157
3158 int UtcDaliNPatchVisualCustomShader(void)
3159 {
3160   ToolkitTestApplication application;
3161   tet_infoline( "NPatchVisual with custom shader" );
3162
3163   VisualFactory factory = VisualFactory::Get();
3164   Property::Map properties;
3165   Property::Map shader;
3166   const std::string vertexShader = "Foobar";
3167   const std::string fragmentShader = "Foobar";
3168   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3169   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3170
3171   Property::Map transformMap;
3172   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
3173   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
3174   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
3175   transformMap["anchorPoint"] = Align::CENTER;
3176   transformMap["origin"] = Align::CENTER;
3177   transformMap["extraSize"] = Vector2( 0.0f, 50.0f );
3178   properties[Visual::Property::TRANSFORM] = transformMap;
3179
3180   properties[Visual::Property::TYPE] = Visual::IMAGE;
3181   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3182   properties[Visual::Property::SHADER]=shader;
3183   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3184   properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3185
3186   Visual::Base visual = factory.CreateVisual( properties );
3187   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
3188
3189   // trigger creation through setting on stage
3190   DummyControl dummy = DummyControl::New(true);
3191   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3192   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3193   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
3194   dummy.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
3195   dummy.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
3196   application.GetScene().Add(dummy);
3197   application.SendNotification();
3198
3199   Renderer renderer = dummy.GetRendererAt( 0 );
3200   Shader shader2 = renderer.GetShader();
3201   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3202   Property::Map* map = value.GetMap();
3203   DALI_TEST_CHECK( map );
3204
3205   Property::Index index = renderer.GetPropertyIndex("size");
3206   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
3207
3208   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3209   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
3210
3211   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3212   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
3213
3214   Vector2 extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
3215   DALI_TEST_EQUALS( extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION );
3216
3217   END_TEST;
3218 }
3219
3220 int UtcDaliGradientVisualBlendMode(void)
3221 {
3222   ToolkitTestApplication application;
3223   VisualFactory factory = VisualFactory::Get();
3224
3225   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3226       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3227                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3228                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3229                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3230                                                                                   .Add( Color::GREEN ) ) );
3231
3232   Visual::Base alphaGradientVisual = factory.CreateVisual(
3233       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3234                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3235                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3236                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3237                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
3238
3239   DummyControl control = DummyControl::New(true);
3240   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3241   application.GetScene().Add( control );
3242
3243   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
3244   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
3245   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
3246
3247   application.SendNotification();
3248   application.Render();
3249
3250   // 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
3251   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
3252   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
3253   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
3254
3255   END_TEST;
3256 }
3257
3258 int UtcDaliVisualRendererRemovalAndReAddition(void)
3259 {
3260   ToolkitTestApplication application;
3261   tet_infoline( "UtcDaliVisualRendererRemoval" );
3262
3263   VisualFactory factory = VisualFactory::Get();
3264   Property::Map propertyMap;
3265   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3266   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3267   Visual::Base visual = factory.CreateVisual( propertyMap );
3268
3269   visual.SetDepthIndex( 1 );
3270
3271   DummyControl dummyControl = DummyControl::New(true);
3272   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3273   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3274   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3275
3276   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3277   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
3278
3279   application.GetScene().Add( dummyControl );
3280
3281   application.SendNotification();
3282   application.Render();
3283
3284   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3285
3286   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
3287   application.GetScene().Remove( dummyControl );
3288   application.SendNotification();
3289   application.Render();
3290
3291   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3292
3293   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
3294
3295   application.GetScene().Add( dummyControl );
3296
3297   application.SendNotification();
3298   application.Render();
3299
3300   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3301
3302   END_TEST;
3303 }
3304
3305
3306
3307 int UtcDaliVisualTextVisualRender(void)
3308 {
3309   ToolkitTestApplication application;
3310   tet_infoline( "UtcDaliVisualTextVisualRender" );
3311
3312   VisualFactory factory = VisualFactory::Get();
3313   Property::Map propertyMap;
3314   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3315   propertyMap.Insert( "mixColor", Color::WHITE );
3316   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3317   propertyMap.Insert( "enableMarkup", false );
3318   propertyMap.Insert( "text", "Hello world" );
3319   propertyMap.Insert( "fontFamily", "TizenSans" );
3320
3321   Property::Map fontStyleMapSet;
3322   fontStyleMapSet.Insert( "weight", "bold" );
3323   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3324
3325   propertyMap.Insert( "pointSize", 12.f );
3326   propertyMap.Insert( "multiLine", true );
3327   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3328   propertyMap.Insert( "verticalAlignment", "CENTER" );
3329   propertyMap.Insert( "textColor", Color::RED );
3330   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3331   textVisual.SetDepthIndex( 1 );
3332
3333   DummyControl dummyControl = DummyControl::New(true);
3334   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3335   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3336   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3337
3338   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3339   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3340
3341   application.GetScene().Add( dummyControl );
3342   application.SendNotification();
3343   application.Render();
3344
3345
3346   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3347   propertyMap.Clear();
3348   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3349   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3350   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3351   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3352
3353   Property::Map transformMap;
3354   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3355   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3356
3357   textVisual = factory.CreateVisual( propertyMap );
3358   textVisual.SetDepthIndex( 1 );
3359
3360   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3361   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 720.f, 640.f ) );
3362
3363   application.SendNotification(); // force process events to ensure text visual
3364   // adds renderer to the dummy control in OnRelayout
3365   application.Render();
3366
3367   Renderer renderer = dummyControl.GetRendererAt(0u);
3368   Property::Index index = renderer.GetPropertyIndex("size");
3369
3370   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3371   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3372
3373   END_TEST;
3374 }
3375
3376 int UtcDaliVisualTextVisualDisableEnable(void)
3377 {
3378   ToolkitTestApplication application;
3379   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3380
3381   VisualFactory factory = VisualFactory::Get();
3382   Property::Map propertyMap;
3383   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3384   propertyMap.Insert( "mixColor", Color::WHITE );
3385   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3386   propertyMap.Insert( "enableMarkup", false );
3387   propertyMap.Insert( "text", "Hello world" );
3388   propertyMap.Insert( "fontFamily", "TizenSans" );
3389
3390   Property::Map fontStyleMapSet;
3391   fontStyleMapSet.Insert( "weight", "bold" );
3392   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3393
3394   propertyMap.Insert( "pointSize", 12.f );
3395   propertyMap.Insert( "multiLine", true );
3396   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3397   propertyMap.Insert( "verticalAlignment", "CENTER" );
3398   propertyMap.Insert( "textColor", Color::RED );
3399   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3400   textVisual.SetDepthIndex( 1 );
3401
3402   DummyControl dummyControl = DummyControl::New(true);
3403   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3404   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3405   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3406
3407   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3408   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3409
3410   application.GetScene().Add( dummyControl );
3411   application.SendNotification();
3412   application.Render();
3413
3414   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3415
3416   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3417
3418   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3419
3420   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3421
3422   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3423
3424   END_TEST;
3425 }
3426
3427 int UtcDaliVisualPremultipliedAlpha(void)
3428 {
3429   ToolkitTestApplication application;
3430   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3431
3432   VisualFactory factory = VisualFactory::Get();
3433
3434   // image visual, test default value ( true )
3435   {
3436     Visual::Base imageVisual = factory.CreateVisual(
3437           Property::Map()
3438           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3439           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3440
3441     Dali::Property::Map visualMap;
3442     imageVisual.CreatePropertyMap( visualMap );
3443     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3444
3445     // test values
3446     DALI_TEST_CHECK( value );
3447     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3448   }
3449
3450   // image visual, override premultiplied
3451   {
3452     Visual::Base imageVisual = factory.CreateVisual(
3453           Property::Map()
3454           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3455           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3456           .Add( Visual::Property::PREMULTIPLIED_ALPHA, false ) );
3457
3458     Dali::Property::Map visualMap;
3459     imageVisual.CreatePropertyMap( visualMap );
3460     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3461
3462     // test values
3463     DALI_TEST_CHECK( value );
3464     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION);
3465   }
3466
3467   // svg visual ( premultiplied alpha by default is true )
3468   {
3469     Visual::Base imageVisual = factory.CreateVisual(
3470           Property::Map()
3471           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3472           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3473
3474     Dali::Property::Map visualMap;
3475     imageVisual.CreatePropertyMap( visualMap );
3476     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3477
3478     // test values
3479     DALI_TEST_CHECK( value );
3480     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3481   }
3482
3483   END_TEST;
3484 }
3485
3486 int UtcDaliRegisterVisualOrder(void)
3487 {
3488   ToolkitTestApplication application;
3489   tet_infoline( "Register Visual Order" );
3490
3491   DummyControl dummyControl = DummyControl::New(true);
3492   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3493
3494   VisualFactory factory = VisualFactory::Get();
3495   Property::Map propertyMap;
3496   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3497   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3498
3499   tet_infoline( "Register visual, should have depth index of 0.0f" );
3500   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3501   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3502   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3503
3504   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3505
3506   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3507   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3508   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3509
3510   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3511   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3512   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3513
3514   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3515   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3516   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3517
3518   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3519   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3520   labelVisual.SetDepthIndex( -2000 );
3521   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3522   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3523
3524   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3525   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3526   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3527   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3528   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3529   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3530
3531   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3532   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3533   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3534   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3535   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3536
3537   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3538   application.GetScene().Add( dummyControl );
3539
3540   END_TEST;
3541 }
3542
3543 int UtcDaliRegisterVisualOrder02(void)
3544 {
3545   ToolkitTestApplication application;
3546   tet_infoline( "Register Visual Order with Background Set" );
3547
3548   DummyControl dummyControl = DummyControl::New(true);
3549   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3550
3551   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3552
3553   VisualFactory factory = VisualFactory::Get();
3554   Property::Map propertyMap;
3555   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3556   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3557
3558   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3559
3560   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3561
3562   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3563   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3564   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3565   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3566   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3567
3568   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3569   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3570   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3571   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3572
3573   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3574   application.GetScene().Add( dummyControl );
3575
3576   END_TEST;
3577 }
3578
3579 int UtcDaliRegisterVisualWithDepthIndex(void)
3580 {
3581   ToolkitTestApplication application;
3582   tet_infoline( "Register a Visual With Depth Index" );
3583
3584   DummyControl dummyControl = DummyControl::New(true);
3585   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3586
3587   VisualFactory factory = VisualFactory::Get();
3588   Property::Map propertyMap;
3589   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3590   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3591
3592   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3593   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3594   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3595   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3596   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3597
3598   tet_infoline( "Register another visual with a depth index and it disabled" );
3599   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3600   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3601   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3602   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3603
3604   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3605   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3606   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3607   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3608   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3609
3610   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3611   application.GetScene().Add( dummyControl );
3612
3613   END_TEST;
3614 }
3615
3616 int UtcDaliSvgVisualCustomShader(void)
3617 {
3618   ToolkitTestApplication application;
3619   tet_infoline( "SvgVisual with custom shader" );
3620
3621   VisualFactory factory = VisualFactory::Get();
3622   Property::Map properties;
3623   Property::Map shader;
3624   const std::string vertexShader = "Foobar";
3625   const std::string fragmentShader = "Foobar";
3626   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3627   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3628
3629   properties[Visual::Property::TYPE] = Visual::IMAGE;
3630   properties[Visual::Property::SHADER] = shader;
3631   properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3632
3633   Visual::Base visual = factory.CreateVisual( properties );
3634
3635   // trigger creation through setting on stage
3636   DummyControl dummy = DummyControl::New( true );
3637   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3638   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3639
3640   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3641   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3642   application.GetScene().Add( dummy );
3643
3644   application.SendNotification();
3645   application.Render();
3646
3647   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3648
3649   Renderer renderer = dummy.GetRendererAt( 0 );
3650   Shader shader2 = renderer.GetShader();
3651   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3652   Property::Map* map = value.GetMap();
3653   DALI_TEST_CHECK( map );
3654
3655   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3656   DALI_TEST_EQUALS( fragmentShader, fragment->Get< std::string >(), TEST_LOCATION );
3657
3658   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3659   DALI_TEST_EQUALS( vertexShader, vertex->Get< std::string >(), TEST_LOCATION );
3660
3661   END_TEST;
3662 }
3663
3664 int UtcDaliVisualRoundedCorner(void)
3665 {
3666   ToolkitTestApplication application;
3667   tet_infoline( "UtcDaliVisualRoundedCorner" );
3668
3669   static std::vector<UniformData> customUniforms =
3670   {
3671     UniformData("cornerRadius", Property::Type::VECTOR4),
3672     UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3673   };
3674
3675   TestGraphicsController& graphics = application.GetGraphicsController();
3676   graphics.AddCustomUniforms(customUniforms);
3677
3678   // image visual
3679   {
3680     VisualFactory factory = VisualFactory::Get();
3681     Property::Map properties;
3682     float cornerRadius = 30.0f;
3683
3684     properties[Visual::Property::TYPE] = Visual::IMAGE;
3685     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3686     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3687
3688     Visual::Base visual = factory.CreateVisual( properties );
3689
3690     // trigger creation through setting on stage
3691     DummyControl dummy = DummyControl::New( true );
3692     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3693     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3694
3695     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3696     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3697     application.GetScene().Add( dummy );
3698
3699     application.SendNotification();
3700     application.Render();
3701
3702     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3703
3704     application.SendNotification();
3705     application.Render();
3706
3707     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3708     // Default corner radius policy is absolute.
3709     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3710   }
3711
3712   // color visual 1
3713   {
3714     VisualFactory factory = VisualFactory::Get();
3715     Property::Map properties;
3716     float cornerRadius = 30.0f;
3717
3718     properties[Visual::Property::TYPE] = Visual::COLOR;
3719     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3720     properties["cornerRadius"] = cornerRadius;
3721     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3722
3723     Visual::Base visual = factory.CreateVisual( properties );
3724
3725     // trigger creation through setting on stage
3726     DummyControl dummy = DummyControl::New( true );
3727     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3728     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3729
3730     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3731     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3732     application.GetScene().Add( dummy );
3733
3734     application.SendNotification();
3735     application.Render();
3736
3737     application.SendNotification();
3738     application.Render();
3739
3740 #ifdef OLD_GRAPHICS_TEST
3741     // Currently test with multiple program doesn't work well. will fix another day
3742     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3743     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3744 #endif
3745   }
3746
3747   // color visual 2
3748   {
3749     VisualFactory factory = VisualFactory::Get();
3750     Property::Map properties;
3751     Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3752
3753     properties[Visual::Property::TYPE] = Visual::COLOR;
3754     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3755     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3756     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3757
3758     Visual::Base visual = factory.CreateVisual( properties );
3759
3760     // trigger creation through setting on stage
3761     DummyControl dummy = DummyControl::New( true );
3762     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3763     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3764
3765     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3766     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3767     application.GetScene().Add( dummy );
3768
3769     application.SendNotification();
3770     application.Render();
3771
3772     application.SendNotification();
3773     application.Render();
3774
3775 #ifdef OLD_GRAPHICS_TEST
3776     // Currently test with multiple program doesn't work well. will fix another day
3777     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3778     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3779 #endif
3780   }
3781
3782   // color visual 3 - invalid value
3783   {
3784     VisualFactory factory = VisualFactory::Get();
3785     Property::Map properties;
3786     Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3787
3788     properties[Visual::Property::TYPE] = Visual::COLOR;
3789     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3790     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3791     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3792
3793     Visual::Base visual = factory.CreateVisual( properties );
3794
3795     // trigger creation through setting on stage
3796     DummyControl dummy = DummyControl::New( true );
3797     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3798     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3799
3800     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3801     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3802     application.GetScene().Add( dummy );
3803
3804     application.SendNotification();
3805     application.Render();
3806
3807     application.SendNotification();
3808     application.Render();
3809
3810 #ifdef OLD_GRAPHICS_TEST
3811     // Currently test with multiple program doesn't work well. will fix another day
3812     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3813     // Default corner radius policy is absolute.
3814     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3815 #endif
3816   }
3817
3818   // gradient visual
3819   {
3820     VisualFactory factory = VisualFactory::Get();
3821     Property::Map properties;
3822     float cornerRadius = 30.0f;
3823
3824     properties[Visual::Property::TYPE] = Visual::GRADIENT;
3825     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3826     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3827     properties[GradientVisual::Property::START_POSITION] = Vector2( 0.5f, 0.5f );
3828     properties[GradientVisual::Property::END_POSITION] = Vector2( -0.5f, -0.5f );
3829     properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3830
3831     Property::Array stopOffsets;
3832     stopOffsets.PushBack( 0.0f );
3833     stopOffsets.PushBack( 0.6f );
3834     stopOffsets.PushBack( 1.0f );
3835     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3836
3837     Property::Array stopColors;
3838     stopColors.PushBack( Color::RED );
3839     stopColors.PushBack( Color::YELLOW );
3840     stopColors.PushBack( Color::GREEN );
3841     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3842
3843     Visual::Base visual = factory.CreateVisual( properties );
3844
3845     // trigger creation through setting on stage
3846     DummyControl dummy = DummyControl::New( true );
3847     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3848     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3849
3850     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3851     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3852     application.GetScene().Add( dummy );
3853
3854     application.SendNotification();
3855     application.Render();
3856
3857     application.SendNotification();
3858     application.Render();
3859
3860 #ifdef OLD_GRAPHICS_TEST
3861     // Currently test with multiple program doesn't work well. will fix another day
3862     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3863     // Default corner radius policy is absolute.
3864     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3865 #endif
3866   }
3867
3868   // animated image visual
3869   {
3870     VisualFactory factory = VisualFactory::Get();
3871     Property::Map properties;
3872     Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3873
3874     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3875     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3876     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
3877     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3878     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3879
3880     Visual::Base visual = factory.CreateVisual( properties );
3881
3882     // trigger creation through setting on stage
3883     DummyControl dummy = DummyControl::New( true );
3884     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3885     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3886
3887     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3888     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3889     application.GetScene().Add( dummy );
3890
3891     application.SendNotification();
3892     application.Render();
3893
3894     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3895
3896     application.SendNotification();
3897     application.Render();
3898
3899 #ifdef OLD_GRAPHICS_TEST
3900     // Currently test with multiple program doesn't work well. will fix another day
3901     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3902     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3903 #endif
3904   }
3905
3906   // vector image visual
3907   {
3908     VisualFactory factory = VisualFactory::Get();
3909     Property::Map properties;
3910     Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
3911
3912     properties[Visual::Property::TYPE] = Visual::SVG;
3913     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3914     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3915
3916     Visual::Base visual = factory.CreateVisual( properties );
3917
3918     // trigger creation through setting on stage
3919     DummyControl dummy = DummyControl::New( true );
3920     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3921     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3922
3923     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3924     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3925     application.GetScene().Add( dummy );
3926
3927     application.SendNotification();
3928     application.Render();
3929
3930     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3931
3932     application.SendNotification();
3933     application.Render();
3934
3935 #ifdef OLD_GRAPHICS_TEST
3936     // Currently test with multiple program doesn't work well. will fix another day
3937     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3938     // Default corner radius policy is absolute.
3939     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3940 #endif
3941   }
3942
3943   // animated vector image visual
3944   {
3945     VisualFactory factory = VisualFactory::Get();
3946     Property::Map properties;
3947     float cornerRadius = 1.3f;
3948
3949     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
3950     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
3951     properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
3952     properties["cornerRadius"] = cornerRadius;
3953     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3954
3955     Visual::Base visual = factory.CreateVisual( properties );
3956
3957     // trigger creation through setting on stage
3958     DummyControl dummy = DummyControl::New( true );
3959     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3960     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3961
3962     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3963     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3964     application.GetScene().Add( dummy );
3965
3966     application.SendNotification();
3967     application.Render();
3968
3969     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3970
3971     application.SendNotification();
3972     application.Render();
3973
3974 #ifdef OLD_GRAPHICS_TEST
3975     // Currently test with multiple program doesn't work well. will fix another day
3976     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3977     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3978 #endif
3979   }
3980
3981   END_TEST;
3982 }
3983
3984 int UtcDaliVisualBorderline(void)
3985 {
3986   ToolkitTestApplication application;
3987   tet_infoline( "UtcDaliVisualBorderline" );
3988
3989   static std::vector<UniformData> customUniforms =
3990   {
3991     UniformData("cornerRadius", Property::Type::VECTOR4),
3992     UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3993     UniformData("borderlineWidth", Property::Type::FLOAT),
3994     UniformData("borderlineColor", Property::Type::VECTOR4),
3995     UniformData("borderlineOffset", Property::Type::FLOAT),
3996   };
3997
3998   TestGraphicsController& graphics = application.GetGraphicsController();
3999   graphics.AddCustomUniforms(customUniforms);
4000
4001   // image visual
4002   {
4003     VisualFactory factory = VisualFactory::Get();
4004     Property::Map properties;
4005     float cornerRadius = 5.0f;
4006     float borderlineWidth = 30.0f;
4007     Vector4 borderlineColor(1.0f, 0.0f, 0.0f, 1.0f);
4008     float borderlineOffset = 1.0f;
4009
4010     properties[Visual::Property::TYPE] = Visual::IMAGE;
4011     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
4012     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4013     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4014     properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4015     properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4016
4017     Visual::Base visual = factory.CreateVisual( properties );
4018
4019     // trigger creation through setting on stage
4020     DummyControl dummy = DummyControl::New( true );
4021     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4022     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4023
4024     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4025     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4026     application.GetScene().Add( dummy );
4027
4028     application.SendNotification();
4029     application.Render();
4030
4031     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
4032
4033     application.SendNotification();
4034     application.Render();
4035
4036     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
4037     // Default corner radius policy is absolute.
4038     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
4039     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4040     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", borderlineColor ), true, TEST_LOCATION );
4041     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", borderlineOffset ), true, TEST_LOCATION );
4042   }
4043
4044   // color visual 1
4045   {
4046     VisualFactory factory = VisualFactory::Get();
4047     Property::Map properties;
4048     Vector4 cornerRadius(23.0f, 2.0f, 3.0f, 2.3f);
4049     float borderlineWidth = 30.0f;
4050     Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4051     float borderlineOffset = -0.4f;
4052
4053     properties[Visual::Property::TYPE] = Visual::COLOR;
4054     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4055     properties["cornerRadius"] = cornerRadius;
4056     properties["borderlineWidth"] = borderlineWidth;
4057     properties["borderlineColor"] = borderlineColor;
4058     properties["borderlineOffset"] = borderlineOffset;
4059
4060     Visual::Base visual = factory.CreateVisual( properties );
4061
4062     // trigger creation through setting on stage
4063     DummyControl dummy = DummyControl::New( true );
4064     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4065     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4066
4067     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4068     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4069     application.GetScene().Add( dummy );
4070
4071     application.SendNotification();
4072     application.Render();
4073
4074     application.SendNotification();
4075     application.Render();
4076
4077 #ifdef OLD_GRAPHICS_TEST
4078     // Currently test with multiple program doesn't work well. will fix another day
4079     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
4080     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4081     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", borderlineColor ), true, TEST_LOCATION );
4082     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", borderlineOffset ), true, TEST_LOCATION );
4083 #endif
4084   }
4085
4086   // color visual 2, default color, default offset
4087   {
4088     VisualFactory factory = VisualFactory::Get();
4089     Property::Map properties;
4090     float borderlineWidth = 30.0f;
4091
4092     properties[Visual::Property::TYPE] = Visual::COLOR;
4093     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4094     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4095
4096     Visual::Base visual = factory.CreateVisual( properties );
4097
4098     // trigger creation through setting on stage
4099     DummyControl dummy = DummyControl::New( true );
4100     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4101     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4102
4103     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4104     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4105     application.GetScene().Add( dummy );
4106
4107     application.SendNotification();
4108     application.Render();
4109
4110     application.SendNotification();
4111     application.Render();
4112
4113 #ifdef OLD_GRAPHICS_TEST
4114     // Currently test with multiple program doesn't work well. will fix another day
4115     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4116     // Default borderline color is BLACK.
4117     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", Color::BLACK ), true, TEST_LOCATION );
4118     // Default borderline offset is 0.0f.
4119     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", 0.0f ), true, TEST_LOCATION );
4120 #endif
4121   }
4122
4123   // color visual 3, offset not [-1.0 ~ 1.0], but uniform value is same anyway
4124   {
4125     VisualFactory factory = VisualFactory::Get();
4126     Property::Map properties;
4127     float borderlineWidth = 30.0f;
4128     Vector4 borderlineColor(0.5f, 0.4f, 0.3f, 0.2f);
4129     float borderlineOffset = 37.4f;
4130
4131     properties[Visual::Property::TYPE] = Visual::COLOR;
4132     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4133     properties["borderlineWidth"] = borderlineWidth;
4134     properties["borderlineColor"] = borderlineColor;
4135     properties["borderlineOffset"] = borderlineOffset;
4136
4137     Visual::Base visual = factory.CreateVisual( properties );
4138
4139     // trigger creation through setting on stage
4140     DummyControl dummy = DummyControl::New( true );
4141     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4142     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4143
4144     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4145     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4146     application.GetScene().Add( dummy );
4147
4148     application.SendNotification();
4149     application.Render();
4150
4151     application.SendNotification();
4152     application.Render();
4153
4154 #ifdef OLD_GRAPHICS_TEST
4155     // Currently test with multiple program doesn't work well. will fix another day
4156     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4157     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", borderlineColor ), true, TEST_LOCATION );
4158     // NOTE : borderlineOffset will clamp in fragment shader. not visual itself
4159     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", borderlineOffset ), true, TEST_LOCATION );
4160 #endif
4161   }
4162
4163   // gradient visual
4164   {
4165     VisualFactory factory = VisualFactory::Get();
4166     Property::Map properties;
4167     float borderlineWidth = 30.0f;
4168     float cornerRadius = 70.0f;
4169
4170     properties[Visual::Property::TYPE] = Visual::GRADIENT;
4171     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4172     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4173     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4174     properties[GradientVisual::Property::START_POSITION] = Vector2( 0.5f, 0.5f );
4175     properties[GradientVisual::Property::END_POSITION] = Vector2( -0.5f, -0.5f );
4176     properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
4177
4178     Property::Array stopOffsets;
4179     stopOffsets.PushBack( 0.0f );
4180     stopOffsets.PushBack( 0.6f );
4181     stopOffsets.PushBack( 1.0f );
4182     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
4183
4184     Property::Array stopColors;
4185     stopColors.PushBack( Color::RED );
4186     stopColors.PushBack( Color::YELLOW );
4187     stopColors.PushBack( Color::GREEN );
4188     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4189
4190     Visual::Base visual = factory.CreateVisual( properties );
4191
4192     // trigger creation through setting on stage
4193     DummyControl dummy = DummyControl::New( true );
4194     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4195     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4196
4197     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4198     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4199     application.GetScene().Add( dummy );
4200
4201     application.SendNotification();
4202     application.Render();
4203
4204     application.SendNotification();
4205     application.Render();
4206
4207 #ifdef OLD_GRAPHICS_TEST
4208     // Currently test with multiple program doesn't work well. will fix another day
4209     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
4210     // Default corner radius policy is absolute.
4211     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
4212     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4213     // Default borderline color is BLACK.
4214     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", Color::BLACK ), true, TEST_LOCATION );
4215     // Default borderline offset is 0.0f.
4216     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", 0.0f ), true, TEST_LOCATION );
4217 #endif
4218   }
4219
4220   // animated image visual
4221   {
4222     VisualFactory factory = VisualFactory::Get();
4223     Property::Map properties;
4224     float borderlineWidth = 24.0f;
4225     float borderlineOffset = -1.0f;
4226
4227     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4228     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4229     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth + 10.0f; // Dummy Input
4230     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4231     properties["borderlineOffset"] = borderlineOffset;
4232
4233     Visual::Base visual = factory.CreateVisual( properties );
4234
4235     // trigger creation through setting on stage
4236     DummyControl dummy = DummyControl::New( true );
4237     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4238     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4239
4240     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4241     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4242     application.GetScene().Add( dummy );
4243
4244     application.SendNotification();
4245     application.Render();
4246
4247     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
4248
4249     application.SendNotification();
4250     application.Render();
4251
4252 #ifdef OLD_GRAPHICS_TEST
4253     // Currently test with multiple program doesn't work well. will fix another day
4254     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4255     // Default borderline color is BLACK.
4256     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", Color::BLACK ), true, TEST_LOCATION );
4257     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", borderlineOffset ), true, TEST_LOCATION );
4258 #endif
4259   }
4260
4261   // vector image visual
4262   {
4263     VisualFactory factory = VisualFactory::Get();
4264     Property::Map properties;
4265     Vector4 cornerRadius(54.0f, 43.0f, 32.0f, 21.0f);
4266     float borderlineWidth = 27.0f;
4267     Vector4 borderlineColor(0.5f, 0.5f, 0.5f, 0.0f);
4268
4269     properties[Visual::Property::TYPE] = Visual::SVG;
4270     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4271     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
4272     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4273     properties[DevelVisual::Property::BORDERLINE_COLOR] = borderlineColor;
4274
4275     Visual::Base visual = factory.CreateVisual( properties );
4276
4277     // trigger creation through setting on stage
4278     DummyControl dummy = DummyControl::New( true );
4279     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4280     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4281
4282     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4283     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4284     application.GetScene().Add( dummy );
4285
4286     application.SendNotification();
4287     application.Render();
4288
4289     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
4290
4291     application.SendNotification();
4292     application.Render();
4293
4294 #ifdef OLD_GRAPHICS_TEST
4295     // Currently test with multiple program doesn't work well. will fix another day
4296     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
4297     // Default corner radius policy is absolute.
4298     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
4299     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4300     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", borderlineColor ), true, TEST_LOCATION );
4301     // Default borderline offset is 0.0.
4302     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", 0.0f ), true, TEST_LOCATION );
4303 #endif
4304   }
4305
4306   // animated vector image visual
4307   {
4308     VisualFactory factory = VisualFactory::Get();
4309     Property::Map properties;
4310     Vector4 cornerRadius(1.3f, 0.0f, 0.4f, 0.2f);
4311     float borderlineWidth = 13.0f;
4312     Vector4 borderlineColor(0.3f, 0.3f, 0.3f, 1.0f);
4313     float borderlineOffset = 13.0f;
4314
4315     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4316     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4317     properties["cornerRadius"] = cornerRadius;
4318     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
4319     properties[DevelVisual::Property::BORDERLINE_WIDTH] = borderlineWidth;
4320     properties["borderlineColor"] = borderlineColor;
4321     properties[DevelVisual::Property::BORDERLINE_OFFSET] = borderlineOffset;
4322
4323     Visual::Base visual = factory.CreateVisual( properties );
4324
4325     // trigger creation through setting on stage
4326     DummyControl dummy = DummyControl::New( true );
4327     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4328     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4329
4330     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4331     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4332     application.GetScene().Add( dummy );
4333
4334     application.SendNotification();
4335     application.Render();
4336
4337     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
4338
4339     application.SendNotification();
4340     application.Render();
4341
4342 #ifdef OLD_GRAPHICS_TEST
4343     // Currently test with multiple program doesn't work well. will fix another day
4344     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
4345     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
4346     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineWidth", borderlineWidth ), true, TEST_LOCATION );
4347     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "borderlineColor", borderlineColor ), true, TEST_LOCATION );
4348     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "borderlineOffset", borderlineOffset ), true, TEST_LOCATION );
4349 #endif
4350   }
4351
4352   END_TEST;
4353 }
4354
4355
4356 int UtcDaliColorVisualBlurRadius(void)
4357 {
4358   ToolkitTestApplication application;
4359   tet_infoline( "UtcDaliColorVisualBlurRadius" );
4360
4361   static std::vector<UniformData> customUniforms =
4362   {
4363     UniformData("blurRadius", Property::Type::FLOAT),
4364   };
4365
4366   TestGraphicsController& graphics = application.GetGraphicsController();
4367   graphics.AddCustomUniforms(customUniforms);
4368
4369   VisualFactory factory = VisualFactory::Get();
4370   Property::Map properties;
4371   float blurRadius = 20.0f;
4372
4373   properties[Visual::Property::TYPE] = Visual::COLOR;
4374   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
4375   properties["blurRadius"] = blurRadius;
4376
4377   Visual::Base visual = factory.CreateVisual( properties );
4378
4379   // trigger creation through setting on stage
4380   DummyControl dummy = DummyControl::New( true );
4381   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
4382   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
4383
4384   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
4385   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
4386   application.GetScene().Add( dummy );
4387
4388   application.SendNotification();
4389   application.Render();
4390
4391   application.SendNotification();
4392   application.Render();
4393
4394   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "blurRadius", blurRadius ), true, TEST_LOCATION );
4395
4396   END_TEST;
4397 }
4398
4399 int UtcDaliVisualGetType(void)
4400 {
4401   ToolkitTestApplication application;
4402   tet_infoline( "UtcDaliVisualGetType" );
4403
4404   VisualFactory factory = VisualFactory::Get();
4405
4406   {
4407     Property::Map properties;
4408     properties[Visual::Property::TYPE] = Visual::BORDER;
4409     Visual::Base visual = factory.CreateVisual( properties );
4410
4411     DALI_TEST_CHECK( visual.GetType() == Visual::BORDER );
4412   }
4413
4414   {
4415     Property::Map properties;
4416     properties[Visual::Property::TYPE] = Visual::COLOR;
4417     Visual::Base visual = factory.CreateVisual( properties );
4418
4419     DALI_TEST_CHECK( visual.GetType() == Visual::COLOR );
4420   }
4421
4422   {
4423     Property::Map properties;
4424     properties[Visual::Property::TYPE] = Visual::GRADIENT;
4425     properties[GradientVisual::Property::START_POSITION] = Vector2( -1.f, -1.f );
4426     properties[GradientVisual::Property::END_POSITION] = Vector2( 1.f, 1.f );
4427     properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4428     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4429     Property::Array stopColors;
4430     stopColors.PushBack( Color::RED );
4431     stopColors.PushBack( Color::GREEN );
4432     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4433     Visual::Base visual = factory.CreateVisual( properties );
4434
4435     DALI_TEST_CHECK( visual.GetType() == Visual::GRADIENT );
4436   }
4437
4438   {
4439     Property::Map properties;
4440     properties[Visual::Property::TYPE] = Visual::IMAGE;
4441     properties.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
4442     Visual::Base visual = factory.CreateVisual( properties );
4443
4444     DALI_TEST_CHECK( visual.GetType() == Visual::IMAGE );
4445   }
4446
4447   {
4448     Property::Map properties;
4449     properties[Visual::Property::TYPE] = Visual::MESH;
4450     Visual::Base visual = factory.CreateVisual( properties );
4451
4452     DALI_TEST_CHECK( visual.GetType() == Visual::MESH );
4453   }
4454
4455   {
4456     Property::Map properties;
4457     properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4458     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4459     Visual::Base visual = factory.CreateVisual( properties );
4460
4461     DALI_TEST_CHECK( visual.GetType() == Visual::PRIMITIVE );
4462   }
4463
4464   {
4465     Property::Map properties;
4466     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4467     Visual::Base visual = factory.CreateVisual( properties );
4468
4469     DALI_TEST_CHECK( visual.GetType() == Visual::WIREFRAME );
4470   }
4471
4472   {
4473     Property::Map properties;
4474     properties[Visual::Property::TYPE] = Visual::TEXT;
4475     Visual::Base visual = factory.CreateVisual( properties );
4476
4477     DALI_TEST_CHECK( visual.GetType() == Visual::TEXT );
4478   }
4479
4480   {
4481     Property::Map properties;
4482     properties[Visual::Property::TYPE] = Visual::N_PATCH;
4483     properties[ImageVisual::Property::URL] =  TEST_NPATCH_FILE_NAME;
4484     Visual::Base visual = factory.CreateVisual( properties );
4485
4486     DALI_TEST_CHECK( visual.GetType() == Visual::N_PATCH );
4487   }
4488
4489   {
4490     Property::Map properties;
4491     properties[Visual::Property::TYPE] = Visual::SVG;
4492     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4493     Visual::Base visual = factory.CreateVisual( properties );
4494
4495     DALI_TEST_CHECK( visual.GetType() == Visual::SVG );
4496   }
4497
4498   {
4499     Property::Map properties;
4500     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4501     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4502     Visual::Base visual = factory.CreateVisual( properties );
4503
4504     DALI_TEST_CHECK( visual.GetType() == Visual::ANIMATED_IMAGE );
4505   }
4506
4507   {
4508     Property::Map properties;
4509     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4510     Visual::Base visual = factory.CreateVisual( properties );
4511
4512     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_GRADIENT ) );
4513   }
4514
4515   {
4516     Property::Map properties;
4517     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4518     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4519     Visual::Base visual = factory.CreateVisual( properties );
4520
4521     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_VECTOR_IMAGE ) );
4522   }
4523
4524   {
4525     Property::Map properties;
4526     properties[Visual::Property::TYPE] = DevelVisual::ARC;
4527     Visual::Base visual = factory.CreateVisual( properties );
4528
4529     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ARC ) );
4530   }
4531
4532   END_TEST;
4533 }
4534
4535 int UtcDaliVisualGetVisualProperty01(void)
4536 {
4537   ToolkitTestApplication application;
4538   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual" );
4539
4540   static std::vector<UniformData> customUniforms =
4541   {
4542     UniformData("mixColor", Property::Type::VECTOR3),
4543     UniformData("offset", Property::Type::VECTOR2),
4544     UniformData("size", Property::Type::VECTOR2),
4545     UniformData("cornerRadius", Property::Type::VECTOR4),
4546     UniformData("blurRadius", Property::Type::FLOAT),
4547     UniformData("borderlineWidth", Property::Type::FLOAT),
4548     UniformData("borderlineColor", Property::Type::VECTOR4),
4549     UniformData("borderlineOffset", Property::Type::FLOAT),
4550   };
4551
4552   TestGraphicsController& graphics = application.GetGraphicsController();
4553   graphics.AddCustomUniforms(customUniforms);
4554
4555   VisualFactory factory = VisualFactory::Get();
4556   Property::Map propertyMap;
4557   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4558   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4559   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4560   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4561   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4562   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
4563   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
4564   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, 1.0f);
4565   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4566
4567   DummyControl dummyControl = DummyControl::New(true);
4568   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4569   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4570   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4571   application.GetScene().Add(dummyControl);
4572
4573   application.SendNotification();
4574   application.Render();
4575
4576   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4577   Vector2 targetOffset(0.05f, 0.05f);
4578   Vector2 targetSize(1.1f, 1.1f);
4579   float targetOpacity = 0.5f;
4580   Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4581   float targetBlurRadius = 10.0f;
4582   float targetBorderlineWidth = 25.0f;
4583   Vector4 targetBorderlineColor(1.0f, 1.0f, 1.0f, 1.0f);
4584   float targetBorderlineOffset = -1.0f;
4585
4586   Animation animation = Animation::New(1.0f);
4587   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4588   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4589   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4590   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4591   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4592   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4593   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4594   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4595   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4596   animation.Play();
4597
4598   application.SendNotification();
4599   application.Render();
4600   application.Render(1001u); // End of animation
4601
4602   Property::Map resultMap;
4603   colorVisual.CreatePropertyMap( resultMap );
4604
4605   // Test property values: they should be updated
4606   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4607   DALI_TEST_CHECK(colorValue);
4608   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4609
4610   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4611   Dali::Property::Map* transformMap = transformValue->GetMap();
4612   DALI_TEST_CHECK(transformMap);
4613
4614   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4615   DALI_TEST_CHECK(offsetValue);
4616   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4617
4618   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4619   DALI_TEST_CHECK(sizeValue);
4620   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4621
4622   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4623   DALI_TEST_CHECK(cornerRadiusValue);
4624   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4625
4626   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4627   DALI_TEST_CHECK(blurRadiusValue);
4628   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4629
4630   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4631   DALI_TEST_CHECK(borderlineWidthValue);
4632   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
4633
4634   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4635   DALI_TEST_CHECK(borderlineColorValue);
4636   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
4637
4638   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4639   DALI_TEST_CHECK(borderlineOffsetValue);
4640   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
4641
4642   // Test uniform values
4643   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4644   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4645   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4646   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4647   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4648   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4649   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4650   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4651
4652   // Test not-supported property
4653   Property property1 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::PREMULTIPLIED_ALPHA);
4654   DALI_TEST_CHECK(!property1.object);
4655   DALI_TEST_CHECK(property1.propertyIndex == Property::INVALID_INDEX);
4656
4657   // Test unregistered visual
4658   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4659   DALI_TEST_CHECK(!property3.object);
4660   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4661
4662   END_TEST;
4663 }
4664
4665 int UtcDaliVisualGetVisualProperty02(void)
4666 {
4667   ToolkitTestApplication application;
4668   tet_infoline( "UtcDaliVisualGetVisualProperty02: Test animatable property, ColorVisual" );
4669
4670   static std::vector<UniformData> customUniforms =
4671   {
4672     UniformData("mixColor", Property::Type::VECTOR3),
4673     UniformData("offset", Property::Type::VECTOR2),
4674     UniformData("size", Property::Type::VECTOR2),
4675     UniformData("cornerRadius", Property::Type::VECTOR4),
4676     UniformData("borderlineWidth", Property::Type::FLOAT),
4677     UniformData("borderlineCOlor", Property::Type::VECTOR4),
4678     UniformData("borderlineOffset", Property::Type::FLOAT),
4679     UniformData("blurRadius", Property::Type::FLOAT),
4680   };
4681
4682   TestGraphicsController& graphics = application.GetGraphicsController();
4683   graphics.AddCustomUniforms(customUniforms);
4684
4685   VisualFactory factory = VisualFactory::Get();
4686   Property::Map propertyMap;
4687   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4688   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4689
4690   DummyControl dummyControl = DummyControl::New(true);
4691   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4692   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4693   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4694   application.GetScene().Add(dummyControl);
4695
4696   application.SendNotification();
4697   application.Render();
4698
4699   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4700   Vector2 targetOffset(0.05f, 0.05f);
4701   Vector2 targetSize(1.1f, 1.1f);
4702   float targetOpacity = 0.5f;
4703   Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
4704   float targetBorderlineWidth = 77.7f;
4705   Vector4 targetBorderlineColor(0.4f, 0.2f, 0.3f, 0.9f);
4706   float targetBorderlineOffset = 1.0f;
4707   float targetBlurRadius = 10.0f;
4708
4709   // Should work when the properties are not set before
4710   Animation animation = Animation::New(1.0f);
4711   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
4712   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
4713   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
4714   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
4715   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
4716   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineWidth"), targetBorderlineWidth);
4717   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineColor"), targetBorderlineColor);
4718   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "borderlineOffset"), targetBorderlineOffset);
4719   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
4720   animation.Play();
4721
4722   application.SendNotification();
4723   application.Render();
4724   application.Render(1001u); // End of animation
4725
4726   Property::Map resultMap;
4727   colorVisual.CreatePropertyMap(resultMap);
4728
4729   // Test property values: they should be updated
4730   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4731   DALI_TEST_CHECK(colorValue);
4732   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4733
4734   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4735   Dali::Property::Map* transformMap = transformValue->GetMap();
4736   DALI_TEST_CHECK(transformMap);
4737
4738   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4739   DALI_TEST_CHECK(offsetValue);
4740   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4741
4742   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4743   DALI_TEST_CHECK(sizeValue);
4744   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4745
4746   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4747   DALI_TEST_CHECK(cornerRadiusValue);
4748   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4749
4750   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4751   DALI_TEST_CHECK(borderlineWidthValue);
4752   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
4753
4754   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4755   DALI_TEST_CHECK(borderlineColorValue);
4756   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
4757
4758   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4759   DALI_TEST_CHECK(borderlineOffsetValue);
4760   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
4761
4762   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4763   DALI_TEST_CHECK(blurRadiusValue);
4764   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4765
4766 #ifdef OLD_GRAPHICS_TEST
4767   // Currently test with multiple program doesn't work well. will fix another day
4768   // Test uniform values
4769   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4770   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4771   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4772   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4773   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4774 #endif
4775
4776   END_TEST;
4777 }
4778
4779 int UtcDaliVisualGetVisualProperty03(void)
4780 {
4781   ToolkitTestApplication application;
4782   tet_infoline( "UtcDaliVisualGetVisualProperty03: Test animatable property, ImageVisual" );
4783
4784   static std::vector<UniformData> customUniforms =
4785   {
4786     UniformData("cornerRadius", Property::Type::VECTOR4),
4787     UniformData("borderlineWidth", Property::Type::FLOAT),
4788     UniformData("borderlineColor", Property::Type::VECTOR4),
4789     UniformData("borderlineOffset", Property::Type::FLOAT),
4790   };
4791
4792   TestGraphicsController& graphics = application.GetGraphicsController();
4793   graphics.AddCustomUniforms(customUniforms);
4794
4795   VisualFactory factory = VisualFactory::Get();
4796   Property::Map propertyMap;
4797   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
4798   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4799
4800   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
4801
4802   DummyControl dummyControl = DummyControl::New(true);
4803   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4804   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
4805   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4806   application.GetScene().Add(dummyControl);
4807
4808   // Wait for image loading
4809   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4810
4811   application.SendNotification();
4812   application.Render();
4813
4814   float targetOpacity = 0.5f;
4815   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
4816   float targetBorderlineWidth = 10.0f;
4817   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
4818   float targetBorderlineOffset = -1.5f;
4819
4820   Animation animation = Animation::New(1.0f);
4821   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4822   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4823   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4824   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4825   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4826   animation.Play();
4827
4828   application.SendNotification();
4829   application.Render();
4830   application.Render(1001u); // End of animation
4831
4832   Property::Map resultMap;
4833   imageVisual.CreatePropertyMap( resultMap );
4834
4835   // Test property values: they should be updated
4836   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4837   DALI_TEST_CHECK(colorValue);
4838   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4839
4840   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4841   DALI_TEST_CHECK(cornerRadiusValue);
4842   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4843
4844   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
4845   DALI_TEST_CHECK(borderlineWidthValue);
4846   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
4847
4848   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
4849   DALI_TEST_CHECK(borderlineColorValue);
4850   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
4851
4852   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
4853   DALI_TEST_CHECK(borderlineOffsetValue);
4854   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
4855
4856 #ifdef OLD_GRAPHICS_TEST
4857   // Currently test with multiple program doesn't work well. will fix another day
4858   // Test uniform value
4859   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4860   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
4861   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
4862   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
4863 #endif
4864
4865   END_TEST;
4866 }
4867
4868 int UtcDaliVisualGetVisualProperty04(void)
4869 {
4870   ToolkitTestApplication application;
4871   tet_infoline( "UtcDaliVisualGetVisualProperty04: Test animatable property, GradientVisual" );
4872
4873   static std::vector<UniformData> customUniforms =
4874   {
4875     UniformData("cornerRadius", Property::Type::VECTOR4),
4876   };
4877
4878   TestGraphicsController& graphics = application.GetGraphicsController();
4879   graphics.AddCustomUniforms(customUniforms);
4880
4881   Vector2 start(-1.f, -1.f);
4882   Vector2 end(1.f, 1.f);
4883   Property::Array stopColors;
4884   stopColors.PushBack( Color::RED );
4885   stopColors.PushBack( Color::GREEN );
4886
4887   VisualFactory factory = VisualFactory::Get();
4888   Property::Map propertyMap;
4889   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
4890   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
4891   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
4892   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
4893   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
4894   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
4895   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
4896
4897   DummyControl dummyControl = DummyControl::New(true);
4898   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4899   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
4900   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4901   application.GetScene().Add(dummyControl);
4902
4903   application.SendNotification();
4904   application.Render();
4905
4906   float targetOpacity = 0.5f;
4907   Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
4908
4909   Animation animation = Animation::New(1.0f);
4910   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4911   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4912   animation.Play();
4913
4914   application.SendNotification();
4915   application.Render();
4916   application.Render(1001u); // End of animation
4917
4918   Property::Map resultMap;
4919   gradientVisual.CreatePropertyMap( resultMap );
4920
4921   // Test property values: they should be updated
4922   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4923   DALI_TEST_CHECK(colorValue);
4924   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4925
4926   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4927   DALI_TEST_CHECK(cornerRadiusValue);
4928   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4929
4930 #ifdef OLD_GRAPHICS_TEST
4931   // Currently test with multiple program doesn't work well. will fix another day
4932   // Test uniform value
4933   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4934 #endif
4935
4936   END_TEST;
4937 }
4938
4939 int UtcDaliVisualGetVisualProperty05(void)
4940 {
4941   ToolkitTestApplication application;
4942   tet_infoline( "UtcDaliVisualGetVisualProperty05: Test animatable property, SvgVisual" );
4943
4944   static std::vector<UniformData> customUniforms =
4945   {
4946     UniformData("cornerRadius", Property::Type::VECTOR4),
4947     UniformData("borderlineWidth", Property::Type::FLOAT),
4948     UniformData("borderlineColor", Property::Type::VECTOR4),
4949     UniformData("borderlineOffset", Property::Type::FLOAT),
4950   };
4951
4952   TestGraphicsController& graphics = application.GetGraphicsController();
4953   graphics.AddCustomUniforms(customUniforms);
4954
4955   VisualFactory factory = VisualFactory::Get();
4956   Property::Map propertyMap;
4957   propertyMap.Insert(Visual::Property::TYPE, Visual::SVG);
4958   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
4959
4960   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
4961
4962   DummyControl dummyControl = DummyControl::New(true);
4963   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4964   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, svgVisual);
4965   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4966   application.GetScene().Add(dummyControl);
4967
4968   application.SendNotification();
4969   application.Render();
4970
4971   // Wait for image loading
4972   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4973
4974   application.SendNotification();
4975   application.Render();
4976
4977   float targetOpacity = 0.5f;
4978   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
4979   float targetBorderlineWidth = 10.0f;
4980   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
4981   float targetBorderlineOffset = -1.5f;
4982
4983   Animation animation = Animation::New(1.0f);
4984   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4985   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4986   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
4987   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
4988   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
4989   animation.Play();
4990
4991   application.SendNotification();
4992   application.Render();
4993   application.Render(1001u); // End of animation
4994
4995   Property::Map resultMap;
4996   svgVisual.CreatePropertyMap( resultMap );
4997
4998   // Test property values: they should be updated
4999   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5000   DALI_TEST_CHECK(colorValue);
5001   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5002
5003   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5004   DALI_TEST_CHECK(cornerRadiusValue);
5005   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
5006
5007   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5008   DALI_TEST_CHECK(borderlineWidthValue);
5009   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
5010
5011   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5012   DALI_TEST_CHECK(borderlineColorValue);
5013   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
5014
5015   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5016   DALI_TEST_CHECK(borderlineOffsetValue);
5017   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
5018
5019 #ifdef OLD_GRAPHICS_TEST
5020   // Currently test with multiple program doesn't work well. will fix another day
5021   // Test uniform value
5022   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5023   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5024   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5025   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5026 #endif
5027
5028   END_TEST;
5029 }
5030
5031 int UtcDaliVisualGetVisualProperty06(void)
5032 {
5033   ToolkitTestApplication application;
5034   tet_infoline( "UtcDaliVisualGetVisualProperty06: Test animatable property, AnimatedImageVisual" );
5035
5036   static std::vector<UniformData> customUniforms =
5037   {
5038     UniformData("cornerRadius", Property::Type::VECTOR4),
5039     UniformData("borderlineWidth", Property::Type::FLOAT),
5040     UniformData("borderlineColor", Property::Type::VECTOR4),
5041     UniformData("borderlineOffset", Property::Type::FLOAT),
5042   };
5043
5044   TestGraphicsController& graphics = application.GetGraphicsController();
5045   graphics.AddCustomUniforms(customUniforms);
5046
5047   VisualFactory factory = VisualFactory::Get();
5048   Property::Map propertyMap;
5049   propertyMap.Insert(Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
5050   propertyMap.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
5051
5052   Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap);
5053
5054   DummyControl dummyControl = DummyControl::New(true);
5055   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5056   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedImageVisual);
5057   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5058   application.GetScene().Add(dummyControl);
5059
5060   application.SendNotification();
5061   application.Render();
5062
5063   // Wait for image loading
5064   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5065
5066   application.SendNotification();
5067   application.Render();
5068
5069   float targetOpacity = 0.5f;
5070   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5071   float targetBorderlineWidth = 10.0f;
5072   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5073   float targetBorderlineOffset = -1.5f;
5074
5075   Animation animation = Animation::New(1.0f);
5076   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5077   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5078   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5079   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5080   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5081   animation.Play();
5082
5083   application.SendNotification();
5084   application.Render();
5085   application.Render(1001u); // End of animation
5086
5087   Property::Map resultMap;
5088   animatedImageVisual.CreatePropertyMap( resultMap );
5089
5090   // Test property values: they should be updated
5091   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5092   DALI_TEST_CHECK(colorValue);
5093   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5094
5095   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5096   DALI_TEST_CHECK(cornerRadiusValue);
5097   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
5098
5099   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5100   DALI_TEST_CHECK(borderlineWidthValue);
5101   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
5102
5103   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5104   DALI_TEST_CHECK(borderlineColorValue);
5105   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
5106
5107   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5108   DALI_TEST_CHECK(borderlineOffsetValue);
5109   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
5110
5111 #ifdef OLD_GRAPHICS_TEST
5112   // Currently test with multiple program doesn't work well. will fix another day
5113   // Test uniform value
5114   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5115   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5116   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5117   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5118 #endif
5119
5120   END_TEST;
5121 }
5122
5123 int UtcDaliVisualGetVisualProperty07(void)
5124 {
5125   ToolkitTestApplication application;
5126   tet_infoline( "UtcDaliVisualGetVisualProperty07: Test animatable property, AnimatedVectorVisual" );
5127
5128   static std::vector<UniformData> customUniforms =
5129   {
5130     UniformData("cornerRadius", Property::Type::VECTOR4),
5131     UniformData("borderlineWidth", Property::Type::FLOAT),
5132     UniformData("borderlineColor", Property::Type::VECTOR4),
5133     UniformData("borderlineOffset", Property::Type::FLOAT),
5134   };
5135
5136   TestGraphicsController& graphics = application.GetGraphicsController();
5137   graphics.AddCustomUniforms(customUniforms);
5138
5139   VisualFactory factory = VisualFactory::Get();
5140   Property::Map propertyMap;
5141   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::Type::ANIMATED_VECTOR_IMAGE);
5142   propertyMap.Insert(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_FILE_NAME);
5143
5144   Visual::Base animatedVectorVisual = factory.CreateVisual(propertyMap);
5145
5146   DummyControl dummyControl = DummyControl::New(true);
5147   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
5148   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, animatedVectorVisual);
5149   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
5150   application.GetScene().Add(dummyControl);
5151
5152   application.SendNotification();
5153   application.Render();
5154
5155   // Wait for image loading
5156   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5157
5158   application.SendNotification();
5159   application.Render();
5160
5161   float targetOpacity = 0.5f;
5162   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
5163   float targetBorderlineWidth = 10.0f;
5164   Vector4 targetBorderlineColor(1.0f, 0.0f, 1.0f, 0.5f);
5165   float targetBorderlineOffset = -1.5f;
5166
5167   Animation animation = Animation::New(1.0f);
5168   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
5169   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
5170   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), targetBorderlineWidth);
5171   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), targetBorderlineColor);
5172   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_OFFSET), targetBorderlineOffset);
5173   animation.Play();
5174
5175   application.SendNotification();
5176   application.Render();
5177   application.Render(1001u); // End of animation
5178
5179   Property::Map resultMap;
5180   animatedVectorVisual.CreatePropertyMap( resultMap );
5181
5182   // Test property values: they should be updated
5183   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
5184   DALI_TEST_CHECK(colorValue);
5185   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
5186
5187   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
5188   DALI_TEST_CHECK(cornerRadiusValue);
5189   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
5190
5191   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
5192   DALI_TEST_CHECK(borderlineWidthValue);
5193   DALI_TEST_EQUALS(borderlineWidthValue->Get< float >(), targetBorderlineWidth, TEST_LOCATION);
5194
5195   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
5196   DALI_TEST_CHECK(borderlineColorValue);
5197   DALI_TEST_EQUALS(borderlineColorValue->Get< Vector4 >(), targetBorderlineColor, TEST_LOCATION);
5198
5199   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
5200   DALI_TEST_CHECK(borderlineOffsetValue);
5201   DALI_TEST_EQUALS(borderlineOffsetValue->Get< float >(), targetBorderlineOffset, TEST_LOCATION);
5202
5203 #ifdef OLD_GRAPHICS_TEST
5204   // Currently test with multiple program doesn't work well. will fix another day
5205   // Test uniform value
5206   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
5207   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineWidth", targetBorderlineWidth), true, TEST_LOCATION);
5208   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderlineColor", targetBorderlineColor), true, TEST_LOCATION);
5209   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderlineOffset", targetBorderlineOffset), true, TEST_LOCATION);
5210 #endif
5211
5212   END_TEST;
5213 }