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