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

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