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( DevelColorVisual::Property::BLUR_RADIUS, 20.0f );
 506   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 507
 508   Property::Map resultMap;
 509   colorVisual.CreatePropertyMap( resultMap );
 510
 511   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 512   DALI_TEST_CHECK( typeValue );
 513   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 514
 515   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 516   DALI_TEST_CHECK( colorValue );
 517   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 518
 519   Property::Value* cornerRadiusValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
 520   DALI_TEST_CHECK( cornerRadiusValue );
 521   DALI_TEST_CHECK( cornerRadiusValue->Get< float >() == 10.0f );
 522
 523   Property::Value* cornerRadiusPolicyValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER );
 524   DALI_TEST_CHECK( cornerRadiusPolicyValue );
 525   DALI_TEST_CHECK( cornerRadiusPolicyValue->Get< int >() == Toolkit::Visual::Transform::Policy::RELATIVE );
 526
 527   Property::Value* blurRadiusValue = resultMap.Find( DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT );
 528   DALI_TEST_CHECK( blurRadiusValue );
 529   DALI_TEST_CHECK( blurRadiusValue->Get< float >() == 20.0f );
 530
 531   // change the blend color
 532   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 533   colorVisual = factory.CreateVisual( propertyMap  );
 534   colorVisual.CreatePropertyMap( resultMap );
 535
 536   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 537   DALI_TEST_CHECK( colorValue );
 538   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 539
 540   // Test wrong values
 541   propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
 542
 543   colorVisual = factory.CreateVisual( propertyMap  );
 544   colorVisual.CreatePropertyMap( resultMap );
 545
 546   blurRadiusValue = resultMap.Find( DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT );
 547   DALI_TEST_CHECK( blurRadiusValue );
 548   DALI_TEST_CHECK( blurRadiusValue->Get< float >() == 0.0f );
 549
 550   END_TEST;
 551 }
 552
 553 int UtcDaliVisualGetPropertyMap2(void)
 554 {
 555   ToolkitTestApplication application;
 556   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 557
 558   VisualFactory factory = VisualFactory::Get();
 559   Property::Map propertyMap;
 560   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 561   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
 562   propertyMap.Insert("borderColor",  Color::BLUE);
 563   propertyMap.Insert("borderSize",  5.f);
 564   propertyMap.Insert("antiAliasing",  true);
 565   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 566
 567   Property::Map resultMap;
 568   borderVisual.CreatePropertyMap( resultMap );
 569
 570   // check the property values from the returned map from visual
 571   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 572   DALI_TEST_CHECK( typeValue );
 573   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 574
 575   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 576   DALI_TEST_CHECK( colorValue );
 577   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 578
 579   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 580   DALI_TEST_CHECK( sizeValue );
 581   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 582
 583   Property::Value* AAValue = resultMap.Find( BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN );
 584   DALI_TEST_CHECK( AAValue );
 585   DALI_TEST_CHECK( AAValue->Get<bool>() == true );
 586
 587   Property::Map propertyMap1;
 588   propertyMap1[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 589   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 590   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 591   borderVisual = factory.CreateVisual( propertyMap1 );
 592   borderVisual.CreatePropertyMap( resultMap );
 593
 594   typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 595   DALI_TEST_CHECK( typeValue );
 596   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 597
 598   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 599   DALI_TEST_CHECK( colorValue );
 600   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 601
 602   colorValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 603   DALI_TEST_CHECK( colorValue );
 604   DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
 605
 606
 607   END_TEST;
 608 }
 609
 610 int UtcDaliVisualGetPropertyMap2N(void)
 611 {
 612   ToolkitTestApplication application;
 613   tet_infoline( "UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties" );
 614
 615   VisualFactory factory = VisualFactory::Get();
 616   Property::Map propertyMap;
 617   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 618   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 619
 620   tet_infoline( "Test that the visual is created, with a default renderer" );
 621   DALI_TEST_CHECK( borderVisual );
 622
 623   DummyControl dummyControl = DummyControl::New(true);
 624   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 625   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
 626   application.GetScene().Add( dummyControl );
 627
 628   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
 629
 630   END_TEST;
 631 }
 632
 633
 634 int UtcDaliVisualGetPropertyMap3(void)
 635 {
 636   ToolkitTestApplication application;
 637   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 638
 639   VisualFactory factory = VisualFactory::Get();
 640   DALI_TEST_CHECK( factory );
 641
 642   Property::Map propertyMap;
 643   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 644
 645   Vector2 start(-1.f, -1.f);
 646   Vector2 end(1.f, 1.f);
 647   propertyMap.Insert( "startPosition", start);
 648   propertyMap.Insert( "endPosition", end);
 649   propertyMap.Insert( "spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 650
 651   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 652
 653   Property::Array stopColors;
 654   stopColors.PushBack( Color::RED );
 655   stopColors.PushBack( Color::GREEN );
 656   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 657
 658   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 659
 660   Property::Map resultMap;
 661   gradientVisual.CreatePropertyMap( resultMap );
 662
 663   // check the property values from the returned map from visual
 664   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 665   DALI_TEST_CHECK( value );
 666   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 667
 668   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 669   DALI_TEST_CHECK( value );
 670   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 671
 672   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 673   DALI_TEST_CHECK( value );
 674   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 675
 676   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 677   DALI_TEST_CHECK( value );
 678   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 679
 680   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 681   DALI_TEST_CHECK( value );
 682   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 683
 684   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 685   DALI_TEST_CHECK( value );
 686   Property::Array* offsetArray = value->GetArray();
 687   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 688   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 689   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 690
 691   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 692   DALI_TEST_CHECK( value );
 693   Property::Array* colorArray = value->GetArray();
 694   DALI_TEST_CHECK( colorArray->Count() == 2 );
 695   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 696   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 697
 698   END_TEST;
 699 }
 700
 701 int UtcDaliVisualGetPropertyMap4(void)
 702 {
 703   ToolkitTestApplication application;
 704   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 705
 706   VisualFactory factory = VisualFactory::Get();
 707   DALI_TEST_CHECK( factory );
 708
 709   Property::Map propertyMap;
 710   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 711
 712   Vector2 center(100.f, 100.f);
 713   float radius = 100.f;
 714   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 715   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 716   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 717   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 718
 719   Property::Array stopColors;
 720   stopColors.PushBack( Color::RED );
 721   stopColors.PushBack( Color::BLACK );
 722   stopColors.PushBack( Color::GREEN );
 723   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 724
 725   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 726   DALI_TEST_CHECK( gradientVisual );
 727
 728   Property::Map resultMap;
 729   gradientVisual.CreatePropertyMap( resultMap );
 730
 731   // check the property values from the returned map from visual
 732   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 733   DALI_TEST_CHECK( value );
 734   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 735
 736   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 737   DALI_TEST_CHECK( value );
 738   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 739
 740   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 741   DALI_TEST_CHECK( value );
 742   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 743
 744   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 745   DALI_TEST_CHECK( value );
 746   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 747
 748   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 749   DALI_TEST_CHECK( value );
 750   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 751
 752   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 753   DALI_TEST_CHECK( value );
 754   Property::Array* offsetArray = value->GetArray();
 755   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 756   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 757   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 758   // any stop value will be clamped to [0.0, 1.0];
 759   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 760
 761   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 762   DALI_TEST_CHECK( value );
 763   Property::Array* colorArray = value->GetArray();
 764   DALI_TEST_CHECK( colorArray->Count() == 3 );
 765   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 766   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 767   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 768
 769   END_TEST;
 770 }
 771
 772 int UtcDaliVisualGetPropertyMap5(void)
 773 {
 774   ToolkitTestApplication application;
 775   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 776
 777   VisualFactory factory = VisualFactory::Get();
 778   Property::Map propertyMap;
 779   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 780   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
 781   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 782   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 783   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 784   propertyMap.Insert( "fittingMode",   FittingMode::FIT_HEIGHT );
 785   propertyMap.Insert( "samplingMode",   SamplingMode::BOX_THEN_NEAREST );
 786   propertyMap.Insert( "pixelArea", Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 787   propertyMap.Insert( "wrapModeU", WrapMode::REPEAT );
 788   propertyMap.Insert( "wrapModeV", WrapMode::MIRRORED_REPEAT );
 789   propertyMap.Insert( "synchronousLoading",   true );
 790
 791   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 792   DALI_TEST_CHECK( imageVisual );
 793
 794   Property::Map resultMap;
 795   imageVisual.CreatePropertyMap( resultMap );
 796
 797   // check the property values from the returned map from visual
 798   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 799   DALI_TEST_CHECK( value );
 800   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 801
 802   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 803   DALI_TEST_CHECK( value );
 804   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 805
 806   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 807   DALI_TEST_CHECK( value );
 808   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 809
 810   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 811   DALI_TEST_CHECK( value );
 812   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 813
 814   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 815   DALI_TEST_CHECK( value );
 816   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX_THEN_NEAREST );
 817
 818   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 819   DALI_TEST_CHECK( value );
 820   DALI_TEST_CHECK( value->Get<int>() == 20 );
 821
 822   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 823   DALI_TEST_CHECK( value );
 824   DALI_TEST_CHECK( value->Get<int>() == 30 );
 825
 826   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 827   DALI_TEST_CHECK( value );
 828   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.25f, 0.25f, 0.5f, 0.5f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 829
 830   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 831   DALI_TEST_CHECK( value );
 832   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::REPEAT);
 833
 834   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 835   DALI_TEST_CHECK( value );
 836   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 837
 838   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 839   DALI_TEST_CHECK( value );
 840   DALI_TEST_CHECK( value->Get<bool>() == true );
 841
 842   END_TEST;
 843 }
 844
 845 int UtcDaliVisualGetPropertyMap6(void)
 846 {
 847   ToolkitTestApplication application;
 848   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 849
 850   Rect< int > border( 1, 1, 1, 1 );
 851
 852   VisualFactory factory = VisualFactory::Get();
 853   Property::Map propertyMap;
 854   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 855   propertyMap.Insert( "mixColor",  Color::MAGENTA );
 856   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 857   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 858   propertyMap.Insert( ImageVisual::Property::BORDER, border );
 859   propertyMap.Insert( DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png" );
 860   propertyMap.Insert( DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f );
 861   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 862
 863   Property::Map resultMap;
 864   nPatchVisual.CreatePropertyMap( resultMap );
 865
 866   // check the property values from the returned map from visual
 867   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 868   DALI_TEST_CHECK( value );
 869   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 870
 871   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 872   DALI_TEST_CHECK( value );
 873   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 874
 875   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 876   DALI_TEST_CHECK( value );
 877   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 878
 879   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 880   DALI_TEST_CHECK( value );
 881   DALI_TEST_CHECK( value->Get<bool>() );
 882
 883   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 884   DALI_TEST_CHECK( value );
 885   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 886
 887   value = resultMap.Find( DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING );
 888   DALI_TEST_CHECK( value );
 889   DALI_TEST_CHECK( value->Get<std::string>() == "application-icon-30.png" );
 890
 891   value = resultMap.Find( DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT );
 892   DALI_TEST_CHECK( value );
 893   DALI_TEST_CHECK( value->Get<float>() == 0.9f );
 894
 895   Vector4 border1( 1.0f, 1.0f, 1.0f, 1.0f );
 896
 897   Property::Map propertyMap1;
 898   propertyMap1.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 899   propertyMap1.Insert( "mixColor",  Color::MAGENTA );
 900   propertyMap1.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 901   propertyMap1.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 902   propertyMap1.Insert( ImageVisual::Property::BORDER, border1 );
 903   nPatchVisual = factory.CreateVisual( propertyMap1 );
 904
 905   nPatchVisual.CreatePropertyMap( resultMap );
 906
 907   // check the property values from the returned map from visual
 908   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 909   DALI_TEST_CHECK( value );
 910   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 911
 912   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 913   DALI_TEST_CHECK( value );
 914   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 915
 916   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 917   DALI_TEST_CHECK( value );
 918   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 919
 920   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 921   DALI_TEST_CHECK( value );
 922   DALI_TEST_CHECK( value->Get<bool>() );
 923
 924   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 925   DALI_TEST_CHECK( value );
 926   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 927
 928   END_TEST;
 929 }
 930
 931 int UtcDaliVisualGetPropertyMap7(void)
 932 {
 933   ToolkitTestApplication application;
 934   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 935
 936   // request SvgVisual with a property map
 937   VisualFactory factory = VisualFactory::Get();
 938   Property::Map propertyMap;
 939   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
 940   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::WHITE );
 941   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 942   propertyMap.Insert( ImageVisual::Property::ATLASING, false );
 943   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 944
 945   Property::Map resultMap;
 946   svgVisual.CreatePropertyMap( resultMap );
 947   // check the property values from the returned map from a visual
 948   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 949   DALI_TEST_CHECK( value );
 950   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 951
 952   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 953   DALI_TEST_CHECK( value );
 954   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 955
 956   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 957   DALI_TEST_CHECK( value );
 958   DALI_TEST_CHECK( value->Get<bool>() == false );
 959
 960   // request SvgVisual with a property map 2
 961   propertyMap.Clear();
 962   propertyMap[ "visualType" ] = Visual::SVG;
 963   propertyMap[ "mixColor" ] = Color::WHITE;
 964   propertyMap[ "url" ] = TEST_SVG_FILE_NAME;
 965   propertyMap[ "atlasing" ] = true;
 966   Visual::Base svgVisual1 = factory.CreateVisual( propertyMap );
 967
 968   resultMap.Clear();
 969   svgVisual1.CreatePropertyMap( resultMap );
 970   // check the property values from the returned map from a visual
 971   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 972   DALI_TEST_CHECK( value );
 973   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 974
 975   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 976   DALI_TEST_CHECK( value );
 977   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 978
 979   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 980   DALI_TEST_CHECK( value );
 981   DALI_TEST_CHECK( value->Get<bool>() == true );
 982
 983   // request SvgVisual with an URL
 984   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 985   resultMap.Clear();
 986   svgVisual2.CreatePropertyMap( resultMap );
 987   // check the property values from the returned map from a visual
 988   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 989   DALI_TEST_CHECK( value );
 990   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 991
 992   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 993   DALI_TEST_CHECK( value );
 994   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 995
 996   END_TEST;
 997 }
 998
 999 //Mesh visual
1000 int UtcDaliVisualGetPropertyMap8(void)
1001 {
1002   ToolkitTestApplication application;
1003   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
1004
1005   //Request MeshVisual using a property map.
1006   VisualFactory factory = VisualFactory::Get();
1007   Property::Map propertyMap;
1008   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1009   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLUE );
1010   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1011   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1012   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
1013   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1014   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
1015   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
1016
1017   Property::Map resultMap;
1018   meshVisual.CreatePropertyMap( resultMap );
1019   TestMixColor( meshVisual, Visual::Property::MIX_COLOR, Color::BLUE );
1020
1021   //Check values in the result map are identical to the initial map's values.
1022   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1023   DALI_TEST_CHECK( value );
1024   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
1025
1026   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
1027   DALI_TEST_CHECK( value );
1028   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
1029
1030   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
1031   DALI_TEST_CHECK( value );
1032   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
1033
1034   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
1035   DALI_TEST_CHECK( value );
1036   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
1037
1038   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
1039   DALI_TEST_CHECK( value );
1040   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
1041
1042   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1043   DALI_TEST_CHECK( value );
1044   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1045
1046  END_TEST;
1047 }
1048
1049 //Primitive shape visual
1050 int UtcDaliVisualGetPropertyMap9(void)
1051 {
1052   ToolkitTestApplication application;
1053   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
1054
1055   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
1056   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
1057
1058   //Request PrimitiveVisual using a property map.
1059   VisualFactory factory = VisualFactory::Get();
1060   Property::Map propertyMap;
1061   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1062   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1063   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
1064   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1065   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1066   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1067   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1068   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1069   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
1070   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
1071   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
1072   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
1073   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
1074   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
1075
1076   Property::Map resultMap;
1077   primitiveVisual.CreatePropertyMap( resultMap );
1078
1079   //Check values in the result map are identical to the initial map's values.
1080   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1081   DALI_TEST_CHECK( value );
1082   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
1083
1084   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
1085   DALI_TEST_CHECK( value );
1086   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
1087
1088   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
1089   DALI_TEST_CHECK( value );
1090   DALI_TEST_CHECK( value->Get<Vector4>() == color );
1091   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1092
1093   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
1094   DALI_TEST_CHECK( value );
1095   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
1096
1097   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
1098   DALI_TEST_CHECK( value );
1099   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
1100
1101   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
1102   DALI_TEST_CHECK( value );
1103   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1104
1105   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
1106   DALI_TEST_CHECK( value );
1107   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1108
1109   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
1110   DALI_TEST_CHECK( value );
1111   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1112
1113   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
1114   DALI_TEST_CHECK( value );
1115   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1116
1117   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
1118   DALI_TEST_CHECK( value );
1119   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1120
1121   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
1122   DALI_TEST_CHECK( value );
1123   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1124
1125   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
1126   DALI_TEST_CHECK( value );
1127   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1128
1129   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1130   DALI_TEST_CHECK( value );
1131   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1132
1133   END_TEST;
1134 }
1135
1136 //Text shape visual
1137 int UtcDaliVisualGetPropertyMap10(void)
1138 {
1139   ToolkitTestApplication application;
1140   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
1141
1142   //Request PrimitiveVisual using a property map.
1143   VisualFactory factory = VisualFactory::Get();
1144
1145   Property::Map propertyMap;
1146   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1147   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLACK );
1148   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
1149   propertyMap.Insert( "enableMarkup", false );
1150   propertyMap.Insert( "text", "Hello world" );
1151   propertyMap.Insert( "fontFamily", "TizenSans" );
1152
1153   Property::Map fontStyleMapSet;
1154   fontStyleMapSet.Insert( "weight", "bold" );
1155   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1156
1157   propertyMap.Insert( "pointSize", 12.f );
1158   propertyMap.Insert( "multiLine", true );
1159   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1160   propertyMap.Insert( "verticalAlignment", "CENTER" );
1161   propertyMap.Insert( "textColor", Color::RED );
1162
1163   Property::Map shadowMapSet;
1164   propertyMap.Insert( "shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f) );
1165
1166   Property::Map underlineMapSet;
1167   propertyMap.Insert( "underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1) );
1168
1169   Property::Map outlineMapSet;
1170   propertyMap.Insert( "outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1) );
1171
1172   Property::Map backgroundMapSet;
1173   propertyMap.Insert( "textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN) );
1174
1175   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1176
1177   Property::Map resultMap;
1178   textVisual.CreatePropertyMap( resultMap );
1179
1180   //Check values in the result map are identical to the initial map's values.
1181   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1182   DALI_TEST_CHECK( value );
1183   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION );
1184
1185   value = resultMap.Find( Visual::Property::MIX_COLOR, Property::VECTOR4 );
1186   DALI_TEST_CHECK( value );
1187   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1188
1189   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1190   DALI_TEST_CHECK( value );
1191   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1192
1193   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1194   DALI_TEST_CHECK( value );
1195   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1196
1197   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1198   DALI_TEST_CHECK( value );
1199
1200   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1201   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1202   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1203
1204   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1205   DALI_TEST_CHECK( value );
1206   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1207
1208   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1209   DALI_TEST_CHECK( value );
1210   DALI_TEST_CHECK( value->Get<bool>() );
1211
1212   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER );
1213   DALI_TEST_CHECK( value );
1214   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION );
1215
1216   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER );
1217   DALI_TEST_CHECK( value );
1218   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION );
1219
1220   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1221   DALI_TEST_CHECK( value );
1222   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1223
1224   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1225   DALI_TEST_CHECK( value );
1226   DALI_TEST_CHECK( !value->Get<bool>() );
1227
1228   value = resultMap.Find( TextVisual::Property::SHADOW, Property::MAP );
1229   DALI_TEST_CHECK( value );
1230
1231   Property::Map shadowMapGet = value->Get<Property::Map>();
1232   DALI_TEST_EQUALS( shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION );
1233   DALI_TEST_EQUALS( DaliTestCheckMaps( shadowMapGet, shadowMapSet ), true, TEST_LOCATION );
1234
1235   value = resultMap.Find( TextVisual::Property::UNDERLINE, Property::MAP );
1236   DALI_TEST_CHECK( value );
1237
1238   Property::Map underlineMapGet = value->Get<Property::Map>();
1239   DALI_TEST_EQUALS( underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION );
1240   DALI_TEST_EQUALS( DaliTestCheckMaps( underlineMapGet, underlineMapSet ), true, TEST_LOCATION );
1241
1242   value = resultMap.Find( DevelTextVisual::Property::OUTLINE, Property::MAP );
1243   DALI_TEST_CHECK( value );
1244
1245   Property::Map outlineMapGet = value->Get<Property::Map>();
1246   DALI_TEST_EQUALS( outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION );
1247   DALI_TEST_EQUALS( DaliTestCheckMaps( outlineMapGet, outlineMapSet ), true, TEST_LOCATION );
1248
1249   value = resultMap.Find( DevelTextVisual::Property::BACKGROUND, Property::MAP );
1250   DALI_TEST_CHECK( value );
1251
1252   Property::Map backgroundMapGet = value->Get<Property::Map>();
1253   DALI_TEST_EQUALS( backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION );
1254   DALI_TEST_EQUALS( DaliTestCheckMaps( backgroundMapGet, backgroundMapSet ), true, TEST_LOCATION );
1255
1256   END_TEST;
1257 }
1258
1259 int UtcDaliVisualGetPropertyMap11(void)
1260 {
1261   ToolkitTestApplication application;
1262   tet_infoline( "UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual" );
1263
1264   VisualFactory factory = VisualFactory::Get();
1265   DALI_TEST_CHECK( factory );
1266
1267   Property::Map propertyMap;
1268   propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1269
1270   Vector2 start(-0.5f, 0.5f);
1271   Vector2 end  (0.5f, -0.0f);
1272   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1273   Vector4 end_color  (0.7f, 0.5f, 1.0f, 1.0f);
1274   Vector2 rotate_center(0.0f, 0.4f);
1275   float rotate_amount = 1.57f;
1276   float offset = 100.f;
1277
1278   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::RADIAL);
1279   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1280   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::CLAMP);
1281
1282   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION,  start);
1283   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,  end);
1284   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,  start_color);
1285   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,  end_color);
1286   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  rotate_center);
1287   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  rotate_amount);
1288   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,  offset);
1289
1290   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1291   DALI_TEST_CHECK( animatedGradientVisual );
1292
1293   Property::Map resultMap;
1294   animatedGradientVisual.CreatePropertyMap( resultMap );
1295
1296   // check the property values from the returned map from visual
1297   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1298   DALI_TEST_CHECK( value );
1299   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1300
1301   value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1302   DALI_TEST_CHECK( value );
1303   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1304
1305   value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1306   DALI_TEST_CHECK( value );
1307   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1308
1309   value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1310   DALI_TEST_CHECK( value );
1311   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP );
1312
1313
1314   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1315   DALI_TEST_CHECK( value );
1316   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1317
1318   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1319   DALI_TEST_CHECK( value );
1320   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1321
1322   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1323   DALI_TEST_CHECK( value );
1324   DALI_TEST_EQUALS( value->Get<Vector4>(), start_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1325
1326   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1327   DALI_TEST_CHECK( value );
1328   DALI_TEST_EQUALS( value->Get<Vector4>(), end_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1329
1330   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1331   DALI_TEST_CHECK( value );
1332   DALI_TEST_EQUALS( value->Get<Vector2>(), rotate_center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1333
1334   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1335   DALI_TEST_CHECK( value );
1336   DALI_TEST_EQUALS( value->Get<float>(), rotate_amount , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1337
1338   value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1339   DALI_TEST_CHECK( value );
1340   DALI_TEST_EQUALS( value->Get<float>(), offset , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1341
1342   END_TEST;
1343 }
1344
1345 int UtcDaliVisualGetPropertyMap12(void)
1346 {
1347   ToolkitTestApplication application;
1348   tet_infoline( "UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param" );
1349
1350   // Case 1 : Set values by index
1351   {
1352     tet_printf( " - Set Values by Index\n" );
1353     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1354     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1355     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1356     {
1357       tet_printf( "test with delay [%f]\n", _delay );
1358       VisualFactory factory = VisualFactory::Get();
1359       DALI_TEST_CHECK( factory );
1360
1361       Property::Map propertyMap;
1362       Property::Map animationMap;
1363       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1364
1365       float duration = 1.1f;
1366       float delay = _delay;
1367       float repeat_delay = 0.4f;
1368
1369       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1370       int loop_count = 5;
1371       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1372       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1373
1374       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1375       {
1376         animationMap.Clear();
1377         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1378         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1379         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1380         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1381         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1382         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1383         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1384         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1385         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1386
1387         return animationMap;
1388       };
1389
1390       Vector2 start1(-0.5f, 0.5f);
1391       Vector2 end1  (0.5f, -0.5f);
1392       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1393       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1394       Vector2 rotate_center1(0.0f, 0.4f);
1395       float rotate_amount1 = 0.0f;
1396       float offset1 = 0.f;
1397
1398       Vector2 start2(-0.5f, -0.5f);
1399       Vector2 end2  (0.5f, 0.5f);
1400       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1401       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1402       Vector2 rotate_center2(0.0f, -0.4f);
1403       float rotate_amount2 = 6.2832f;
1404       float offset2 = 2.f;
1405
1406       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1407       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1408       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REPEAT);
1409
1410       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1411       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1412       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1413       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1414       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1415       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1416       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1417
1418       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1419       DALI_TEST_CHECK( animatedGradientVisual );
1420
1421       Property::Map resultMap;
1422       animatedGradientVisual.CreatePropertyMap( resultMap );
1423
1424       // check the property values from the returned map from visual
1425       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1426       DALI_TEST_CHECK( value );
1427       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1428
1429       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1430       DALI_TEST_CHECK( value );
1431       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1432
1433       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1434       DALI_TEST_CHECK( value );
1435       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1436
1437       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1438       DALI_TEST_CHECK( value );
1439       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT );
1440
1441       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
1442       {
1443         tet_printf("Check value at %d\n", line_num);
1444         value = resultMap.Find( index, Property::MAP );
1445         DALI_TEST_CHECK( value );
1446         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1447         Property::Map *temp_map = value->GetMap();
1448         DALI_TEST_CHECK( temp_map );
1449
1450         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1451         {
1452           Property::Value *res = temp_map->Find( index );
1453           DALI_TEST_CHECK( res );
1454           return *res;
1455         };
1456
1457         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1458         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1459         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1460         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1461         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1462         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1463         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1464         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1465         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1466       };
1467
1468       // check the animation map data is good
1469       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1470       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1471       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1472       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1473       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1474       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1475       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1476     }
1477   }
1478
1479   // Case 2 : Set values by string
1480   {
1481     tet_printf( " - Set Values by String\n" );
1482     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1483     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1484     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1485     {
1486       tet_printf( "test with delay [%f]\n", _delay );
1487       VisualFactory factory = VisualFactory::Get();
1488       DALI_TEST_CHECK( factory );
1489
1490       Property::Map propertyMap;
1491       Property::Map animationMap;
1492       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1493
1494       float duration = 1.1f;
1495       float delay = _delay;
1496       float repeat_delay = 0.4f;
1497
1498       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1499       int loop_count = 5;
1500       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1501       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1502
1503       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value &start, const Property::Value &target)->Property::Map&
1504       {
1505         animationMap.Clear();
1506         animationMap.Insert("startValue"   , start);
1507         animationMap.Insert("targetValue"  , target);
1508         animationMap.Insert("directionType", "BACKWARD");
1509         animationMap.Insert("duration"     , duration);
1510         animationMap.Insert("delay"        , delay);
1511         animationMap.Insert("repeat"       , loop_count);
1512         animationMap.Insert("repeatDelay"  , repeat_delay);
1513         animationMap.Insert("motionType"   , "MIRROR");
1514         animationMap.Insert("easingType"   , "IN_OUT");
1515
1516         return animationMap;
1517       };
1518
1519       Vector2 start1(-0.5f, 0.5f);
1520       Vector2 end1  (0.5f, -0.5f);
1521       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1522       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1523       Vector2 rotate_center1(0.0f, 0.4f);
1524       float rotate_amount1 = 0.0f;
1525       float offset1 = 0.f;
1526
1527       Vector2 start2(-0.5f, -0.5f);
1528       Vector2 end2  (0.5f, 0.5f);
1529       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1530       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1531       Vector2 rotate_center2(0.0f, -0.4f);
1532       float rotate_amount2 = 6.2832f;
1533       float offset2 = 2.f;
1534
1535       // For test mix the type string/index key and string/index value works well.
1536       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  "RADIAL");
1537       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1538       propertyMap.Insert("spreadType"  , DevelAnimatedGradientVisual::SpreadType::REFLECT);
1539
1540       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ));
1541       propertyMap.Insert("endPosition"  , buildAnimatedMap(end1          , end2          ));
1542       propertyMap.Insert("startColor"   , buildAnimatedMap(start_color1  , start_color2  ));
1543       propertyMap.Insert("endColor"     , buildAnimatedMap(end_color1    , end_color2    ));
1544       propertyMap.Insert("rotateCenter" , buildAnimatedMap(rotate_center1, rotate_center2));
1545       propertyMap.Insert("rotateAmount" , buildAnimatedMap(rotate_amount1, rotate_amount2));
1546       propertyMap.Insert("offset"       , buildAnimatedMap(offset1       , offset2       ));
1547
1548       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1549       DALI_TEST_CHECK( animatedGradientVisual );
1550
1551       Property::Map resultMap;
1552       animatedGradientVisual.CreatePropertyMap( resultMap );
1553
1554       // check the property values from the returned map from visual
1555       // Note : resultMap from CreatePropertyMap only contain indexKey
1556       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1557       DALI_TEST_CHECK( value );
1558       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1559
1560       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1561       DALI_TEST_CHECK( value );
1562       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1563
1564       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1565       DALI_TEST_CHECK( value );
1566       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1567
1568       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1569       DALI_TEST_CHECK( value );
1570       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1571
1572       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
1573       {
1574         tet_printf("Check value at %d\n", line_num);
1575         value = resultMap.Find( index, Property::MAP );
1576         DALI_TEST_CHECK( value );
1577         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1578         Property::Map *temp_map = value->GetMap();
1579         DALI_TEST_CHECK( temp_map );
1580
1581         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1582         {
1583           Property::Value *res = temp_map->Find( index );
1584           DALI_TEST_CHECK( res );
1585           return *res;
1586         };
1587
1588         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1589         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1590         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1591         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1592         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1593         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1594         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1595         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1596         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1597       };
1598
1599       // check the animation map data is good
1600       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1601       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1602       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1603       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1604       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1605       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1606       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1607     }
1608   }
1609
1610   END_TEST;
1611 }
1612 int UtcDaliVisualGetPropertyMap13(void)
1613 {
1614   ToolkitTestApplication application;
1615   tet_infoline( "UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0" );
1616
1617   for(int _direction = 0; _direction <= 1; ++_direction)
1618   {
1619     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1620     {
1621       tet_printf( ((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n") , _delay );
1622       VisualFactory factory = VisualFactory::Get();
1623       DALI_TEST_CHECK( factory );
1624
1625       Property::Map propertyMap;
1626       Property::Map animationMap;
1627       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1628
1629       float duration = 1.0f;
1630       float delay = _delay;
1631       float repeat_delay = 0.5f;
1632
1633       int direction = _direction;
1634       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1635       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1636       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1637
1638       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1639       {
1640         animationMap.Clear();
1641         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1642         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1643         if(direction == 0)animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1644         else animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1645         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1646         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1647         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1648         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1649         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1650         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1651         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1652
1653         return animationMap;
1654       };
1655
1656       Vector2 start1(-0.5f, 0.5f);
1657       Vector2 end1  (0.5f, -0.5f);
1658       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1659       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1660       Vector2 rotate_center1(1.0f, 0.4f);
1661       float rotate_amount1 = 2.0f;
1662       float offset1 = 1.f;
1663
1664       Vector2 start2(-0.5f, -0.5f);
1665       Vector2 end2  (0.5f, 0.5f);
1666       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1667       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1668       Vector2 rotate_center2(1.0f, -0.4f);
1669       float rotate_amount2 = 1.0f;
1670       float offset2 = 3.f;
1671
1672       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1673       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1674       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REFLECT);
1675
1676       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1677       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1678       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1679       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1680       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1681       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1682       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1683
1684       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1685       DALI_TEST_CHECK( animatedGradientVisual );
1686
1687       Property::Map resultMap;
1688       animatedGradientVisual.CreatePropertyMap( resultMap );
1689
1690       // check the property values from the returned map from visual
1691       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1692       DALI_TEST_CHECK( value );
1693       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1694
1695       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1696       DALI_TEST_CHECK( value );
1697       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1698
1699       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1700       DALI_TEST_CHECK( value );
1701       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1702
1703       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1704       DALI_TEST_CHECK( value );
1705       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1706
1707       // If loop_count = 0, Animation doesn't created.
1708       // Optimized resultMap only have one value, which is target value
1709       // Note: target value will be changed by direction option.
1710       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1711       DALI_TEST_CHECK( value );
1712       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? start1 : start2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1713
1714       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1715       DALI_TEST_CHECK( value );
1716       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? end1 : end2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1717
1718       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1719       DALI_TEST_CHECK( value );
1720       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? start_color1 : start_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1721
1722       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1723       DALI_TEST_CHECK( value );
1724       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? end_color1 : end_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1725
1726       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1727       DALI_TEST_CHECK( value );
1728       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1729
1730       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1731       DALI_TEST_CHECK( value );
1732       DALI_TEST_EQUALS( value->Get<float>(), direction ? rotate_amount1 : rotate_amount2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1733
1734       value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1735       DALI_TEST_CHECK( value );
1736       DALI_TEST_EQUALS( value->Get<float>(), direction ? offset1 : offset2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1737     }
1738   }
1739
1740   END_TEST;
1741 }
1742
1743 int UtcDaliVisualAnimateBorderVisual01(void)
1744 {
1745   ToolkitTestApplication application;
1746   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1747
1748   VisualFactory factory = VisualFactory::Get();
1749   Property::Map propertyMap;
1750   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1751   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1752   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1753   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1754   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1755
1756   Property::Map map;
1757   map["target"] = "testVisual";
1758   map["property"] = "mixColor";
1759   map["targetValue"] = Vector4(1,1,1,0.1);
1760   map["animator"] = Property::Map()
1761     .Add("alphaFunction", "LINEAR")
1762     .Add("timePeriod", Property::Map()
1763          .Add("delay", 0.0f)
1764          .Add("duration", 4.0f));
1765
1766   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1767
1768   DummyControl actor = DummyControl::New(true);
1769   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1770   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1771   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1772   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1773   application.GetScene().Add(actor);
1774
1775   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1776
1777   Renderer renderer = actor.GetRendererAt(0);
1778   Property::Index borderColorIndex = renderer.GetPropertyIndex( BorderVisual::Property::COLOR );
1779   Property::Index mixColorIndex = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1780
1781   Animation animation = dummyImpl.CreateTransition( transition );
1782
1783   // Animate the mix color through the transition, and the border color through
1784   // programmatic method.
1785   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1786   animation.Play();
1787
1788   application.SendNotification();
1789   application.Render(0);
1790   application.Render(2000u); // halfway point between blue and white
1791
1792   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1793   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1794   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1795   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1796
1797   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1798   testColor = Vector4( 1,1,1,0.45f );
1799   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1800   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1801
1802   Vector4 uColor;
1803   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1804   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1805
1806   application.Render(2000u);
1807
1808   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1809   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1810   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1811
1812   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1813   testColor = Vector4(1,1,1,0.1);
1814   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), TEST_LOCATION );
1815   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1816
1817   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1818   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1819
1820   END_TEST;
1821 }
1822
1823
1824 int UtcDaliVisualAnimateBorderVisual02(void)
1825 {
1826   ToolkitTestApplication application;
1827   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1828
1829   VisualFactory factory = VisualFactory::Get();
1830   Property::Map propertyMap;
1831   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1832   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1833   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1834   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1835
1836   DummyControl actor = DummyControl::New(true);
1837   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1838   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1839   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1840   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1841   application.GetScene().Add(actor);
1842
1843   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1844
1845   Renderer renderer = actor.GetRendererAt(0);
1846   Property::Index index = renderer.GetPropertyIndex( BorderVisual::Property::SIZE );
1847
1848   Animation animation = Animation::New(4.0f);
1849   animation.AnimateTo( Property(renderer, index), 9.0f );
1850   animation.Play();
1851
1852   application.SendNotification();
1853   application.Render(0);
1854   application.Render(2000u); // halfway point
1855
1856   float size = renderer.GetCurrentProperty< float >( index );
1857   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1858   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1859
1860   application.Render(2000u); // halfway point between blue and white
1861
1862   size = renderer.GetCurrentProperty< float >( index );
1863   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1864   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1865
1866   END_TEST;
1867 }
1868
1869 int UtcDaliVisualAnimateColorVisual(void)
1870 {
1871   ToolkitTestApplication application;
1872   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1873
1874   VisualFactory factory = VisualFactory::Get();
1875   Property::Map propertyMap;
1876   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1877   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1878   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1879
1880   DummyControl actor = DummyControl::New(true);
1881   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1882   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1883   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1884   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1885   application.GetScene().Add(actor);
1886
1887   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1888
1889   Renderer renderer = actor.GetRendererAt(0);
1890   Property::Index mixColorIndex = renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1891
1892   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1893   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1894
1895   Animation animation = Animation::New(4.0f);
1896   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1897   animation.Play();
1898
1899   application.SendNotification();
1900   application.Render(0);
1901   application.Render(2000u); // halfway point
1902
1903   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1904   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1905   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1906
1907   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1908
1909   application.Render(2000u); // halfway point between blue and white
1910
1911   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1912   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1913
1914   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1915
1916   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1917   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1918
1919   END_TEST;
1920 }
1921
1922 int UtcDaliVisualAnimatePrimitiveVisual(void)
1923 {
1924   ToolkitTestApplication application;
1925   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1926
1927   {
1928     VisualFactory factory = VisualFactory::Get();
1929     Property::Map propertyMap;
1930     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1931     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1932     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1933     Visual::Base visual = factory.CreateVisual( propertyMap );
1934
1935     DummyControl actor = DummyControl::New(true);
1936     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1937     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1938     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1939     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1940     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
1941     application.GetScene().Add(actor);
1942
1943     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1944
1945     Renderer renderer = actor.GetRendererAt(0);
1946     Property::Index index = renderer.GetPropertyIndex( PrimitiveVisual::Property::MIX_COLOR );
1947
1948     tet_infoline("Test that the renderer has the Primitive mix color");
1949     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1950
1951     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1952     const Vector4 TARGET_MIX_COLOR( Color::RED );
1953
1954     Property::Map map;
1955     map["target"] = "testVisual";
1956     map["property"] = "mixColor";
1957     map["initialValue"] = INITIAL_MIX_COLOR;
1958     map["targetValue"] = TARGET_MIX_COLOR;
1959     map["animator"] = Property::Map()
1960       .Add("alphaFunction", "LINEAR")
1961       .Add("timePeriod", Property::Map()
1962            .Add("delay", 0.0f)
1963            .Add("duration", 4.0f));
1964
1965     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1966
1967     Animation animation = dummyImpl.CreateTransition( transition );
1968     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1969     animation.Play();
1970
1971     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1972     glAbstraction.EnableEnableDisableCallTrace( true );
1973     TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1974     std::ostringstream blendStr;
1975     blendStr << std::hex << GL_BLEND;
1976
1977     application.SendNotification();
1978     application.Render(0);
1979     application.Render(2000u); // halfway point
1980     application.SendNotification();
1981
1982     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1983     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a )), true, TEST_LOCATION );
1984     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1985
1986     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
1987
1988     glEnableStack.Reset();
1989
1990     application.Render(2001u); // go past end
1991     application.SendNotification(); // Trigger signals
1992
1993     DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
1994     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4( 1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a ) ), true, TEST_LOCATION );
1995     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1996
1997     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
1998
1999     actor.Unparent();
2000   }
2001
2002   END_TEST;
2003 }
2004
2005 int UtcDaliVisualAnimatedGradientVisual01(void)
2006 {
2007   ToolkitTestApplication application;
2008   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
2009
2010   {
2011     VisualFactory factory = VisualFactory::Get();
2012     Property::Map propertyMap;
2013     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2014     Visual::Base visual = factory.CreateVisual( propertyMap );
2015
2016     DummyControl actor = DummyControl::New(true);
2017     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2018     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2019     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2020     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2021     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2022     application.GetScene().Add(actor);
2023
2024     application.SendNotification();
2025     application.Render(0);
2026     application.SendNotification();
2027
2028     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2029
2030     for(int step_iter = 0; step_iter < 3; step_iter++)
2031     {
2032       application.SendNotification();
2033       application.Render(0);
2034       application.Render(750u); // step i/4
2035       application.SendNotification();
2036
2037       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
2038       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
2039       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2040       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2041       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
2042       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
2043       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
2044     }
2045
2046     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2047     application.Render(750u); // go to end
2048     application.SendNotification();
2049
2050     application.Render(10u); // finish
2051     application.SendNotification();
2052
2053     actor.Unparent();
2054     application.SendNotification();
2055     application.Render(0u);
2056     application.SendNotification();
2057   }
2058
2059   END_TEST;
2060 }
2061
2062 int UtcDaliVisualAnimatedGradientVisual02(void)
2063 {
2064   ToolkitTestApplication application;
2065   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
2066
2067   {
2068     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
2069     int _direction[2] = {0, 1};
2070     int _loop_count[3] = {-1, 0, 1};
2071     int _motion[2] = {0, 1};
2072     int _easing[4] = {0, 1, 2, 3};
2073
2074     int test_case_max = 4 * 2 * 3 * 2 * 4;
2075     int test_case = 0;
2076     int test_case_d = 7; // 7 is the number of animated properties.
2077
2078     float _duration = 0.4f;
2079     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2080     float noise_maker = 0.0f;
2081     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2082     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2083     {
2084       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2085
2086       VisualFactory factory = VisualFactory::Get();
2087       Property::Map propertyMap;
2088       Property::Map animationMap;
2089       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2090
2091       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2092       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2093       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2094
2095       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&
2096       {
2097         int tc = (test_case + tc_offset);
2098         int idx_easing = tc % 4; tc /= 4;
2099         int idx_motion = tc % 2; tc /= 2;
2100         int idx_loop_count = tc % 3; tc /= 3;
2101         int idx_direction = tc % 2; tc /= 2;
2102         int idx_delay = tc % 4; tc /= 4;
2103
2104         float duration = _duration - _repeat_delay;
2105         float repeat_delay = _repeat_delay;
2106         float delay = _delay[idx_delay] * _duration;
2107         int direction = _direction[idx_direction];
2108         int loop_count = _loop_count[idx_loop_count];
2109         int motion = _motion[idx_motion];
2110         int easing = _easing[idx_easing];
2111
2112         animationMap.Clear();
2113         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
2114         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
2115         if( direction == 0 )
2116         {
2117           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2118         }
2119         else
2120         {
2121           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2122         }
2123         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2124         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2125         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2126         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2127         if( motion == 0 )
2128         {
2129           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2130         }
2131         else
2132         {
2133           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2134         }
2135         if( easing == 0 )
2136         {
2137           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2138         }
2139         else if( easing == 1 )
2140         {
2141           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2142         }
2143         else if( easing == 2 )
2144         {
2145           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2146         }
2147         else
2148         {
2149           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2150         }
2151
2152         return animationMap;
2153       };
2154
2155       // Give different values for debuging
2156       noise_maker += 1.0f;
2157       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2158       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2159       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2160       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2161       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2162       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2163       float offset1 = 0.f + noise_maker * 0.1f;
2164
2165       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2166       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2167       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2168       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2169       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2170       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2171       float offset2 = 2.f + noise_maker * 0.1f;
2172
2173       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2174       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2175       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2176
2177       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2178       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2179       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2180       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2181       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2182       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2183       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2184
2185       Visual::Base visual = factory.CreateVisual( propertyMap );
2186
2187       DummyControl actor = DummyControl::New( true );
2188       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2189       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2190       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2191       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2192       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2193       application.GetScene().Add(actor);
2194
2195       application.SendNotification();
2196       application.Render( 0 );
2197       application.SendNotification();
2198
2199       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2200
2201       application.SendNotification();
2202
2203       //Compare between CPU calculated value and Shader Visual calculated value
2204       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
2205       {
2206         int tc = (test_case + tc_offset);
2207         int idx_easing = tc % 4; tc /= 4;
2208         int idx_motion = tc % 2; tc /= 2;
2209         int idx_loop_count = tc % 3; tc /= 3;
2210         int idx_direction = tc % 2; tc /= 2;
2211         int idx_delay = tc % 4; tc /= 4;
2212
2213         float duration = _duration - _repeat_delay;
2214         float repeat_delay = _repeat_delay;
2215         float delay = _delay[idx_delay] * _duration;
2216         int direction = _direction[idx_direction];
2217         int loop_count = _loop_count[idx_loop_count];
2218         int motion = _motion[idx_motion];
2219         int easing = _easing[idx_easing];
2220
2221         progress -= delay / _duration;
2222
2223         Property::Value s = start;
2224         Property::Value t = target;
2225         if( direction == 1 )
2226         {
2227           s = target;
2228           t = start;
2229         }
2230         float x; ///< Animator progress value
2231         if( loop_count == 0 )
2232         {
2233           x = 1.0f;
2234         }
2235         else if( loop_count > 0 && progress + 0.01f > loop_count )
2236         {
2237           x = ( motion == 0 ) ? 1.0f : 0.0f;
2238         }
2239         else
2240         {
2241           if( progress < 0.0f )
2242           {
2243             progress = 0.0f;
2244           }
2245           progress = fmodf( progress, 1.0f );
2246           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2247
2248           x = progress;
2249           if( motion == 1 )
2250           {
2251             x = progress * 2.0f;
2252             if( x > 1.0f )
2253             {
2254               x = 2.0f - x;
2255             }
2256           }
2257
2258           if( easing == 1 ) // EASE_IN
2259           {
2260             x = x*x;
2261           }
2262           else if( easing == 2 ) // EASE_OUT
2263           {
2264             x = 2.0f*x - x*x;
2265           }
2266           else if( easing == 3 ) // EASE_IN_OUT
2267           {
2268             x = x * x * (3.0f - 2.0f * x);
2269           }
2270         }
2271         if( value_type == 0 ) // result type is Float
2272         {
2273           float res;
2274           float cur;
2275           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2276           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2277           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2278         }
2279         else if( value_type == 1 ) // result type is Vector2
2280         {
2281           Vector2 res;
2282           Vector2 cur;
2283           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2284           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2285           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2286         }
2287         else if( value_type == 2 ) // result type is Vector3
2288         {
2289           Vector3 res;
2290           Vector3 cur;
2291           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2292           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2293           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2294         }
2295         else // result type is Vector4
2296         {
2297           Vector4 res;
2298           Vector4 cur;
2299           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2300           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2301           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2302         }
2303       };
2304
2305       float step = 0.0f;
2306       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2307       {
2308         for( int step_iter = 0; step_iter < 3; step_iter++ )
2309         {
2310           application.SendNotification();
2311           application.Render( _duration * 250.f );  // step i/4
2312           application.SendNotification();
2313           step += 0.25f;
2314
2315           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2316           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2317           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2318           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2319           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2320           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2321           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2322         }
2323         application.SendNotification();
2324         application.Render(_duration * 250.f);  // step 4/4 will not test
2325         application.SendNotification();
2326         step += 0.25f;
2327       }
2328
2329       application.SendNotification();
2330       actor.Unparent();
2331       application.SendNotification();
2332       application.Render(10.f);  // tempral time
2333       application.SendNotification();
2334     }
2335   }
2336
2337   END_TEST;
2338 }
2339
2340 int UtcDaliVisualAnimatedGradientVisual03(void)
2341 {
2342   ToolkitTestApplication application;
2343   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2344
2345   {
2346     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
2347     int _direction[2] = {0, 1};
2348     int _loop_count[3] = {-1, 0, 1};
2349     int _motion[2] = {0, 1};
2350     int _easing[4] = {0, 1, 2, 3};
2351
2352     int test_case_max = 4 * 2 * 3 * 2 * 4;
2353     int test_case = 0;
2354     int test_case_d = 7; // 7 is the number of animated properties.
2355
2356     float _duration = 0.4f;
2357     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2358     float noise_maker = 0.2f;
2359     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2360     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2361     {
2362       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2363
2364       VisualFactory factory = VisualFactory::Get();
2365       Property::Map propertyMap;
2366       Property::Map animationMap;
2367       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2368
2369       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&
2370       {
2371         int tc = (test_case + tc_offset);
2372         int idx_easing = tc % 4; tc /= 4;
2373         int idx_motion = tc % 2; tc /= 2;
2374         int idx_loop_count = tc % 3; tc /= 3;
2375         int idx_direction = tc % 2; tc /= 2;
2376         int idx_delay = tc % 4; tc /= 4;
2377
2378         float duration = _duration - _repeat_delay;
2379         float repeat_delay = _repeat_delay;
2380         float delay = _delay[idx_delay] * _duration;
2381         int direction = _direction[idx_direction];
2382         int loop_count = _loop_count[idx_loop_count];
2383         int motion = _motion[idx_motion];
2384         int easing = _easing[idx_easing];
2385
2386         animationMap.Clear();
2387         animationMap.Insert( "startValue", start );
2388         animationMap.Insert( "targetValue", target );
2389         if( direction == 0 )
2390         {
2391           animationMap.Insert("directionType", "FORWARD");
2392         }
2393         else
2394         {
2395           animationMap.Insert("directionType", "BACKWARD");
2396         }
2397         animationMap.Insert("duration", duration);
2398         animationMap.Insert("delay", delay);
2399         animationMap.Insert("repeat", loop_count);
2400         animationMap.Insert("repeatDelay", repeat_delay);
2401         if( motion == 0 )
2402         {
2403           animationMap.Insert("motionType", "LOOP");
2404         }
2405         else
2406         {
2407           animationMap.Insert("motionType", "MIRROR");
2408         }
2409         if( easing == 0 )
2410         {
2411           animationMap.Insert("easingType", "LINEAR");
2412         }
2413         else if( easing == 1 )
2414         {
2415           animationMap.Insert("easingType", "IN");
2416         }
2417         else if( easing == 2 )
2418         {
2419           animationMap.Insert("easingType", "OUT");
2420         }
2421         else
2422         {
2423           animationMap.Insert("easingType", "IN_OUT");
2424         }
2425
2426         return animationMap;
2427       };
2428
2429       // Give different values for debuging
2430       noise_maker += 0.8f;
2431       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2432       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2433       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2434       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2435       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2436       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2437       float offset1 = 0.f + noise_maker * 0.1f;
2438
2439       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2440       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2441       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2442       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2443       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2444       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2445       float offset2 = 2.f + noise_maker * 0.1f;
2446
2447       propertyMap.Insert("gradientType", "LINEAR");
2448       propertyMap.Insert("unitType",     "USER_SPACE");
2449       propertyMap.Insert("spreadType",   "CLAMP");
2450
2451       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2452       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2453       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2454       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2455       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2456       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2457       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2458
2459       Visual::Base visual = factory.CreateVisual( propertyMap );
2460
2461       DummyControl actor = DummyControl::New( true );
2462       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2463       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2464       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2465       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2466       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2467       application.GetScene().Add(actor);
2468
2469       application.SendNotification();
2470       application.Render( 0 );
2471       application.SendNotification();
2472
2473       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2474
2475       application.SendNotification();
2476
2477       //Compare between CPU calculated value and Shader Visual calculated value
2478       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
2479       {
2480         int tc = (test_case + tc_offset);
2481         int idx_easing = tc % 4; tc /= 4;
2482         int idx_motion = tc % 2; tc /= 2;
2483         int idx_loop_count = tc % 3; tc /= 3;
2484         int idx_direction = tc % 2; tc /= 2;
2485         int idx_delay = tc % 4; tc /= 4;
2486
2487         float duration = _duration - _repeat_delay;
2488         float repeat_delay = _repeat_delay;
2489         float delay = _delay[idx_delay] * _duration;
2490         int direction = _direction[idx_direction];
2491         int loop_count = _loop_count[idx_loop_count];
2492         int motion = _motion[idx_motion];
2493         int easing = _easing[idx_easing];
2494
2495         progress -= delay / _duration;
2496
2497         Property::Value s = start;
2498         Property::Value t = target;
2499         if( direction == 1 )
2500         {
2501           s = target;
2502           t = start;
2503         }
2504         float x; ///< Animator progress value
2505         if( loop_count == 0 )
2506         {
2507           x = 1.0f;
2508         }
2509         else if( loop_count > 0 && progress + 0.01f > loop_count )
2510         {
2511           x = ( motion == 0 ) ? 1.0f : 0.0f;
2512         }
2513         else
2514         {
2515           if( progress < 0.0f )
2516           {
2517             progress = 0.0f;
2518           }
2519           progress = fmodf( progress, 1.0f );
2520           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2521
2522           x = progress;
2523           if( motion == 1 )
2524           {
2525             x = progress * 2.0f;
2526             if( x > 1.0f )
2527             {
2528               x = 2.0f - x;
2529             }
2530           }
2531
2532           if( easing == 1 ) // EASE_IN
2533           {
2534             x = x*x;
2535           }
2536           else if( easing == 2 ) // EASE_OUT
2537           {
2538             x = 2.0f*x - x*x;
2539           }
2540           else if( easing == 3 ) // EASE_IN_OUT
2541           {
2542             x = x * x * (3.0f - 2.0f * x);
2543           }
2544         }
2545         if( value_type == 0 ) // result type is Float
2546         {
2547           float res;
2548           float cur;
2549           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2550           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2551           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2552         }
2553         else if( value_type == 1 ) // result type is Vector2
2554         {
2555           Vector2 res;
2556           Vector2 cur;
2557           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2558           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2559           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2560         }
2561         else if( value_type == 2 ) // result type is Vector3
2562         {
2563           Vector3 res;
2564           Vector3 cur;
2565           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2566           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2567           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2568         }
2569         else // result type is Vector4
2570         {
2571           Vector4 res;
2572           Vector4 cur;
2573           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2574           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2575           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2576         }
2577       };
2578
2579       float step = 0.0f;
2580       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2581       {
2582         for( int step_iter = 0; step_iter < 3; step_iter++ )
2583         {
2584           application.SendNotification();
2585           application.Render( _duration * 250.f );  // step i/4
2586           application.SendNotification();
2587           step += 0.25f;
2588
2589           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2590           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2591           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2592           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2593           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2594           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2595           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2596         }
2597         application.SendNotification();
2598         application.Render(_duration * 250.f);  // step 4/4 will not test
2599         application.SendNotification();
2600         step += 0.25f;
2601       }
2602
2603       application.SendNotification();
2604       actor.Unparent();
2605       application.SendNotification();
2606       application.Render(10.f);  // tempral time
2607       application.SendNotification();
2608     }
2609   }
2610
2611   END_TEST;
2612 }
2613
2614 int UtcDaliVisualWireframeVisual(void)
2615 {
2616   ToolkitTestApplication application;
2617
2618   VisualFactory factory = VisualFactory::Get();
2619   Property::Map propertyMap;
2620   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2621
2622   // Create the visual.
2623   Visual::Base visual = factory.CreateVisual( propertyMap );
2624
2625   DALI_TEST_CHECK( visual );
2626
2627   Property::Map resultMap;
2628   visual.CreatePropertyMap( resultMap );
2629
2630   // Check the property values from the returned map from visual
2631   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2632   DALI_TEST_CHECK( value );
2633   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2634
2635   END_TEST;
2636 }
2637
2638 int UtcDaliVisualGetTransform(void)
2639 {
2640   ToolkitTestApplication application;
2641   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2642
2643   VisualFactory factory = VisualFactory::Get();
2644   Property::Map propertyMap;
2645   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2646   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2647   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2648
2649   Dali::Property::Map visualMap;
2650   colorVisual.CreatePropertyMap( visualMap );
2651   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2652   Dali::Property::Map* map = value->GetMap();
2653   DALI_TEST_CHECK( map );
2654
2655   //Test default values
2656   {
2657     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2658     DALI_TEST_CHECK( typeValue );
2659     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2660   }
2661   {
2662     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2663     DALI_TEST_CHECK( typeValue );
2664     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2665   }
2666   {
2667     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2668     DALI_TEST_CHECK( typeValue );
2669     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2670   }
2671   {
2672     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2673     DALI_TEST_CHECK( typeValue );
2674     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2675   }
2676   {
2677     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2678     DALI_TEST_CHECK( typeValue );
2679     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2680   }
2681   {
2682     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2683     DALI_TEST_CHECK( typeValue );
2684     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2685   }
2686   {
2687     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2688     DALI_TEST_CHECK( typeValue );
2689     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2690   }
2691
2692   END_TEST;
2693 }
2694
2695 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2696 {
2697   Property::Map transform;
2698   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2699   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2700   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2701   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2702   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2703   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f) );
2704
2705   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2706
2707   Dali::Property::Map visualMap;
2708   visual.CreatePropertyMap( visualMap );
2709   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2710   Dali::Property::Map* map = value->GetMap();
2711   DALI_TEST_CHECK( map );
2712
2713   {
2714     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2715     DALI_TEST_CHECK( typeValue );
2716     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2717   }
2718   {
2719     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2720     DALI_TEST_CHECK( typeValue );
2721     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2722   }
2723   {
2724     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2725     DALI_TEST_CHECK( typeValue );
2726     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2727   }
2728   {
2729     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2730     DALI_TEST_CHECK( typeValue );
2731     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2732   }
2733   {
2734     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2735     DALI_TEST_CHECK( typeValue );
2736     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2737   }
2738   {
2739     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2740     DALI_TEST_CHECK( typeValue );
2741     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2742   }
2743   {
2744     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2745     DALI_TEST_CHECK( typeValue );
2746     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(50.0f,50.0f), TEST_LOCATION );
2747   }
2748
2749   //Put the visual on the stage
2750   DummyControl actor = DummyControl::New(true);
2751   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2752   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2753   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2754   application.GetScene().Add(actor);
2755
2756   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2757   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2758
2759   application.SendNotification();
2760   application.Render(0);
2761   Renderer renderer( actor.GetRendererAt(0) );
2762
2763   //Check that the properties have been registered on the Renderer
2764   Property::Index index = renderer.GetPropertyIndex( "offset" );
2765   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2766   Vector2 offset = renderer.GetProperty<Vector2>( index );
2767   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2768
2769   index = renderer.GetPropertyIndex( "size" );
2770   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2771   Vector2 size = renderer.GetProperty<Vector2>( index );
2772   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2773
2774   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2775   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2776   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2777   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2778
2779   index = renderer.GetPropertyIndex( "origin" );
2780   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2781   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2782   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2783
2784   index = renderer.GetPropertyIndex( "anchorPoint" );
2785   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2786   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2787   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2788
2789   index = renderer.GetPropertyIndex( "extraSize" );
2790   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2791   Vector2 extraSize = renderer.GetProperty<Vector2>( index );
2792   DALI_TEST_EQUALS( extraSize, Vector2(50.0f,50.0f), TEST_LOCATION );
2793
2794   //Set a new transform
2795   transform.Clear();
2796   transform = DefaultTransform();
2797   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2798   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2799   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2800   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f) );
2801   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2802   application.SendNotification();
2803   application.Render(0);
2804
2805   //Check that the values have changed in the renderer
2806   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2807   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2808
2809   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2810   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2811
2812   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2813   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2814
2815   //Parent origin and anchor point should have the default values
2816   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2817   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2818
2819   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2820   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2821
2822   extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
2823   DALI_TEST_EQUALS( extraSize, Vector2(0.5f,0.5f), TEST_LOCATION );
2824 }
2825
2826 int UtcDaliVisualSetTransform01(void)
2827 {
2828   ToolkitTestApplication application;
2829   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2830
2831   VisualFactory factory = VisualFactory::Get();
2832   Property::Map propertyMap;
2833   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2834   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2835   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2836   Visual::Base visual = factory.CreateVisual( propertyMap );
2837   TestTransform( application, visual );
2838   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2839
2840   END_TEST;
2841 }
2842
2843 int UtcDaliVisualSetTransform0(void)
2844 {
2845   ToolkitTestApplication application;
2846   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2847
2848   VisualFactory factory = VisualFactory::Get();
2849   Property::Map propertyMap;
2850   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2851   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2852   Visual::Base visual = factory.CreateVisual( propertyMap );
2853   TestTransform( application, visual );
2854   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2855
2856   END_TEST;
2857 }
2858
2859 int UtcDaliVisualSetTransform1(void)
2860 {
2861   ToolkitTestApplication application;
2862   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2863
2864   VisualFactory factory = VisualFactory::Get();
2865   Property::Map propertyMap;
2866   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2867   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2868   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2869   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2870   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
2871   Visual::Base visual = factory.CreateVisual( propertyMap );
2872   TestTransform( application, visual );
2873   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
2874
2875   END_TEST;
2876 }
2877
2878 int UtcDaliVisualSetTransform2(void)
2879 {
2880   ToolkitTestApplication application;
2881   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
2882
2883   VisualFactory factory = VisualFactory::Get();
2884   Property::Map propertyMap;
2885   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
2886   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
2887
2888   Property::Array stopOffsets;
2889   stopOffsets.PushBack( 0.0f );
2890   stopOffsets.PushBack( 0.3f );
2891   stopOffsets.PushBack( 0.6f );
2892   stopOffsets.PushBack( 0.8f );
2893   stopOffsets.PushBack( 1.0f );
2894   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
2895
2896   Property::Array stopColors;
2897   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
2898   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
2899   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
2900   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
2901   stopColors.PushBack( Color::YELLOW );
2902   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
2903   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
2904   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
2905   Visual::Base visual = factory.CreateVisual( propertyMap );
2906   TestTransform( application, visual );
2907   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
2908
2909   END_TEST;
2910 }
2911
2912 int UtcDaliVisualSetTransform3(void)
2913 {
2914   ToolkitTestApplication application;
2915   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
2916
2917   VisualFactory factory = VisualFactory::Get();
2918   Property::Map propertyMap;
2919   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
2920   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
2921   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
2922   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
2923   Visual::Base visual = factory.CreateVisual( propertyMap );
2924   TestTransform( application, visual );
2925   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
2926
2927   END_TEST;
2928 }
2929
2930 int UtcDaliVisualSetTransform4(void)
2931 {
2932   ToolkitTestApplication application;
2933   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
2934
2935   VisualFactory factory = VisualFactory::Get();
2936   Property::Map propertyMap;
2937   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
2938   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
2939
2940   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
2941   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
2942   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
2943   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
2944   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
2945   Visual::Base visual = factory.CreateVisual( propertyMap );
2946   TestTransform( application, visual );
2947   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
2948
2949   END_TEST;
2950 }
2951
2952 int UtcDaliVisualSetTransform5(void)
2953 {
2954   ToolkitTestApplication application;
2955   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
2956
2957   VisualFactory factory = VisualFactory::Get();
2958   Property::Map propertyMap;
2959   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
2960   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
2961   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2962   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
2963   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
2964   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
2965   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
2966   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
2967   Visual::Base visual = factory.CreateVisual(propertyMap);
2968   TestTransform( application, visual );
2969   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
2970
2971   END_TEST;
2972 }
2973
2974 int UtcDaliVisualSetTransform6(void)
2975 {
2976   ToolkitTestApplication application;
2977   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
2978
2979   VisualFactory factory = VisualFactory::Get();
2980   Property::Map propertyMap;
2981   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
2982   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
2983   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
2984   Visual::Base visual = factory.CreateVisual(propertyMap);
2985   TestTransform( application, visual );
2986   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2987
2988   END_TEST;
2989 }
2990
2991 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
2992 {
2993   ToolkitTestApplication application;
2994   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
2995
2996   VisualFactory factory = VisualFactory::Get();
2997   Property::Map propertyMap;
2998   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2999   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3000   Visual::Base visual = factory.CreateVisual( propertyMap );
3001
3002   Property::Map transform;
3003   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
3004                                                  .Add( "RELATIVE" );
3005   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
3006                                                  .Add( "ABSOLUTE" );
3007   visual.SetTransformAndSize( transform, Vector2(100, 100) );
3008
3009   Dali::Property::Map visualMap;
3010   visual.CreatePropertyMap( visualMap );
3011   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
3012   Dali::Property::Map* map = value->GetMap();
3013   DALI_TEST_CHECK( map );
3014
3015   {
3016     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
3017     DALI_TEST_CHECK( typeValue );
3018     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
3019   }
3020   {
3021     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
3022     DALI_TEST_CHECK( typeValue );
3023     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
3024   }
3025
3026   END_TEST;
3027 }
3028
3029 int UtcDaliNPatchVisualCustomShader(void)
3030 {
3031   ToolkitTestApplication application;
3032   tet_infoline( "NPatchVisual with custom shader" );
3033
3034   VisualFactory factory = VisualFactory::Get();
3035   Property::Map properties;
3036   Property::Map shader;
3037   const std::string vertexShader = "Foobar";
3038   const std::string fragmentShader = "Foobar";
3039   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3040   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3041
3042   Property::Map transformMap;
3043   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
3044   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
3045   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
3046   transformMap["anchorPoint"] = Align::CENTER;
3047   transformMap["origin"] = Align::CENTER;
3048   transformMap["extraSize"] = Vector2( 0.0f, 50.0f );
3049   properties[Visual::Property::TRANSFORM] = transformMap;
3050
3051   properties[Visual::Property::TYPE] = Visual::IMAGE;
3052   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3053   properties[Visual::Property::SHADER]=shader;
3054   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3055   properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3056
3057   Visual::Base visual = factory.CreateVisual( properties );
3058   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
3059
3060   // trigger creation through setting on stage
3061   DummyControl dummy = DummyControl::New(true);
3062   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3063   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3064   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
3065   dummy.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
3066   dummy.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
3067   application.GetScene().Add(dummy);
3068   application.SendNotification();
3069
3070   Renderer renderer = dummy.GetRendererAt( 0 );
3071   Shader shader2 = renderer.GetShader();
3072   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3073   Property::Map* map = value.GetMap();
3074   DALI_TEST_CHECK( map );
3075
3076   Property::Index index = renderer.GetPropertyIndex("size");
3077   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
3078
3079   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3080   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
3081
3082   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3083   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
3084
3085   Vector2 extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
3086   DALI_TEST_EQUALS( extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION );
3087
3088   END_TEST;
3089 }
3090
3091 int UtcDaliGradientVisualBlendMode(void)
3092 {
3093   ToolkitTestApplication application;
3094   VisualFactory factory = VisualFactory::Get();
3095
3096   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3097       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3098                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3099                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3100                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3101                                                                                   .Add( Color::GREEN ) ) );
3102
3103   Visual::Base alphaGradientVisual = factory.CreateVisual(
3104       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3105                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3106                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3107                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3108                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
3109
3110   DummyControl control = DummyControl::New(true);
3111   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3112   application.GetScene().Add( control );
3113
3114   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
3115   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
3116   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
3117
3118   application.SendNotification();
3119   application.Render();
3120
3121   // 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
3122   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
3123   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
3124   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
3125
3126   END_TEST;
3127 }
3128
3129 int UtcDaliVisualRendererRemovalAndReAddition(void)
3130 {
3131   ToolkitTestApplication application;
3132   tet_infoline( "UtcDaliVisualRendererRemoval" );
3133
3134   VisualFactory factory = VisualFactory::Get();
3135   Property::Map propertyMap;
3136   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3137   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3138   Visual::Base visual = factory.CreateVisual( propertyMap );
3139
3140   visual.SetDepthIndex( 1 );
3141
3142   DummyControl dummyControl = DummyControl::New(true);
3143   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3144   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3145   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3146
3147   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3148   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
3149
3150   application.GetScene().Add( dummyControl );
3151
3152   application.SendNotification();
3153   application.Render();
3154
3155   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3156
3157   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
3158   application.GetScene().Remove( dummyControl );
3159   application.SendNotification();
3160   application.Render();
3161
3162   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3163
3164   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
3165
3166   application.GetScene().Add( dummyControl );
3167
3168   application.SendNotification();
3169   application.Render();
3170
3171   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3172
3173   END_TEST;
3174 }
3175
3176
3177
3178 int UtcDaliVisualTextVisualRender(void)
3179 {
3180   ToolkitTestApplication application;
3181   tet_infoline( "UtcDaliVisualTextVisualRender" );
3182
3183   VisualFactory factory = VisualFactory::Get();
3184   Property::Map propertyMap;
3185   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3186   propertyMap.Insert( "mixColor", Color::WHITE );
3187   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3188   propertyMap.Insert( "enableMarkup", false );
3189   propertyMap.Insert( "text", "Hello world" );
3190   propertyMap.Insert( "fontFamily", "TizenSans" );
3191
3192   Property::Map fontStyleMapSet;
3193   fontStyleMapSet.Insert( "weight", "bold" );
3194   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3195
3196   propertyMap.Insert( "pointSize", 12.f );
3197   propertyMap.Insert( "multiLine", true );
3198   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3199   propertyMap.Insert( "verticalAlignment", "CENTER" );
3200   propertyMap.Insert( "textColor", Color::RED );
3201   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3202   textVisual.SetDepthIndex( 1 );
3203
3204   DummyControl dummyControl = DummyControl::New(true);
3205   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3206   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3207   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3208
3209   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3210   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3211
3212   application.GetScene().Add( dummyControl );
3213   application.SendNotification();
3214   application.Render();
3215
3216
3217   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3218   propertyMap.Clear();
3219   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3220   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3221   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3222   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3223
3224   Property::Map transformMap;
3225   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3226   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3227
3228   textVisual = factory.CreateVisual( propertyMap );
3229   textVisual.SetDepthIndex( 1 );
3230
3231   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3232   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 720.f, 640.f ) );
3233
3234   application.SendNotification(); // force process events to ensure text visual
3235   // adds renderer to the dummy control in OnRelayout
3236   application.Render();
3237
3238   Renderer renderer = dummyControl.GetRendererAt(0u);
3239   Property::Index index = renderer.GetPropertyIndex("size");
3240
3241   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3242   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3243
3244   END_TEST;
3245 }
3246
3247 int UtcDaliVisualTextVisualDisableEnable(void)
3248 {
3249   ToolkitTestApplication application;
3250   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3251
3252   VisualFactory factory = VisualFactory::Get();
3253   Property::Map propertyMap;
3254   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3255   propertyMap.Insert( "mixColor", Color::WHITE );
3256   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3257   propertyMap.Insert( "enableMarkup", false );
3258   propertyMap.Insert( "text", "Hello world" );
3259   propertyMap.Insert( "fontFamily", "TizenSans" );
3260
3261   Property::Map fontStyleMapSet;
3262   fontStyleMapSet.Insert( "weight", "bold" );
3263   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3264
3265   propertyMap.Insert( "pointSize", 12.f );
3266   propertyMap.Insert( "multiLine", true );
3267   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3268   propertyMap.Insert( "verticalAlignment", "CENTER" );
3269   propertyMap.Insert( "textColor", Color::RED );
3270   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3271   textVisual.SetDepthIndex( 1 );
3272
3273   DummyControl dummyControl = DummyControl::New(true);
3274   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3275   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3276   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3277
3278   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3279   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3280
3281   application.GetScene().Add( dummyControl );
3282   application.SendNotification();
3283   application.Render();
3284
3285   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3286
3287   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3288
3289   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3290
3291   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3292
3293   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3294
3295   END_TEST;
3296 }
3297
3298 int UtcDaliVisualPremultipliedAlpha(void)
3299 {
3300   ToolkitTestApplication application;
3301   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3302
3303   VisualFactory factory = VisualFactory::Get();
3304
3305   // image visual, test default value ( true )
3306   {
3307     Visual::Base imageVisual = factory.CreateVisual(
3308           Property::Map()
3309           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3310           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3311
3312     Dali::Property::Map visualMap;
3313     imageVisual.CreatePropertyMap( visualMap );
3314     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3315
3316     // test values
3317     DALI_TEST_CHECK( value );
3318     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3319   }
3320
3321   // image visual, override premultiplied
3322   {
3323     Visual::Base imageVisual = factory.CreateVisual(
3324           Property::Map()
3325           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3326           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3327           .Add( Visual::Property::PREMULTIPLIED_ALPHA, false ) );
3328
3329     Dali::Property::Map visualMap;
3330     imageVisual.CreatePropertyMap( visualMap );
3331     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3332
3333     // test values
3334     DALI_TEST_CHECK( value );
3335     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION);
3336   }
3337
3338   // svg visual ( premultiplied alpha by default is true )
3339   {
3340     Visual::Base imageVisual = factory.CreateVisual(
3341           Property::Map()
3342           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3343           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3344
3345     Dali::Property::Map visualMap;
3346     imageVisual.CreatePropertyMap( visualMap );
3347     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3348
3349     // test values
3350     DALI_TEST_CHECK( value );
3351     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3352   }
3353
3354   END_TEST;
3355 }
3356
3357 int UtcDaliRegisterVisualOrder(void)
3358 {
3359   ToolkitTestApplication application;
3360   tet_infoline( "Register Visual Order" );
3361
3362   DummyControl dummyControl = DummyControl::New(true);
3363   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3364
3365   VisualFactory factory = VisualFactory::Get();
3366   Property::Map propertyMap;
3367   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3368   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3369
3370   tet_infoline( "Register visual, should have depth index of 0.0f" );
3371   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3372   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3373   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3374
3375   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3376
3377   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3378   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3379   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3380
3381   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3382   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3383   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3384
3385   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3386   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3387   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3388
3389   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3390   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3391   labelVisual.SetDepthIndex( -2000 );
3392   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3393   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3394
3395   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3396   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3397   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3398   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3399   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3400   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3401
3402   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3403   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3404   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3405   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3406   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3407
3408   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3409   application.GetScene().Add( dummyControl );
3410
3411   END_TEST;
3412 }
3413
3414 int UtcDaliRegisterVisualOrder02(void)
3415 {
3416   ToolkitTestApplication application;
3417   tet_infoline( "Register Visual Order with Background Set" );
3418
3419   DummyControl dummyControl = DummyControl::New(true);
3420   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3421
3422   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3423
3424   VisualFactory factory = VisualFactory::Get();
3425   Property::Map propertyMap;
3426   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3427   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3428
3429   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3430
3431   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3432
3433   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3434   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3435   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3436   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3437   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3438
3439   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3440   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3441   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3442   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3443
3444   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3445   application.GetScene().Add( dummyControl );
3446
3447   END_TEST;
3448 }
3449
3450 int UtcDaliRegisterVisualWithDepthIndex(void)
3451 {
3452   ToolkitTestApplication application;
3453   tet_infoline( "Register a Visual With Depth Index" );
3454
3455   DummyControl dummyControl = DummyControl::New(true);
3456   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3457
3458   VisualFactory factory = VisualFactory::Get();
3459   Property::Map propertyMap;
3460   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3461   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3462
3463   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3464   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3465   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3466   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3467   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3468
3469   tet_infoline( "Register another visual with a depth index and it disabled" );
3470   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3471   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3472   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3473   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3474
3475   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3476   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3477   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3478   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3479   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3480
3481   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3482   application.GetScene().Add( dummyControl );
3483
3484   END_TEST;
3485 }
3486
3487 int UtcDaliColorVisualRenderIfTransparentProperty(void)
3488 {
3489   ToolkitTestApplication application;
3490   tet_infoline( "Test the renderIfTransparent property of ColorVisual" );
3491
3492   VisualFactory factory = VisualFactory::Get();
3493   Property::Map propertyMap;
3494   propertyMap.Insert( Visual::Property::TYPE,  Visual::COLOR );
3495   propertyMap.Insert( ColorVisual::Property::MIX_COLOR, Color::BLUE );
3496
3497   tet_infoline( "Check default value" );
3498   {
3499     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3500     Property::Map returnedMap;
3501     testVisual.CreatePropertyMap( returnedMap );
3502
3503     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3504     DALI_TEST_CHECK( renderIfTransparentProperty );
3505     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3506   }
3507
3508   propertyMap.Insert( DevelColorVisual::Property::RENDER_IF_TRANSPARENT, true );
3509
3510   tet_infoline( "Ensure set to value required" );
3511   {
3512     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3513     Property::Map returnedMap;
3514     testVisual.CreatePropertyMap( returnedMap );
3515
3516     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3517     DALI_TEST_CHECK( renderIfTransparentProperty );
3518     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), true, TEST_LOCATION );
3519   }
3520
3521   propertyMap[ DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = Color::BLUE;
3522
3523   tet_infoline( "Ensure it returns default value if set to wrong type" );
3524   {
3525     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3526     Property::Map returnedMap;
3527     testVisual.CreatePropertyMap( returnedMap );
3528
3529     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3530     DALI_TEST_CHECK( renderIfTransparentProperty );
3531     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3532   }
3533
3534   END_TEST;
3535 }
3536
3537 int UtcDaliSvgVisualCustomShader(void)
3538 {
3539   ToolkitTestApplication application;
3540   tet_infoline( "SvgVisual with custom shader" );
3541
3542   VisualFactory factory = VisualFactory::Get();
3543   Property::Map properties;
3544   Property::Map shader;
3545   const std::string vertexShader = "Foobar";
3546   const std::string fragmentShader = "Foobar";
3547   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3548   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3549
3550   properties[Visual::Property::TYPE] = Visual::IMAGE;
3551   properties[Visual::Property::SHADER] = shader;
3552   properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3553
3554   Visual::Base visual = factory.CreateVisual( properties );
3555
3556   // trigger creation through setting on stage
3557   DummyControl dummy = DummyControl::New( true );
3558   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3559   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3560
3561   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3562   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3563   application.GetScene().Add( dummy );
3564
3565   application.SendNotification();
3566   application.Render();
3567
3568   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3569
3570   Renderer renderer = dummy.GetRendererAt( 0 );
3571   Shader shader2 = renderer.GetShader();
3572   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3573   Property::Map* map = value.GetMap();
3574   DALI_TEST_CHECK( map );
3575
3576   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3577   DALI_TEST_EQUALS( fragmentShader, fragment->Get< std::string >(), TEST_LOCATION );
3578
3579   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3580   DALI_TEST_EQUALS( vertexShader, vertex->Get< std::string >(), TEST_LOCATION );
3581
3582   END_TEST;
3583 }
3584
3585 int UtcDaliVisualRoundedCorner(void)
3586 {
3587   ToolkitTestApplication application;
3588   tet_infoline( "UtcDaliVisualRoundedCorner" );
3589
3590   // image visual
3591   {
3592     VisualFactory factory = VisualFactory::Get();
3593     Property::Map properties;
3594     float cornerRadius = 30.0f;
3595
3596     properties[Visual::Property::TYPE] = Visual::IMAGE;
3597     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3598     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3599
3600     Visual::Base visual = factory.CreateVisual( properties );
3601
3602     // trigger creation through setting on stage
3603     DummyControl dummy = DummyControl::New( true );
3604     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3605     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3606
3607     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3608     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3609     application.GetScene().Add( dummy );
3610
3611     application.SendNotification();
3612     application.Render();
3613
3614     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3615
3616     application.SendNotification();
3617     application.Render();
3618
3619     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3620     // Default corner radius policy is absolute.
3621     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3622   }
3623
3624   // color visual 1
3625   {
3626     VisualFactory factory = VisualFactory::Get();
3627     Property::Map properties;
3628     float cornerRadius = 30.0f;
3629
3630     properties[Visual::Property::TYPE] = Visual::COLOR;
3631     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3632     properties["cornerRadius"] = cornerRadius;
3633     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3634
3635     Visual::Base visual = factory.CreateVisual( properties );
3636
3637     // trigger creation through setting on stage
3638     DummyControl dummy = DummyControl::New( true );
3639     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3640     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3641
3642     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3643     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3644     application.GetScene().Add( dummy );
3645
3646     application.SendNotification();
3647     application.Render();
3648
3649     application.SendNotification();
3650     application.Render();
3651
3652     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3653     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3654   }
3655
3656   // color visual 2
3657   {
3658     VisualFactory factory = VisualFactory::Get();
3659     Property::Map properties;
3660     float cornerRadius = 0.5f;
3661
3662     properties[Visual::Property::TYPE] = Visual::COLOR;
3663     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3664     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3665     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3666
3667     Visual::Base visual = factory.CreateVisual( properties );
3668
3669     // trigger creation through setting on stage
3670     DummyControl dummy = DummyControl::New( true );
3671     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3672     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3673
3674     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3675     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3676     application.GetScene().Add( dummy );
3677
3678     application.SendNotification();
3679     application.Render();
3680
3681     application.SendNotification();
3682     application.Render();
3683
3684     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3685     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3686   }
3687
3688   // color visual 3 - invalid value
3689   {
3690     VisualFactory factory = VisualFactory::Get();
3691     Property::Map properties;
3692     float cornerRadius = 30.0f;
3693
3694     properties[Visual::Property::TYPE] = Visual::COLOR;
3695     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3696     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3697     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3698
3699     Visual::Base visual = factory.CreateVisual( properties );
3700
3701     // trigger creation through setting on stage
3702     DummyControl dummy = DummyControl::New( true );
3703     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3704     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3705
3706     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3707     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3708     application.GetScene().Add( dummy );
3709
3710     application.SendNotification();
3711     application.Render();
3712
3713     application.SendNotification();
3714     application.Render();
3715
3716     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3717     // Default corner radius policy is absolute.
3718     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3719   }
3720
3721   // gradient visual
3722   {
3723     VisualFactory factory = VisualFactory::Get();
3724     Property::Map properties;
3725     float cornerRadius = 30.0f;
3726
3727     properties[Visual::Property::TYPE] = Visual::GRADIENT;
3728     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3729     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3730     properties[GradientVisual::Property::START_POSITION] = Vector2( 0.5f, 0.5f );
3731     properties[GradientVisual::Property::END_POSITION] = Vector2( -0.5f, -0.5f );
3732     properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3733
3734     Property::Array stopOffsets;
3735     stopOffsets.PushBack( 0.0f );
3736     stopOffsets.PushBack( 0.6f );
3737     stopOffsets.PushBack( 1.0f );
3738     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3739
3740     Property::Array stopColors;
3741     stopColors.PushBack( Color::RED );
3742     stopColors.PushBack( Color::YELLOW );
3743     stopColors.PushBack( Color::GREEN );
3744     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3745
3746     Visual::Base visual = factory.CreateVisual( properties );
3747
3748     // trigger creation through setting on stage
3749     DummyControl dummy = DummyControl::New( true );
3750     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3751     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3752
3753     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3754     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3755     application.GetScene().Add( dummy );
3756
3757     application.SendNotification();
3758     application.Render();
3759
3760     application.SendNotification();
3761     application.Render();
3762
3763     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3764     // Default corner radius policy is absolute.
3765     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3766   }
3767
3768   // animated image visual
3769   {
3770     VisualFactory factory = VisualFactory::Get();
3771     Property::Map properties;
3772     float cornerRadius = 24.0f;
3773
3774     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3775     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3776     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius + 10.0f; // Dummy Input
3777     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3778     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3779
3780     Visual::Base visual = factory.CreateVisual( properties );
3781
3782     // trigger creation through setting on stage
3783     DummyControl dummy = DummyControl::New( true );
3784     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3785     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3786
3787     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3788     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3789     application.GetScene().Add( dummy );
3790
3791     application.SendNotification();
3792     application.Render();
3793
3794     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3795
3796     application.SendNotification();
3797     application.Render();
3798
3799     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3800     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3801   }
3802
3803   // vector image visual
3804   {
3805     VisualFactory factory = VisualFactory::Get();
3806     Property::Map properties;
3807     float cornerRadius = 27.0f;
3808
3809     properties[Visual::Property::TYPE] = Visual::SVG;
3810     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3811     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3812
3813     Visual::Base visual = factory.CreateVisual( properties );
3814
3815     // trigger creation through setting on stage
3816     DummyControl dummy = DummyControl::New( true );
3817     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3818     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3819
3820     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3821     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3822     application.GetScene().Add( dummy );
3823
3824     application.SendNotification();
3825     application.Render();
3826
3827     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3828
3829     application.SendNotification();
3830     application.Render();
3831
3832     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3833     // Default corner radius policy is absolute.
3834     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3835   }
3836
3837   // animated vector image visual
3838   {
3839     VisualFactory factory = VisualFactory::Get();
3840     Property::Map properties;
3841     float cornerRadius = 1.3f;
3842
3843     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
3844     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
3845     properties["cornerRadius"] = cornerRadius;
3846     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3847
3848     Visual::Base visual = factory.CreateVisual( properties );
3849
3850     // trigger creation through setting on stage
3851     DummyControl dummy = DummyControl::New( true );
3852     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3853     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3854
3855     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3856     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3857     application.GetScene().Add( dummy );
3858
3859     application.SendNotification();
3860     application.Render();
3861
3862     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3863
3864     application.SendNotification();
3865     application.Render();
3866
3867     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3868     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3869   }
3870
3871
3872   END_TEST;
3873 }
3874
3875 int UtcDaliColorVisualBlurRadius(void)
3876 {
3877   ToolkitTestApplication application;
3878   tet_infoline( "UtcDaliColorVisualBlurRadius" );
3879
3880   VisualFactory factory = VisualFactory::Get();
3881   Property::Map properties;
3882   float blurRadius = 20.0f;
3883
3884   properties[Visual::Property::TYPE] = Visual::COLOR;
3885   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3886   properties["blurRadius"] = blurRadius;
3887
3888   Visual::Base visual = factory.CreateVisual( properties );
3889
3890   // trigger creation through setting on stage
3891   DummyControl dummy = DummyControl::New( true );
3892   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3893   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3894
3895   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3896   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3897   application.GetScene().Add( dummy );
3898
3899   application.SendNotification();
3900   application.Render();
3901
3902   application.SendNotification();
3903   application.Render();
3904
3905   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "blurRadius", blurRadius ), true, TEST_LOCATION );
3906
3907   END_TEST;
3908 }
3909
3910 int UtcDaliVisualGetType(void)
3911 {
3912   ToolkitTestApplication application;
3913   tet_infoline( "UtcDaliVisualGetType" );
3914
3915   VisualFactory factory = VisualFactory::Get();
3916
3917   {
3918     Property::Map properties;
3919     properties[Visual::Property::TYPE] = Visual::BORDER;
3920     Visual::Base visual = factory.CreateVisual( properties );
3921
3922     DALI_TEST_CHECK( visual.GetType() == Visual::BORDER );
3923   }
3924
3925   {
3926     Property::Map properties;
3927     properties[Visual::Property::TYPE] = Visual::COLOR;
3928     Visual::Base visual = factory.CreateVisual( properties );
3929
3930     DALI_TEST_CHECK( visual.GetType() == Visual::COLOR );
3931   }
3932
3933   {
3934     Property::Map properties;
3935     properties[Visual::Property::TYPE] = Visual::GRADIENT;
3936     properties[GradientVisual::Property::START_POSITION] = Vector2( -1.f, -1.f );
3937     properties[GradientVisual::Property::END_POSITION] = Vector2( 1.f, 1.f );
3938     properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
3939     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
3940     Property::Array stopColors;
3941     stopColors.PushBack( Color::RED );
3942     stopColors.PushBack( Color::GREEN );
3943     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3944     Visual::Base visual = factory.CreateVisual( properties );
3945
3946     DALI_TEST_CHECK( visual.GetType() == Visual::GRADIENT );
3947   }
3948
3949   {
3950     Property::Map properties;
3951     properties[Visual::Property::TYPE] = Visual::IMAGE;
3952     properties.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
3953     Visual::Base visual = factory.CreateVisual( properties );
3954
3955     DALI_TEST_CHECK( visual.GetType() == Visual::IMAGE );
3956   }
3957
3958   {
3959     Property::Map properties;
3960     properties[Visual::Property::TYPE] = Visual::MESH;
3961     Visual::Base visual = factory.CreateVisual( properties );
3962
3963     DALI_TEST_CHECK( visual.GetType() == Visual::MESH );
3964   }
3965
3966   {
3967     Property::Map properties;
3968     properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
3969     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
3970     Visual::Base visual = factory.CreateVisual( properties );
3971
3972     DALI_TEST_CHECK( visual.GetType() == Visual::PRIMITIVE );
3973   }
3974
3975   {
3976     Property::Map properties;
3977     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
3978     Visual::Base visual = factory.CreateVisual( properties );
3979
3980     DALI_TEST_CHECK( visual.GetType() == Visual::WIREFRAME );
3981   }
3982
3983   {
3984     Property::Map properties;
3985     properties[Visual::Property::TYPE] = Visual::TEXT;
3986     Visual::Base visual = factory.CreateVisual( properties );
3987
3988     DALI_TEST_CHECK( visual.GetType() == Visual::TEXT );
3989   }
3990
3991   {
3992     Property::Map properties;
3993     properties[Visual::Property::TYPE] = Visual::N_PATCH;
3994     properties[ImageVisual::Property::URL] =  TEST_NPATCH_FILE_NAME;
3995     Visual::Base visual = factory.CreateVisual( properties );
3996
3997     DALI_TEST_CHECK( visual.GetType() == Visual::N_PATCH );
3998   }
3999
4000   {
4001     Property::Map properties;
4002     properties[Visual::Property::TYPE] = Visual::SVG;
4003     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4004     Visual::Base visual = factory.CreateVisual( properties );
4005
4006     DALI_TEST_CHECK( visual.GetType() == Visual::SVG );
4007   }
4008
4009   {
4010     Property::Map properties;
4011     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4012     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4013     Visual::Base visual = factory.CreateVisual( properties );
4014
4015     DALI_TEST_CHECK( visual.GetType() == Visual::ANIMATED_IMAGE );
4016   }
4017
4018   {
4019     Property::Map properties;
4020     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4021     Visual::Base visual = factory.CreateVisual( properties );
4022
4023     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_GRADIENT ) );
4024   }
4025
4026   {
4027     Property::Map properties;
4028     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4029     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4030     Visual::Base visual = factory.CreateVisual( properties );
4031
4032     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_VECTOR_IMAGE ) );
4033   }
4034
4035   {
4036     Property::Map properties;
4037     properties[Visual::Property::TYPE] = DevelVisual::ARC;
4038     Visual::Base visual = factory.CreateVisual( properties );
4039
4040     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ARC ) );
4041   }
4042
4043   END_TEST;
4044 }
4045
4046 int UtcDaliVisualGetVisualProperty01(void)
4047 {
4048   ToolkitTestApplication application;
4049   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual" );
4050
4051   VisualFactory factory = VisualFactory::Get();
4052   Property::Map propertyMap;
4053   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4054   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4055   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
4056   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4057   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4058   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4059
4060   DummyControl dummyControl = DummyControl::New(true);
4061   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4062   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4063   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4064   application.GetScene().Add(dummyControl);
4065
4066   application.SendNotification();
4067   application.Render();
4068
4069   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4070   Vector2 targetOffset(0.05f, 0.05f);
4071   Vector2 targetSize(1.1f, 1.1f);
4072   float targetOpacity = 0.5f;
4073   float targetCornerRadius = 20.0f;
4074   float targetBlurRadius = 10.0f;
4075
4076   Animation animation = Animation::New(1.0f);
4077   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4078   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4079   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4080   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4081   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4082   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4083   animation.Play();
4084
4085   application.SendNotification();
4086   application.Render();
4087   application.Render(1001u); // End of animation
4088
4089   Property::Map resultMap;
4090   colorVisual.CreatePropertyMap( resultMap );
4091
4092   // Test property values: they should be updated
4093   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4094   DALI_TEST_CHECK(colorValue);
4095   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4096
4097   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4098   Dali::Property::Map* transformMap = transformValue->GetMap();
4099   DALI_TEST_CHECK(transformMap);
4100
4101   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4102   DALI_TEST_CHECK(offsetValue);
4103   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4104
4105   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4106   DALI_TEST_CHECK(sizeValue);
4107   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4108
4109   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
4110   DALI_TEST_CHECK(cornerRadiusValue);
4111   DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
4112
4113   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4114   DALI_TEST_CHECK(blurRadiusValue);
4115   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4116
4117   // Test uniform values
4118   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4119   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4120   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4121   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4122   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4123
4124   // Test not-supported property
4125   Property property1 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::PREMULTIPLIED_ALPHA);
4126   DALI_TEST_CHECK(!property1.object);
4127   DALI_TEST_CHECK(property1.propertyIndex == Property::INVALID_INDEX);
4128
4129   // Test not-supported property
4130   Property property2 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::RENDER_IF_TRANSPARENT);
4131   DALI_TEST_CHECK(!property2.object);
4132   DALI_TEST_CHECK(property2.propertyIndex == Property::INVALID_INDEX);
4133
4134   // Test unregistered visual
4135   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4136   DALI_TEST_CHECK(!property3.object);
4137   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4138
4139   END_TEST;
4140 }
4141
4142 int UtcDaliVisualGetVisualProperty02(void)
4143 {
4144   ToolkitTestApplication application;
4145   tet_infoline( "UtcDaliVisualGetVisualProperty02: Test animatable property" );
4146
4147   VisualFactory factory = VisualFactory::Get();
4148   Property::Map propertyMap;
4149   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4150   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4151
4152   DummyControl dummyControl = DummyControl::New(true);
4153   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4154   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4155   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4156   application.GetScene().Add(dummyControl);
4157
4158   application.SendNotification();
4159   application.Render();
4160
4161   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4162   Vector2 targetOffset(0.05f, 0.05f);
4163   Vector2 targetSize(1.1f, 1.1f);
4164   float targetOpacity = 0.5f;
4165   float targetCornerRadius = 20.0f;
4166   float targetBlurRadius = 10.0f;
4167
4168   // Should work when the properties are not set before
4169   Animation animation = Animation::New(1.0f);
4170   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
4171   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
4172   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
4173   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
4174   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
4175   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
4176   animation.Play();
4177
4178   application.SendNotification();
4179   application.Render();
4180   application.Render(1001u); // End of animation
4181
4182   Property::Map resultMap;
4183   colorVisual.CreatePropertyMap(resultMap);
4184
4185   // Test property values: they should be updated
4186   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4187   DALI_TEST_CHECK(colorValue);
4188   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4189
4190   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4191   Dali::Property::Map* transformMap = transformValue->GetMap();
4192   DALI_TEST_CHECK(transformMap);
4193
4194   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4195   DALI_TEST_CHECK(offsetValue);
4196   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4197
4198   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4199   DALI_TEST_CHECK(sizeValue);
4200   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4201
4202   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
4203   DALI_TEST_CHECK(cornerRadiusValue);
4204   DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
4205
4206   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4207   DALI_TEST_CHECK(blurRadiusValue);
4208   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4209
4210   // Test uniform values
4211   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4212   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4213   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4214   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4215   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4216
4217   END_TEST;
4218 }
4219
4220 int UtcDaliVisualGetVisualProperty03(void)
4221 {
4222   ToolkitTestApplication application;
4223   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, ImageVisual" );
4224
4225   VisualFactory factory = VisualFactory::Get();
4226   Property::Map propertyMap;
4227   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
4228   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4229   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
4230
4231   DummyControl dummyControl = DummyControl::New(true);
4232   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4233   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
4234   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4235   application.GetScene().Add(dummyControl);
4236
4237   // Wait for image loading
4238   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4239
4240   application.SendNotification();
4241   application.Render();
4242
4243   float targetOpacity = 0.5f;
4244   float targetCornerRadius = 20.0f;
4245
4246   Animation animation = Animation::New(1.0f);
4247   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4248   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4249   animation.Play();
4250
4251   application.SendNotification();
4252   application.Render();
4253   application.Render(1001u); // End of animation
4254
4255   Property::Map resultMap;
4256   imageVisual.CreatePropertyMap( resultMap );
4257
4258   // Test property values: they should be updated
4259   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4260   DALI_TEST_CHECK(colorValue);
4261   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4262
4263   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
4264   DALI_TEST_CHECK(cornerRadiusValue);
4265   DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
4266
4267   // Test uniform value
4268   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4269
4270   END_TEST;
4271 }
4272
4273 int UtcDaliVisualGetVisualProperty04(void)
4274 {
4275   ToolkitTestApplication application;
4276   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, GradientVisual" );
4277
4278   Vector2 start(-1.f, -1.f);
4279   Vector2 end(1.f, 1.f);
4280   Property::Array stopColors;
4281   stopColors.PushBack( Color::RED );
4282   stopColors.PushBack( Color::GREEN );
4283
4284   VisualFactory factory = VisualFactory::Get();
4285   Property::Map propertyMap;
4286   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
4287   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
4288   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
4289   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
4290   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
4291   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
4292   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
4293
4294   DummyControl dummyControl = DummyControl::New(true);
4295   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4296   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
4297   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4298   application.GetScene().Add(dummyControl);
4299
4300   application.SendNotification();
4301   application.Render();
4302
4303   float targetOpacity = 0.5f;
4304   float targetCornerRadius = 20.0f;
4305
4306   Animation animation = Animation::New(1.0f);
4307   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4308   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4309   animation.Play();
4310
4311   application.SendNotification();
4312   application.Render();
4313   application.Render(1001u); // End of animation
4314
4315   Property::Map resultMap;
4316   gradientVisual.CreatePropertyMap( resultMap );
4317
4318   // Test property values: they should be updated
4319   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4320   DALI_TEST_CHECK(colorValue);
4321   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4322
4323   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
4324   DALI_TEST_CHECK(cornerRadiusValue);
4325   DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
4326
4327   // Test uniform value
4328   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4329
4330   END_TEST;
4331 }