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::VECTOR4 );
 520   DALI_TEST_CHECK( cornerRadiusValue );
 521   DALI_TEST_CHECK( cornerRadiusValue->Get< Vector4 >() == Vector4(10.0f, 10.0f, 10.0f, 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   static std::vector<UniformData> customUniforms =
1749   {
1750     UniformData("borderColor", Property::Type::VECTOR4),
1751     UniformData("mixColor", Property::Type::VECTOR3),
1752   };
1753
1754   TestGraphicsController& graphics = application.GetGraphicsController();
1755   graphics.AddCustomUniforms(customUniforms);
1756
1757   VisualFactory factory = VisualFactory::Get();
1758   Property::Map propertyMap;
1759   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1760   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1761   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1762   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1763   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1764
1765   Property::Map map;
1766   map["target"] = "testVisual";
1767   map["property"] = "mixColor";
1768   map["targetValue"] = Vector4(1,1,1,0.1);
1769   map["animator"] = Property::Map()
1770     .Add("alphaFunction", "LINEAR")
1771     .Add("timePeriod", Property::Map()
1772          .Add("delay", 0.0f)
1773          .Add("duration", 4.0f));
1774
1775   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1776
1777   DummyControl actor = DummyControl::New(true);
1778   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1779   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1780   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1781   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1782   application.GetScene().Add(actor);
1783
1784   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1785
1786   Renderer renderer = actor.GetRendererAt(0);
1787   Property::Index borderColorIndex = renderer.GetPropertyIndex( BorderVisual::Property::COLOR );
1788   Property::Index mixColorIndex = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1789
1790   Animation animation = dummyImpl.CreateTransition( transition );
1791
1792   // Animate the mix color through the transition, and the border color through
1793   // programmatic method.
1794   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1795   animation.Play();
1796
1797   application.SendNotification();
1798   application.Render(0);
1799   application.Render(2000u); // halfway point between blue and white
1800
1801   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1802   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1803   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1804   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1805
1806   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1807   testColor = Vector4( 1,1,1,0.45f );
1808   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1809   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1810
1811   Vector4 uColor;
1812   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1813   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1814
1815   application.Render(2000u);
1816
1817   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1818   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1819   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1820
1821   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1822   testColor = Vector4(1,1,1,0.1);
1823   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), TEST_LOCATION );
1824   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1825
1826   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", uColor ) );
1827   DALI_TEST_EQUALS( uColor.a, testColor.a, TEST_LOCATION );
1828
1829   END_TEST;
1830 }
1831
1832
1833 int UtcDaliVisualAnimateBorderVisual02(void)
1834 {
1835   ToolkitTestApplication application;
1836   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1837
1838   static std::vector<UniformData> customUniforms =
1839   {
1840     UniformData("borderSize", Property::Type::FLOAT),
1841   };
1842
1843   TestGraphicsController& graphics = application.GetGraphicsController();
1844   graphics.AddCustomUniforms(customUniforms);
1845
1846   VisualFactory factory = VisualFactory::Get();
1847   Property::Map propertyMap;
1848   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1849   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1850   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1851   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1852
1853   DummyControl actor = DummyControl::New(true);
1854   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1855   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1856   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1857   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1858   application.GetScene().Add(actor);
1859
1860   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1861
1862   Renderer renderer = actor.GetRendererAt(0);
1863   Property::Index index = renderer.GetPropertyIndex( BorderVisual::Property::SIZE );
1864
1865   Animation animation = Animation::New(4.0f);
1866   animation.AnimateTo( Property(renderer, index), 9.0f );
1867   animation.Play();
1868
1869   application.SendNotification();
1870   application.Render(0);
1871   application.Render(2000u); // halfway point
1872
1873   float size = renderer.GetCurrentProperty< float >( index );
1874   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1875   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1876
1877   application.Render(2000u); // halfway point between blue and white
1878
1879   size = renderer.GetCurrentProperty< float >( index );
1880   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1881   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1882
1883   END_TEST;
1884 }
1885
1886 int UtcDaliVisualAnimateColorVisual(void)
1887 {
1888   ToolkitTestApplication application;
1889   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1890
1891   static std::vector<UniformData> customUniforms =
1892   {
1893     UniformData("mixColor", Property::Type::VECTOR3),
1894   };
1895
1896   TestGraphicsController& graphics = application.GetGraphicsController();
1897   graphics.AddCustomUniforms(customUniforms);
1898
1899   VisualFactory factory = VisualFactory::Get();
1900   Property::Map propertyMap;
1901   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1902   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1903   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1904
1905   DummyControl actor = DummyControl::New(true);
1906   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1907   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1908   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1909   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1910   application.GetScene().Add(actor);
1911
1912   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1913
1914   Renderer renderer = actor.GetRendererAt(0);
1915   Property::Index mixColorIndex = renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1916
1917   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1918   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1919
1920   Animation animation = Animation::New(4.0f);
1921   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1922   animation.Play();
1923
1924   application.SendNotification();
1925   application.Render(0);
1926   application.Render(2000u); // halfway point
1927
1928   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1929   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1930   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1931
1932   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1933
1934   application.Render(2000u); // halfway point between blue and white
1935
1936   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1937   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1938
1939   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1940
1941   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1942   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1943
1944   END_TEST;
1945 }
1946
1947 int UtcDaliVisualAnimatePrimitiveVisual(void)
1948 {
1949   ToolkitTestApplication application;
1950   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1951
1952   static std::vector<UniformData> customUniforms =
1953   {
1954     UniformData("mixColor", Property::Type::VECTOR3),
1955   };
1956
1957   TestGraphicsController& graphics = application.GetGraphicsController();
1958   graphics.AddCustomUniforms(customUniforms);
1959
1960   {
1961     VisualFactory factory = VisualFactory::Get();
1962     Property::Map propertyMap;
1963     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1964     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1965     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1966     Visual::Base visual = factory.CreateVisual( propertyMap );
1967
1968     DummyControl actor = DummyControl::New(true);
1969     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1970     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1971     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
1972     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1973     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
1974     application.GetScene().Add(actor);
1975
1976     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1977
1978     Renderer renderer = actor.GetRendererAt(0);
1979     Property::Index index = renderer.GetPropertyIndex( PrimitiveVisual::Property::MIX_COLOR );
1980
1981     tet_infoline("Test that the renderer has the Primitive mix color");
1982     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1983
1984     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1985     const Vector4 TARGET_MIX_COLOR( Color::RED );
1986
1987     Property::Map map;
1988     map["target"] = "testVisual";
1989     map["property"] = "mixColor";
1990     map["initialValue"] = INITIAL_MIX_COLOR;
1991     map["targetValue"] = TARGET_MIX_COLOR;
1992     map["animator"] = Property::Map()
1993       .Add("alphaFunction", "LINEAR")
1994       .Add("timePeriod", Property::Map()
1995            .Add("delay", 0.0f)
1996            .Add("duration", 4.0f));
1997
1998     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1999
2000     Animation animation = dummyImpl.CreateTransition( transition );
2001     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
2002     animation.Play();
2003
2004     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2005     glAbstraction.EnableEnableDisableCallTrace( true );
2006     TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2007     std::ostringstream blendStr;
2008     blendStr << std::hex << GL_BLEND;
2009
2010     application.SendNotification();
2011     application.Render(0);
2012     application.Render(2000u); // halfway point
2013     application.SendNotification();
2014
2015     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
2016     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a )), true, TEST_LOCATION );
2017     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
2018
2019     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
2020
2021     glEnableStack.Reset();
2022
2023     application.Render(2001u); // go past end
2024     application.SendNotification(); // Trigger signals
2025
2026     DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
2027     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4( 1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a ) ), true, TEST_LOCATION );
2028     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
2029
2030     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
2031
2032     actor.Unparent();
2033   }
2034
2035   END_TEST;
2036 }
2037
2038 int UtcDaliVisualAnimatedGradientVisual01(void)
2039 {
2040   ToolkitTestApplication application;
2041   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
2042
2043   static std::vector<UniformData> customUniforms =
2044   {
2045     UniformData("start_point", Property::Type::VECTOR2),
2046     UniformData("end_point", Property::Type::VECTOR2),
2047     UniformData("start_color", Property::Type::VECTOR4),
2048     UniformData("end_color", Property::Type::VECTOR4),
2049     UniformData("rotate_center", Property::Type::VECTOR2),
2050     UniformData("rotate_angle", Property::Type::FLOAT),
2051     UniformData("gradient_offset", Property::Type::FLOAT),
2052   };
2053
2054   TestGraphicsController& graphics = application.GetGraphicsController();
2055   graphics.AddCustomUniforms(customUniforms);
2056
2057   {
2058     VisualFactory factory = VisualFactory::Get();
2059     Property::Map propertyMap;
2060     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2061     Visual::Base visual = factory.CreateVisual( propertyMap );
2062
2063     DummyControl actor = DummyControl::New(true);
2064     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2065     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2066     actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2067     actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2068     actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2069     application.GetScene().Add(actor);
2070
2071     application.SendNotification();
2072     application.Render(0);
2073     application.SendNotification();
2074
2075     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2076
2077     for(int step_iter = 0; step_iter < 3; step_iter++)
2078     {
2079       application.SendNotification();
2080       application.Render(0);
2081       application.Render(750u); // step i/4
2082       application.SendNotification();
2083
2084       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
2085       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
2086       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2087       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
2088       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
2089       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
2090       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
2091     }
2092
2093     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2094     application.Render(750u); // go to end
2095     application.SendNotification();
2096
2097     application.Render(10u); // finish
2098     application.SendNotification();
2099
2100     actor.Unparent();
2101     application.SendNotification();
2102     application.Render(0u);
2103     application.SendNotification();
2104   }
2105
2106   END_TEST;
2107 }
2108
2109 int UtcDaliVisualAnimatedGradientVisual02(void)
2110 {
2111   ToolkitTestApplication application;
2112   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
2113
2114   static std::vector<UniformData> customUniforms =
2115   {
2116     UniformData("start_point", Property::Type::VECTOR2),
2117     UniformData("end_point", Property::Type::VECTOR2),
2118     UniformData("start_color", Property::Type::VECTOR4),
2119     UniformData("end_color", Property::Type::VECTOR4),
2120     UniformData("rotate_center", Property::Type::VECTOR2),
2121     UniformData("rotate_angle", Property::Type::FLOAT),
2122     UniformData("gradient_offset", Property::Type::FLOAT),
2123   };
2124
2125   TestGraphicsController& graphics = application.GetGraphicsController();
2126   graphics.AddCustomUniforms(customUniforms);
2127
2128   {
2129     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
2130     int _direction[2] = {0, 1};
2131     int _loop_count[3] = {-1, 0, 1};
2132     int _motion[2] = {0, 1};
2133     int _easing[4] = {0, 1, 2, 3};
2134
2135     int test_case_max = 4 * 2 * 3 * 2 * 4;
2136     int test_case = 0;
2137     int test_case_d = 7; // 7 is the number of animated properties.
2138
2139     float _duration = 0.4f;
2140     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2141     float noise_maker = 0.0f;
2142     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2143     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2144     {
2145       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2146
2147       VisualFactory factory = VisualFactory::Get();
2148       Property::Map propertyMap;
2149       Property::Map animationMap;
2150       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2151
2152       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2153       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2154       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2155
2156       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&
2157       {
2158         int tc = (test_case + tc_offset);
2159         int idx_easing = tc % 4; tc /= 4;
2160         int idx_motion = tc % 2; tc /= 2;
2161         int idx_loop_count = tc % 3; tc /= 3;
2162         int idx_direction = tc % 2; tc /= 2;
2163         int idx_delay = tc % 4; tc /= 4;
2164
2165         float duration = _duration - _repeat_delay;
2166         float repeat_delay = _repeat_delay;
2167         float delay = _delay[idx_delay] * _duration;
2168         int direction = _direction[idx_direction];
2169         int loop_count = _loop_count[idx_loop_count];
2170         int motion = _motion[idx_motion];
2171         int easing = _easing[idx_easing];
2172
2173         animationMap.Clear();
2174         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
2175         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
2176         if( direction == 0 )
2177         {
2178           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2179         }
2180         else
2181         {
2182           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2183         }
2184         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2185         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2186         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2187         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2188         if( motion == 0 )
2189         {
2190           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2191         }
2192         else
2193         {
2194           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2195         }
2196         if( easing == 0 )
2197         {
2198           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2199         }
2200         else if( easing == 1 )
2201         {
2202           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2203         }
2204         else if( easing == 2 )
2205         {
2206           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2207         }
2208         else
2209         {
2210           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2211         }
2212
2213         return animationMap;
2214       };
2215
2216       // Give different values for debuging
2217       noise_maker += 1.0f;
2218       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2219       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2220       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2221       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2222       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2223       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2224       float offset1 = 0.f + noise_maker * 0.1f;
2225
2226       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2227       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2228       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2229       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2230       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2231       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2232       float offset2 = 2.f + noise_maker * 0.1f;
2233
2234       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2235       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2236       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2237
2238       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2239       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2240       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2241       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2242       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2243       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2244       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2245
2246       Visual::Base visual = factory.CreateVisual( propertyMap );
2247
2248       DummyControl actor = DummyControl::New( true );
2249       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2250       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2251       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2252       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2253       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2254       application.GetScene().Add(actor);
2255
2256       application.SendNotification();
2257       application.Render( 0 );
2258       application.SendNotification();
2259
2260       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2261
2262       application.SendNotification();
2263
2264       //Compare between CPU calculated value and Shader Visual calculated value
2265       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
2266       {
2267         int tc = (test_case + tc_offset);
2268         int idx_easing = tc % 4; tc /= 4;
2269         int idx_motion = tc % 2; tc /= 2;
2270         int idx_loop_count = tc % 3; tc /= 3;
2271         int idx_direction = tc % 2; tc /= 2;
2272         int idx_delay = tc % 4; tc /= 4;
2273
2274         float duration = _duration - _repeat_delay;
2275         float repeat_delay = _repeat_delay;
2276         float delay = _delay[idx_delay] * _duration;
2277         int direction = _direction[idx_direction];
2278         int loop_count = _loop_count[idx_loop_count];
2279         int motion = _motion[idx_motion];
2280         int easing = _easing[idx_easing];
2281
2282         progress -= delay / _duration;
2283
2284         Property::Value s = start;
2285         Property::Value t = target;
2286         if( direction == 1 )
2287         {
2288           s = target;
2289           t = start;
2290         }
2291         float x; ///< Animator progress value
2292         if( loop_count == 0 )
2293         {
2294           x = 1.0f;
2295         }
2296         else if( loop_count > 0 && progress + 0.01f > loop_count )
2297         {
2298           x = ( motion == 0 ) ? 1.0f : 0.0f;
2299         }
2300         else
2301         {
2302           if( progress < 0.0f )
2303           {
2304             progress = 0.0f;
2305           }
2306           progress = fmodf( progress, 1.0f );
2307           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2308
2309           x = progress;
2310           if( motion == 1 )
2311           {
2312             x = progress * 2.0f;
2313             if( x > 1.0f )
2314             {
2315               x = 2.0f - x;
2316             }
2317           }
2318
2319           if( easing == 1 ) // EASE_IN
2320           {
2321             x = x*x;
2322           }
2323           else if( easing == 2 ) // EASE_OUT
2324           {
2325             x = 2.0f*x - x*x;
2326           }
2327           else if( easing == 3 ) // EASE_IN_OUT
2328           {
2329             x = x * x * (3.0f - 2.0f * x);
2330           }
2331         }
2332         if( value_type == 0 ) // result type is Float
2333         {
2334           float res;
2335           float cur;
2336           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2337           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2338           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2339         }
2340         else if( value_type == 1 ) // result type is Vector2
2341         {
2342           Vector2 res;
2343           Vector2 cur;
2344           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2345           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2346           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2347         }
2348         else if( value_type == 2 ) // result type is Vector3
2349         {
2350           Vector3 res;
2351           Vector3 cur;
2352           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2353           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2354           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2355         }
2356         else // result type is Vector4
2357         {
2358           Vector4 res;
2359           Vector4 cur;
2360           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2361           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2362           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2363         }
2364       };
2365
2366       float step = 0.0f;
2367       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2368       {
2369         for( int step_iter = 0; step_iter < 3; step_iter++ )
2370         {
2371           application.SendNotification();
2372           application.Render( _duration * 250.f );  // step i/4
2373           application.SendNotification();
2374           step += 0.25f;
2375
2376           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2377           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2378           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2379           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2380           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2381           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2382           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2383         }
2384         application.SendNotification();
2385         application.Render(_duration * 250.f);  // step 4/4 will not test
2386         application.SendNotification();
2387         step += 0.25f;
2388       }
2389
2390       application.SendNotification();
2391       actor.Unparent();
2392       application.SendNotification();
2393       application.Render(10.f);  // tempral time
2394       application.SendNotification();
2395     }
2396   }
2397
2398   END_TEST;
2399 }
2400
2401 int UtcDaliVisualAnimatedGradientVisual03(void)
2402 {
2403   ToolkitTestApplication application;
2404   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2405
2406   static std::vector<UniformData> customUniforms =
2407   {
2408     UniformData("start_point", Property::Type::VECTOR2),
2409     UniformData("end_point", Property::Type::VECTOR2),
2410     UniformData("start_color", Property::Type::VECTOR4),
2411     UniformData("end_color", Property::Type::VECTOR4),
2412     UniformData("rotate_center", Property::Type::VECTOR2),
2413     UniformData("rotate_angle", Property::Type::FLOAT),
2414     UniformData("gradient_offset", Property::Type::FLOAT),
2415   };
2416
2417   TestGraphicsController& graphics = application.GetGraphicsController();
2418   graphics.AddCustomUniforms(customUniforms);
2419
2420   {
2421     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
2422     int _direction[2] = {0, 1};
2423     int _loop_count[3] = {-1, 0, 1};
2424     int _motion[2] = {0, 1};
2425     int _easing[4] = {0, 1, 2, 3};
2426
2427     int test_case_max = 4 * 2 * 3 * 2 * 4;
2428     int test_case = 0;
2429     int test_case_d = 7; // 7 is the number of animated properties.
2430
2431     float _duration = 0.4f;
2432     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2433     float noise_maker = 0.2f;
2434     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2435     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2436     {
2437       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2438
2439       VisualFactory factory = VisualFactory::Get();
2440       Property::Map propertyMap;
2441       Property::Map animationMap;
2442       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2443
2444       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&
2445       {
2446         int tc = (test_case + tc_offset);
2447         int idx_easing = tc % 4; tc /= 4;
2448         int idx_motion = tc % 2; tc /= 2;
2449         int idx_loop_count = tc % 3; tc /= 3;
2450         int idx_direction = tc % 2; tc /= 2;
2451         int idx_delay = tc % 4; tc /= 4;
2452
2453         float duration = _duration - _repeat_delay;
2454         float repeat_delay = _repeat_delay;
2455         float delay = _delay[idx_delay] * _duration;
2456         int direction = _direction[idx_direction];
2457         int loop_count = _loop_count[idx_loop_count];
2458         int motion = _motion[idx_motion];
2459         int easing = _easing[idx_easing];
2460
2461         animationMap.Clear();
2462         animationMap.Insert( "startValue", start );
2463         animationMap.Insert( "targetValue", target );
2464         if( direction == 0 )
2465         {
2466           animationMap.Insert("directionType", "FORWARD");
2467         }
2468         else
2469         {
2470           animationMap.Insert("directionType", "BACKWARD");
2471         }
2472         animationMap.Insert("duration", duration);
2473         animationMap.Insert("delay", delay);
2474         animationMap.Insert("repeat", loop_count);
2475         animationMap.Insert("repeatDelay", repeat_delay);
2476         if( motion == 0 )
2477         {
2478           animationMap.Insert("motionType", "LOOP");
2479         }
2480         else
2481         {
2482           animationMap.Insert("motionType", "MIRROR");
2483         }
2484         if( easing == 0 )
2485         {
2486           animationMap.Insert("easingType", "LINEAR");
2487         }
2488         else if( easing == 1 )
2489         {
2490           animationMap.Insert("easingType", "IN");
2491         }
2492         else if( easing == 2 )
2493         {
2494           animationMap.Insert("easingType", "OUT");
2495         }
2496         else
2497         {
2498           animationMap.Insert("easingType", "IN_OUT");
2499         }
2500
2501         return animationMap;
2502       };
2503
2504       // Give different values for debuging
2505       noise_maker += 0.8f;
2506       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2507       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2508       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2509       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2510       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2511       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2512       float offset1 = 0.f + noise_maker * 0.1f;
2513
2514       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2515       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2516       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2517       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2518       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2519       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2520       float offset2 = 2.f + noise_maker * 0.1f;
2521
2522       propertyMap.Insert("gradientType", "LINEAR");
2523       propertyMap.Insert("unitType",     "USER_SPACE");
2524       propertyMap.Insert("spreadType",   "CLAMP");
2525
2526       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2527       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2528       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2529       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2530       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2531       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2532       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2533
2534       Visual::Base visual = factory.CreateVisual( propertyMap );
2535
2536       DummyControl actor = DummyControl::New( true );
2537       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2538       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2539       actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2540       actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2541       actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
2542       application.GetScene().Add(actor);
2543
2544       application.SendNotification();
2545       application.Render( 0 );
2546       application.SendNotification();
2547
2548       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2549
2550       application.SendNotification();
2551
2552       //Compare between CPU calculated value and Shader Visual calculated value
2553       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
2554       {
2555         int tc = (test_case + tc_offset);
2556         int idx_easing = tc % 4; tc /= 4;
2557         int idx_motion = tc % 2; tc /= 2;
2558         int idx_loop_count = tc % 3; tc /= 3;
2559         int idx_direction = tc % 2; tc /= 2;
2560         int idx_delay = tc % 4; tc /= 4;
2561
2562         float duration = _duration - _repeat_delay;
2563         float repeat_delay = _repeat_delay;
2564         float delay = _delay[idx_delay] * _duration;
2565         int direction = _direction[idx_direction];
2566         int loop_count = _loop_count[idx_loop_count];
2567         int motion = _motion[idx_motion];
2568         int easing = _easing[idx_easing];
2569
2570         progress -= delay / _duration;
2571
2572         Property::Value s = start;
2573         Property::Value t = target;
2574         if( direction == 1 )
2575         {
2576           s = target;
2577           t = start;
2578         }
2579         float x; ///< Animator progress value
2580         if( loop_count == 0 )
2581         {
2582           x = 1.0f;
2583         }
2584         else if( loop_count > 0 && progress + 0.01f > loop_count )
2585         {
2586           x = ( motion == 0 ) ? 1.0f : 0.0f;
2587         }
2588         else
2589         {
2590           if( progress < 0.0f )
2591           {
2592             progress = 0.0f;
2593           }
2594           progress = fmodf( progress, 1.0f );
2595           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2596
2597           x = progress;
2598           if( motion == 1 )
2599           {
2600             x = progress * 2.0f;
2601             if( x > 1.0f )
2602             {
2603               x = 2.0f - x;
2604             }
2605           }
2606
2607           if( easing == 1 ) // EASE_IN
2608           {
2609             x = x*x;
2610           }
2611           else if( easing == 2 ) // EASE_OUT
2612           {
2613             x = 2.0f*x - x*x;
2614           }
2615           else if( easing == 3 ) // EASE_IN_OUT
2616           {
2617             x = x * x * (3.0f - 2.0f * x);
2618           }
2619         }
2620         if( value_type == 0 ) // result type is Float
2621         {
2622           float res;
2623           float cur;
2624           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2625           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2626           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2627         }
2628         else if( value_type == 1 ) // result type is Vector2
2629         {
2630           Vector2 res;
2631           Vector2 cur;
2632           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2633           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2634           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2635         }
2636         else if( value_type == 2 ) // result type is Vector3
2637         {
2638           Vector3 res;
2639           Vector3 cur;
2640           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2641           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2642           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2643         }
2644         else // result type is Vector4
2645         {
2646           Vector4 res;
2647           Vector4 cur;
2648           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2649           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2650           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2651         }
2652       };
2653
2654       float step = 0.0f;
2655       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2656       {
2657         for( int step_iter = 0; step_iter < 3; step_iter++ )
2658         {
2659           application.SendNotification();
2660           application.Render( _duration * 250.f );  // step i/4
2661           application.SendNotification();
2662           step += 0.25f;
2663
2664           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2665           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2666           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2667           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2668           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2669           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2670           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2671         }
2672         application.SendNotification();
2673         application.Render(_duration * 250.f);  // step 4/4 will not test
2674         application.SendNotification();
2675         step += 0.25f;
2676       }
2677
2678       application.SendNotification();
2679       actor.Unparent();
2680       application.SendNotification();
2681       application.Render(10.f);  // tempral time
2682       application.SendNotification();
2683     }
2684   }
2685
2686   END_TEST;
2687 }
2688
2689 int UtcDaliVisualWireframeVisual(void)
2690 {
2691   ToolkitTestApplication application;
2692
2693   VisualFactory factory = VisualFactory::Get();
2694   Property::Map propertyMap;
2695   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2696
2697   // Create the visual.
2698   Visual::Base visual = factory.CreateVisual( propertyMap );
2699
2700   DALI_TEST_CHECK( visual );
2701
2702   Property::Map resultMap;
2703   visual.CreatePropertyMap( resultMap );
2704
2705   // Check the property values from the returned map from visual
2706   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2707   DALI_TEST_CHECK( value );
2708   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2709
2710   END_TEST;
2711 }
2712
2713 int UtcDaliVisualGetTransform(void)
2714 {
2715   ToolkitTestApplication application;
2716   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2717
2718   VisualFactory factory = VisualFactory::Get();
2719   Property::Map propertyMap;
2720   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2721   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2722   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2723
2724   Dali::Property::Map visualMap;
2725   colorVisual.CreatePropertyMap( visualMap );
2726   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2727   Dali::Property::Map* map = value->GetMap();
2728   DALI_TEST_CHECK( map );
2729
2730   //Test default values
2731   {
2732     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2733     DALI_TEST_CHECK( typeValue );
2734     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2735   }
2736   {
2737     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2738     DALI_TEST_CHECK( typeValue );
2739     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2740   }
2741   {
2742     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2743     DALI_TEST_CHECK( typeValue );
2744     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2745   }
2746   {
2747     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2748     DALI_TEST_CHECK( typeValue );
2749     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2750   }
2751   {
2752     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2753     DALI_TEST_CHECK( typeValue );
2754     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2755   }
2756   {
2757     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2758     DALI_TEST_CHECK( typeValue );
2759     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2760   }
2761   {
2762     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2763     DALI_TEST_CHECK( typeValue );
2764     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2765   }
2766
2767   END_TEST;
2768 }
2769
2770 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2771 {
2772   Property::Map transform;
2773   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2774   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2775   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2776   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2777   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2778   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f) );
2779
2780   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2781
2782   Dali::Property::Map visualMap;
2783   visual.CreatePropertyMap( visualMap );
2784   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2785   Dali::Property::Map* map = value->GetMap();
2786   DALI_TEST_CHECK( map );
2787
2788   {
2789     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2790     DALI_TEST_CHECK( typeValue );
2791     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2792   }
2793   {
2794     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2795     DALI_TEST_CHECK( typeValue );
2796     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2797   }
2798   {
2799     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2800     DALI_TEST_CHECK( typeValue );
2801     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2802   }
2803   {
2804     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2805     DALI_TEST_CHECK( typeValue );
2806     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2807   }
2808   {
2809     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2810     DALI_TEST_CHECK( typeValue );
2811     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2812   }
2813   {
2814     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2815     DALI_TEST_CHECK( typeValue );
2816     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2817   }
2818   {
2819     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE );
2820     DALI_TEST_CHECK( typeValue );
2821     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(50.0f,50.0f), TEST_LOCATION );
2822   }
2823
2824   //Put the visual on the stage
2825   DummyControl actor = DummyControl::New(true);
2826   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2827   actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
2828   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
2829   application.GetScene().Add(actor);
2830
2831   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2832   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2833
2834   application.SendNotification();
2835   application.Render(0);
2836   Renderer renderer( actor.GetRendererAt(0) );
2837
2838   //Check that the properties have been registered on the Renderer
2839   Property::Index index = renderer.GetPropertyIndex( "offset" );
2840   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2841   Vector2 offset = renderer.GetProperty<Vector2>( index );
2842   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2843
2844   index = renderer.GetPropertyIndex( "size" );
2845   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2846   Vector2 size = renderer.GetProperty<Vector2>( index );
2847   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2848
2849   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2850   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2851   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2852   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2853
2854   index = renderer.GetPropertyIndex( "origin" );
2855   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2856   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2857   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2858
2859   index = renderer.GetPropertyIndex( "anchorPoint" );
2860   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2861   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2862   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2863
2864   index = renderer.GetPropertyIndex( "extraSize" );
2865   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2866   Vector2 extraSize = renderer.GetProperty<Vector2>( index );
2867   DALI_TEST_EQUALS( extraSize, Vector2(50.0f,50.0f), TEST_LOCATION );
2868
2869   //Set a new transform
2870   transform.Clear();
2871   transform = DefaultTransform();
2872   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2873   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2874   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2875   transform.Insert( DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f) );
2876   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2877   application.SendNotification();
2878   application.Render(0);
2879
2880   //Check that the values have changed in the renderer
2881   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2882   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2883
2884   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2885   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2886
2887   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2888   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2889
2890   //Parent origin and anchor point should have the default values
2891   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2892   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2893
2894   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2895   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2896
2897   extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
2898   DALI_TEST_EQUALS( extraSize, Vector2(0.5f,0.5f), TEST_LOCATION );
2899 }
2900
2901 int UtcDaliVisualSetTransform01(void)
2902 {
2903   ToolkitTestApplication application;
2904   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2905
2906   VisualFactory factory = VisualFactory::Get();
2907   Property::Map propertyMap;
2908   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2909   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2910   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2911   Visual::Base visual = factory.CreateVisual( propertyMap );
2912   TestTransform( application, visual );
2913   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2914
2915   END_TEST;
2916 }
2917
2918 int UtcDaliVisualSetTransform0(void)
2919 {
2920   ToolkitTestApplication application;
2921   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2922
2923   VisualFactory factory = VisualFactory::Get();
2924   Property::Map propertyMap;
2925   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2926   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2927   Visual::Base visual = factory.CreateVisual( propertyMap );
2928   TestTransform( application, visual );
2929   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2930
2931   END_TEST;
2932 }
2933
2934 int UtcDaliVisualSetTransform1(void)
2935 {
2936   ToolkitTestApplication application;
2937   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2938
2939   VisualFactory factory = VisualFactory::Get();
2940   Property::Map propertyMap;
2941   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2942   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2943   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2944   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2945   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
2946   Visual::Base visual = factory.CreateVisual( propertyMap );
2947   TestTransform( application, visual );
2948   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
2949
2950   END_TEST;
2951 }
2952
2953 int UtcDaliVisualSetTransform2(void)
2954 {
2955   ToolkitTestApplication application;
2956   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
2957
2958   VisualFactory factory = VisualFactory::Get();
2959   Property::Map propertyMap;
2960   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
2961   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
2962
2963   Property::Array stopOffsets;
2964   stopOffsets.PushBack( 0.0f );
2965   stopOffsets.PushBack( 0.3f );
2966   stopOffsets.PushBack( 0.6f );
2967   stopOffsets.PushBack( 0.8f );
2968   stopOffsets.PushBack( 1.0f );
2969   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
2970
2971   Property::Array stopColors;
2972   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
2973   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
2974   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
2975   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
2976   stopColors.PushBack( Color::YELLOW );
2977   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
2978   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
2979   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
2980   Visual::Base visual = factory.CreateVisual( propertyMap );
2981   TestTransform( application, visual );
2982   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
2983
2984   END_TEST;
2985 }
2986
2987 int UtcDaliVisualSetTransform3(void)
2988 {
2989   ToolkitTestApplication application;
2990   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
2991
2992   VisualFactory factory = VisualFactory::Get();
2993   Property::Map propertyMap;
2994   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
2995   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
2996   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
2997   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
2998   Visual::Base visual = factory.CreateVisual( propertyMap );
2999   TestTransform( application, visual );
3000   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
3001
3002   END_TEST;
3003 }
3004
3005 int UtcDaliVisualSetTransform4(void)
3006 {
3007   ToolkitTestApplication application;
3008   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
3009
3010   VisualFactory factory = VisualFactory::Get();
3011   Property::Map propertyMap;
3012   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
3013   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
3014
3015   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
3016   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
3017   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
3018   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
3019   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
3020   Visual::Base visual = factory.CreateVisual( propertyMap );
3021   TestTransform( application, visual );
3022   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
3023
3024   END_TEST;
3025 }
3026
3027 int UtcDaliVisualSetTransform5(void)
3028 {
3029   ToolkitTestApplication application;
3030   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
3031
3032   VisualFactory factory = VisualFactory::Get();
3033   Property::Map propertyMap;
3034   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3035   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
3036   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3037   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
3038   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
3039   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
3040   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
3041   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3042   Visual::Base visual = factory.CreateVisual(propertyMap);
3043   TestTransform( application, visual );
3044   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
3045
3046   END_TEST;
3047 }
3048
3049 int UtcDaliVisualSetTransform6(void)
3050 {
3051   ToolkitTestApplication application;
3052   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
3053
3054   VisualFactory factory = VisualFactory::Get();
3055   Property::Map propertyMap;
3056   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
3057   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3058   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3059   Visual::Base visual = factory.CreateVisual(propertyMap);
3060   TestTransform( application, visual );
3061   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
3062
3063   END_TEST;
3064 }
3065
3066 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3067 {
3068   ToolkitTestApplication application;
3069   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
3070
3071   VisualFactory factory = VisualFactory::Get();
3072   Property::Map propertyMap;
3073   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3074   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3075   Visual::Base visual = factory.CreateVisual( propertyMap );
3076
3077   Property::Map transform;
3078   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
3079                                                  .Add( "RELATIVE" );
3080   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
3081                                                  .Add( "ABSOLUTE" );
3082   visual.SetTransformAndSize( transform, Vector2(100, 100) );
3083
3084   Dali::Property::Map visualMap;
3085   visual.CreatePropertyMap( visualMap );
3086   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
3087   Dali::Property::Map* map = value->GetMap();
3088   DALI_TEST_CHECK( map );
3089
3090   {
3091     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
3092     DALI_TEST_CHECK( typeValue );
3093     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
3094   }
3095   {
3096     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
3097     DALI_TEST_CHECK( typeValue );
3098     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
3099   }
3100
3101   END_TEST;
3102 }
3103
3104 int UtcDaliNPatchVisualCustomShader(void)
3105 {
3106   ToolkitTestApplication application;
3107   tet_infoline( "NPatchVisual with custom shader" );
3108
3109   VisualFactory factory = VisualFactory::Get();
3110   Property::Map properties;
3111   Property::Map shader;
3112   const std::string vertexShader = "Foobar";
3113   const std::string fragmentShader = "Foobar";
3114   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3115   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3116
3117   Property::Map transformMap;
3118   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
3119   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
3120   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
3121   transformMap["anchorPoint"] = Align::CENTER;
3122   transformMap["origin"] = Align::CENTER;
3123   transformMap["extraSize"] = Vector2( 0.0f, 50.0f );
3124   properties[Visual::Property::TRANSFORM] = transformMap;
3125
3126   properties[Visual::Property::TYPE] = Visual::IMAGE;
3127   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
3128   properties[Visual::Property::SHADER]=shader;
3129   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
3130   properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3131
3132   Visual::Base visual = factory.CreateVisual( properties );
3133   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
3134
3135   // trigger creation through setting on stage
3136   DummyControl dummy = DummyControl::New(true);
3137   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3138   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3139   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
3140   dummy.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
3141   dummy.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
3142   application.GetScene().Add(dummy);
3143   application.SendNotification();
3144
3145   Renderer renderer = dummy.GetRendererAt( 0 );
3146   Shader shader2 = renderer.GetShader();
3147   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3148   Property::Map* map = value.GetMap();
3149   DALI_TEST_CHECK( map );
3150
3151   Property::Index index = renderer.GetPropertyIndex("size");
3152   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
3153
3154   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3155   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
3156
3157   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3158   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
3159
3160   Vector2 extraSize = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "extraSize" ) );
3161   DALI_TEST_EQUALS( extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION );
3162
3163   END_TEST;
3164 }
3165
3166 int UtcDaliGradientVisualBlendMode(void)
3167 {
3168   ToolkitTestApplication application;
3169   VisualFactory factory = VisualFactory::Get();
3170
3171   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3172       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3173                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3174                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3175                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3176                                                                                   .Add( Color::GREEN ) ) );
3177
3178   Visual::Base alphaGradientVisual = factory.CreateVisual(
3179       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
3180                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
3181                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
3182                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
3183                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
3184
3185   DummyControl control = DummyControl::New(true);
3186   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3187   application.GetScene().Add( control );
3188
3189   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
3190   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
3191   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
3192
3193   application.SendNotification();
3194   application.Render();
3195
3196   // 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
3197   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
3198   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
3199   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
3200
3201   END_TEST;
3202 }
3203
3204 int UtcDaliVisualRendererRemovalAndReAddition(void)
3205 {
3206   ToolkitTestApplication application;
3207   tet_infoline( "UtcDaliVisualRendererRemoval" );
3208
3209   VisualFactory factory = VisualFactory::Get();
3210   Property::Map propertyMap;
3211   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3212   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3213   Visual::Base visual = factory.CreateVisual( propertyMap );
3214
3215   visual.SetDepthIndex( 1 );
3216
3217   DummyControl dummyControl = DummyControl::New(true);
3218   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3219   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3220   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3221
3222   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3223   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
3224
3225   application.GetScene().Add( dummyControl );
3226
3227   application.SendNotification();
3228   application.Render();
3229
3230   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3231
3232   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
3233   application.GetScene().Remove( dummyControl );
3234   application.SendNotification();
3235   application.Render();
3236
3237   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3238
3239   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
3240
3241   application.GetScene().Add( dummyControl );
3242
3243   application.SendNotification();
3244   application.Render();
3245
3246   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3247
3248   END_TEST;
3249 }
3250
3251
3252
3253 int UtcDaliVisualTextVisualRender(void)
3254 {
3255   ToolkitTestApplication application;
3256   tet_infoline( "UtcDaliVisualTextVisualRender" );
3257
3258   VisualFactory factory = VisualFactory::Get();
3259   Property::Map propertyMap;
3260   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3261   propertyMap.Insert( "mixColor", Color::WHITE );
3262   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3263   propertyMap.Insert( "enableMarkup", false );
3264   propertyMap.Insert( "text", "Hello world" );
3265   propertyMap.Insert( "fontFamily", "TizenSans" );
3266
3267   Property::Map fontStyleMapSet;
3268   fontStyleMapSet.Insert( "weight", "bold" );
3269   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3270
3271   propertyMap.Insert( "pointSize", 12.f );
3272   propertyMap.Insert( "multiLine", true );
3273   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3274   propertyMap.Insert( "verticalAlignment", "CENTER" );
3275   propertyMap.Insert( "textColor", Color::RED );
3276   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3277   textVisual.SetDepthIndex( 1 );
3278
3279   DummyControl dummyControl = DummyControl::New(true);
3280   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3281   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3282   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3283
3284   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3285   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3286
3287   application.GetScene().Add( dummyControl );
3288   application.SendNotification();
3289   application.Render();
3290
3291
3292   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3293   propertyMap.Clear();
3294   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3295   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3296   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3297   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3298
3299   Property::Map transformMap;
3300   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3301   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3302
3303   textVisual = factory.CreateVisual( propertyMap );
3304   textVisual.SetDepthIndex( 1 );
3305
3306   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3307   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 720.f, 640.f ) );
3308
3309   application.SendNotification(); // force process events to ensure text visual
3310   // adds renderer to the dummy control in OnRelayout
3311   application.Render();
3312
3313   Renderer renderer = dummyControl.GetRendererAt(0u);
3314   Property::Index index = renderer.GetPropertyIndex("size");
3315
3316   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3317   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3318
3319   END_TEST;
3320 }
3321
3322 int UtcDaliVisualTextVisualDisableEnable(void)
3323 {
3324   ToolkitTestApplication application;
3325   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3326
3327   VisualFactory factory = VisualFactory::Get();
3328   Property::Map propertyMap;
3329   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3330   propertyMap.Insert( "mixColor", Color::WHITE );
3331   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::DevelText::DEFAULT_RENDERING_BACKEND ) );
3332   propertyMap.Insert( "enableMarkup", false );
3333   propertyMap.Insert( "text", "Hello world" );
3334   propertyMap.Insert( "fontFamily", "TizenSans" );
3335
3336   Property::Map fontStyleMapSet;
3337   fontStyleMapSet.Insert( "weight", "bold" );
3338   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3339
3340   propertyMap.Insert( "pointSize", 12.f );
3341   propertyMap.Insert( "multiLine", true );
3342   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3343   propertyMap.Insert( "verticalAlignment", "CENTER" );
3344   propertyMap.Insert( "textColor", Color::RED );
3345   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3346   textVisual.SetDepthIndex( 1 );
3347
3348   DummyControl dummyControl = DummyControl::New(true);
3349   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3350   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3351   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3352
3353   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3354   dummyControl.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3355
3356   application.GetScene().Add( dummyControl );
3357   application.SendNotification();
3358   application.Render();
3359
3360   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3361
3362   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3363
3364   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3365
3366   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3367
3368   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3369
3370   END_TEST;
3371 }
3372
3373 int UtcDaliVisualPremultipliedAlpha(void)
3374 {
3375   ToolkitTestApplication application;
3376   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3377
3378   VisualFactory factory = VisualFactory::Get();
3379
3380   // image visual, test default value ( true )
3381   {
3382     Visual::Base imageVisual = factory.CreateVisual(
3383           Property::Map()
3384           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3385           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3386
3387     Dali::Property::Map visualMap;
3388     imageVisual.CreatePropertyMap( visualMap );
3389     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3390
3391     // test values
3392     DALI_TEST_CHECK( value );
3393     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3394   }
3395
3396   // image visual, override premultiplied
3397   {
3398     Visual::Base imageVisual = factory.CreateVisual(
3399           Property::Map()
3400           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3401           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3402           .Add( Visual::Property::PREMULTIPLIED_ALPHA, false ) );
3403
3404     Dali::Property::Map visualMap;
3405     imageVisual.CreatePropertyMap( visualMap );
3406     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3407
3408     // test values
3409     DALI_TEST_CHECK( value );
3410     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION);
3411   }
3412
3413   // svg visual ( premultiplied alpha by default is true )
3414   {
3415     Visual::Base imageVisual = factory.CreateVisual(
3416           Property::Map()
3417           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3418           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3419
3420     Dali::Property::Map visualMap;
3421     imageVisual.CreatePropertyMap( visualMap );
3422     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3423
3424     // test values
3425     DALI_TEST_CHECK( value );
3426     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3427   }
3428
3429   END_TEST;
3430 }
3431
3432 int UtcDaliRegisterVisualOrder(void)
3433 {
3434   ToolkitTestApplication application;
3435   tet_infoline( "Register Visual Order" );
3436
3437   DummyControl dummyControl = DummyControl::New(true);
3438   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3439
3440   VisualFactory factory = VisualFactory::Get();
3441   Property::Map propertyMap;
3442   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3443   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3444
3445   tet_infoline( "Register visual, should have depth index of 0.0f" );
3446   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3447   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3448   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3449
3450   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3451
3452   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3453   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3454   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3455
3456   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3457   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3458   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3459
3460   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3461   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3462   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3463
3464   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3465   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3466   labelVisual.SetDepthIndex( -2000 );
3467   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3468   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3469
3470   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3471   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3472   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3473   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3474   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3475   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3476
3477   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3478   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3479   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3480   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3481   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3482
3483   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3484   application.GetScene().Add( dummyControl );
3485
3486   END_TEST;
3487 }
3488
3489 int UtcDaliRegisterVisualOrder02(void)
3490 {
3491   ToolkitTestApplication application;
3492   tet_infoline( "Register Visual Order with Background Set" );
3493
3494   DummyControl dummyControl = DummyControl::New(true);
3495   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3496
3497   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3498
3499   VisualFactory factory = VisualFactory::Get();
3500   Property::Map propertyMap;
3501   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3502   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3503
3504   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3505
3506   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3507
3508   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3509   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3510   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3511   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3512   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3513
3514   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3515   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3516   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3517   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3518
3519   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3520   application.GetScene().Add( dummyControl );
3521
3522   END_TEST;
3523 }
3524
3525 int UtcDaliRegisterVisualWithDepthIndex(void)
3526 {
3527   ToolkitTestApplication application;
3528   tet_infoline( "Register a Visual With Depth Index" );
3529
3530   DummyControl dummyControl = DummyControl::New(true);
3531   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3532
3533   VisualFactory factory = VisualFactory::Get();
3534   Property::Map propertyMap;
3535   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3536   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3537
3538   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3539   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3540   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3541   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3542   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3543
3544   tet_infoline( "Register another visual with a depth index and it disabled" );
3545   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3546   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3547   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3548   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3549
3550   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3551   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3552   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3553   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3554   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3555
3556   dummyControl.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3557   application.GetScene().Add( dummyControl );
3558
3559   END_TEST;
3560 }
3561
3562 int UtcDaliColorVisualRenderIfTransparentProperty(void)
3563 {
3564   ToolkitTestApplication application;
3565   tet_infoline( "Test the renderIfTransparent property of ColorVisual" );
3566
3567   VisualFactory factory = VisualFactory::Get();
3568   Property::Map propertyMap;
3569   propertyMap.Insert( Visual::Property::TYPE,  Visual::COLOR );
3570   propertyMap.Insert( ColorVisual::Property::MIX_COLOR, Color::BLUE );
3571
3572   tet_infoline( "Check default value" );
3573   {
3574     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3575     Property::Map returnedMap;
3576     testVisual.CreatePropertyMap( returnedMap );
3577
3578     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3579     DALI_TEST_CHECK( renderIfTransparentProperty );
3580     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3581   }
3582
3583   propertyMap.Insert( DevelColorVisual::Property::RENDER_IF_TRANSPARENT, true );
3584
3585   tet_infoline( "Ensure set to value required" );
3586   {
3587     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3588     Property::Map returnedMap;
3589     testVisual.CreatePropertyMap( returnedMap );
3590
3591     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3592     DALI_TEST_CHECK( renderIfTransparentProperty );
3593     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), true, TEST_LOCATION );
3594   }
3595
3596   propertyMap[ DevelColorVisual::Property::RENDER_IF_TRANSPARENT ] = Color::BLUE;
3597
3598   tet_infoline( "Ensure it returns default value if set to wrong type" );
3599   {
3600     Visual::Base testVisual = factory.CreateVisual( propertyMap );
3601     Property::Map returnedMap;
3602     testVisual.CreatePropertyMap( returnedMap );
3603
3604     Property::Value* renderIfTransparentProperty = returnedMap.Find( DevelColorVisual::Property::RENDER_IF_TRANSPARENT );
3605     DALI_TEST_CHECK( renderIfTransparentProperty );
3606     DALI_TEST_EQUALS( renderIfTransparentProperty->Get< bool >(), false, TEST_LOCATION );
3607   }
3608
3609   END_TEST;
3610 }
3611
3612 int UtcDaliSvgVisualCustomShader(void)
3613 {
3614   ToolkitTestApplication application;
3615   tet_infoline( "SvgVisual with custom shader" );
3616
3617   VisualFactory factory = VisualFactory::Get();
3618   Property::Map properties;
3619   Property::Map shader;
3620   const std::string vertexShader = "Foobar";
3621   const std::string fragmentShader = "Foobar";
3622   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3623   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
3624
3625   properties[Visual::Property::TYPE] = Visual::IMAGE;
3626   properties[Visual::Property::SHADER] = shader;
3627   properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3628
3629   Visual::Base visual = factory.CreateVisual( properties );
3630
3631   // trigger creation through setting on stage
3632   DummyControl dummy = DummyControl::New( true );
3633   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3634   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3635
3636   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3637   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3638   application.GetScene().Add( dummy );
3639
3640   application.SendNotification();
3641   application.Render();
3642
3643   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3644
3645   Renderer renderer = dummy.GetRendererAt( 0 );
3646   Shader shader2 = renderer.GetShader();
3647   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
3648   Property::Map* map = value.GetMap();
3649   DALI_TEST_CHECK( map );
3650
3651   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
3652   DALI_TEST_EQUALS( fragmentShader, fragment->Get< std::string >(), TEST_LOCATION );
3653
3654   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
3655   DALI_TEST_EQUALS( vertexShader, vertex->Get< std::string >(), TEST_LOCATION );
3656
3657   END_TEST;
3658 }
3659
3660 int UtcDaliVisualRoundedCorner(void)
3661 {
3662 #ifdef OLD_GRAPHICS_TEST
3663   ToolkitTestApplication application;
3664   tet_infoline( "UtcDaliVisualRoundedCorner" );
3665
3666   static std::vector<UniformData> customUniforms =
3667   {
3668     UniformData("cornerRadius", Property::Type::VECTOR4),
3669     UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
3670   };
3671
3672   TestGraphicsController& graphics = application.GetGraphicsController();
3673   graphics.AddCustomUniforms(customUniforms);
3674
3675   // image visual
3676   {
3677     VisualFactory factory = VisualFactory::Get();
3678     Property::Map properties;
3679     float cornerRadius = 30.0f;
3680
3681     properties[Visual::Property::TYPE] = Visual::IMAGE;
3682     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
3683     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3684
3685     Visual::Base visual = factory.CreateVisual( properties );
3686
3687     // trigger creation through setting on stage
3688     DummyControl dummy = DummyControl::New( true );
3689     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3690     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3691
3692     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3693     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3694     application.GetScene().Add( dummy );
3695
3696     application.SendNotification();
3697     application.Render();
3698
3699     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3700
3701     application.SendNotification();
3702     application.Render();
3703
3704     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3705     // Default corner radius policy is absolute.
3706     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3707   }
3708
3709   // color visual 1
3710   {
3711     VisualFactory factory = VisualFactory::Get();
3712     Property::Map properties;
3713     float cornerRadius = 30.0f;
3714
3715     properties[Visual::Property::TYPE] = Visual::COLOR;
3716     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3717     properties["cornerRadius"] = cornerRadius;
3718     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3719
3720     Visual::Base visual = factory.CreateVisual( properties );
3721
3722     // trigger creation through setting on stage
3723     DummyControl dummy = DummyControl::New( true );
3724     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3725     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3726
3727     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3728     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3729     application.GetScene().Add( dummy );
3730
3731     application.SendNotification();
3732     application.Render();
3733
3734     application.SendNotification();
3735     application.Render();
3736
3737     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3738     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3739   }
3740
3741   // color visual 2
3742   {
3743     VisualFactory factory = VisualFactory::Get();
3744     Property::Map properties;
3745     Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
3746
3747     properties[Visual::Property::TYPE] = Visual::COLOR;
3748     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3749     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3750     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3751
3752     Visual::Base visual = factory.CreateVisual( properties );
3753
3754     // trigger creation through setting on stage
3755     DummyControl dummy = DummyControl::New( true );
3756     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3757     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3758
3759     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3760     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3761     application.GetScene().Add( dummy );
3762
3763     application.SendNotification();
3764     application.Render();
3765
3766     application.SendNotification();
3767     application.Render();
3768
3769     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3770     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3771   }
3772
3773   // color visual 3 - invalid value
3774   {
3775     VisualFactory factory = VisualFactory::Get();
3776     Property::Map properties;
3777     Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
3778
3779     properties[Visual::Property::TYPE] = Visual::COLOR;
3780     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3781     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3782     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = -1; // Set an invalid value
3783
3784     Visual::Base visual = factory.CreateVisual( properties );
3785
3786     // trigger creation through setting on stage
3787     DummyControl dummy = DummyControl::New( true );
3788     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3789     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3790
3791     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3792     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3793     application.GetScene().Add( dummy );
3794
3795     application.SendNotification();
3796     application.Render();
3797
3798     application.SendNotification();
3799     application.Render();
3800
3801     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3802     // Default corner radius policy is absolute.
3803     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3804   }
3805
3806   // gradient visual
3807   {
3808     VisualFactory factory = VisualFactory::Get();
3809     Property::Map properties;
3810     float cornerRadius = 30.0f;
3811
3812     properties[Visual::Property::TYPE] = Visual::GRADIENT;
3813     properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3814     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3815     properties[GradientVisual::Property::START_POSITION] = Vector2( 0.5f, 0.5f );
3816     properties[GradientVisual::Property::END_POSITION] = Vector2( -0.5f, -0.5f );
3817     properties[GradientVisual::Property::UNITS] = GradientVisual::Units::USER_SPACE;
3818
3819     Property::Array stopOffsets;
3820     stopOffsets.PushBack( 0.0f );
3821     stopOffsets.PushBack( 0.6f );
3822     stopOffsets.PushBack( 1.0f );
3823     properties[GradientVisual::Property::STOP_OFFSET] = stopOffsets;
3824
3825     Property::Array stopColors;
3826     stopColors.PushBack( Color::RED );
3827     stopColors.PushBack( Color::YELLOW );
3828     stopColors.PushBack( Color::GREEN );
3829     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
3830
3831     Visual::Base visual = factory.CreateVisual( properties );
3832
3833     // trigger creation through setting on stage
3834     DummyControl dummy = DummyControl::New( true );
3835     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3836     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3837
3838     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3839     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3840     application.GetScene().Add( dummy );
3841
3842     application.SendNotification();
3843     application.Render();
3844
3845     application.SendNotification();
3846     application.Render();
3847
3848     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3849     // Default corner radius policy is absolute.
3850     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3851   }
3852
3853   // animated image visual
3854   {
3855     VisualFactory factory = VisualFactory::Get();
3856     Property::Map properties;
3857     Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
3858
3859     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
3860     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3861     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
3862     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3863     properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
3864
3865     Visual::Base visual = factory.CreateVisual( properties );
3866
3867     // trigger creation through setting on stage
3868     DummyControl dummy = DummyControl::New( true );
3869     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3870     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3871
3872     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3873     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3874     application.GetScene().Add( dummy );
3875
3876     application.SendNotification();
3877     application.Render();
3878
3879     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3880
3881     application.SendNotification();
3882     application.Render();
3883
3884     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3885     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3886   }
3887
3888   // vector image visual
3889   {
3890     VisualFactory factory = VisualFactory::Get();
3891     Property::Map properties;
3892     Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
3893
3894     properties[Visual::Property::TYPE] = Visual::SVG;
3895     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
3896     properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
3897
3898     Visual::Base visual = factory.CreateVisual( properties );
3899
3900     // trigger creation through setting on stage
3901     DummyControl dummy = DummyControl::New( true );
3902     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3903     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3904
3905     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3906     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3907     application.GetScene().Add( dummy );
3908
3909     application.SendNotification();
3910     application.Render();
3911
3912     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3913
3914     application.SendNotification();
3915     application.Render();
3916
3917     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
3918     // Default corner radius policy is absolute.
3919     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
3920   }
3921
3922   // animated vector image visual
3923   {
3924     VisualFactory factory = VisualFactory::Get();
3925     Property::Map properties;
3926     float cornerRadius = 1.3f;
3927
3928     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
3929     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
3930     properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
3931     properties["cornerRadius"] = cornerRadius;
3932     properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
3933
3934     Visual::Base visual = factory.CreateVisual( properties );
3935
3936     // trigger creation through setting on stage
3937     DummyControl dummy = DummyControl::New( true );
3938     Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3939     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3940
3941     dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3942     dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3943     application.GetScene().Add( dummy );
3944
3945     application.SendNotification();
3946     application.Render();
3947
3948     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
3949
3950     application.SendNotification();
3951     application.Render();
3952
3953     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
3954     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
3955   }
3956 #else
3957   tet_result(TET_PASS);
3958 #endif
3959
3960   END_TEST;
3961 }
3962
3963 int UtcDaliColorVisualBlurRadius(void)
3964 {
3965   ToolkitTestApplication application;
3966   tet_infoline( "UtcDaliColorVisualBlurRadius" );
3967
3968   static std::vector<UniformData> customUniforms =
3969   {
3970     UniformData("blurRadius", Property::Type::FLOAT),
3971   };
3972
3973   TestGraphicsController& graphics = application.GetGraphicsController();
3974   graphics.AddCustomUniforms(customUniforms);
3975
3976   VisualFactory factory = VisualFactory::Get();
3977   Property::Map properties;
3978   float blurRadius = 20.0f;
3979
3980   properties[Visual::Property::TYPE] = Visual::COLOR;
3981   properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
3982   properties["blurRadius"] = blurRadius;
3983
3984   Visual::Base visual = factory.CreateVisual( properties );
3985
3986   // trigger creation through setting on stage
3987   DummyControl dummy = DummyControl::New( true );
3988   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
3989   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
3990
3991   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
3992   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
3993   application.GetScene().Add( dummy );
3994
3995   application.SendNotification();
3996   application.Render();
3997
3998   application.SendNotification();
3999   application.Render();
4000
4001   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "blurRadius", blurRadius ), true, TEST_LOCATION );
4002
4003   END_TEST;
4004 }
4005
4006 int UtcDaliVisualGetType(void)
4007 {
4008   ToolkitTestApplication application;
4009   tet_infoline( "UtcDaliVisualGetType" );
4010
4011   VisualFactory factory = VisualFactory::Get();
4012
4013   {
4014     Property::Map properties;
4015     properties[Visual::Property::TYPE] = Visual::BORDER;
4016     Visual::Base visual = factory.CreateVisual( properties );
4017
4018     DALI_TEST_CHECK( visual.GetType() == Visual::BORDER );
4019   }
4020
4021   {
4022     Property::Map properties;
4023     properties[Visual::Property::TYPE] = Visual::COLOR;
4024     Visual::Base visual = factory.CreateVisual( properties );
4025
4026     DALI_TEST_CHECK( visual.GetType() == Visual::COLOR );
4027   }
4028
4029   {
4030     Property::Map properties;
4031     properties[Visual::Property::TYPE] = Visual::GRADIENT;
4032     properties[GradientVisual::Property::START_POSITION] = Vector2( -1.f, -1.f );
4033     properties[GradientVisual::Property::END_POSITION] = Vector2( 1.f, 1.f );
4034     properties[GradientVisual::Property::STOP_OFFSET] = Vector2(0.f, 1.f);
4035     // propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
4036     Property::Array stopColors;
4037     stopColors.PushBack( Color::RED );
4038     stopColors.PushBack( Color::GREEN );
4039     properties[GradientVisual::Property::STOP_COLOR] = stopColors;
4040     Visual::Base visual = factory.CreateVisual( properties );
4041
4042     DALI_TEST_CHECK( visual.GetType() == Visual::GRADIENT );
4043   }
4044
4045   {
4046     Property::Map properties;
4047     properties[Visual::Property::TYPE] = Visual::IMAGE;
4048     properties.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
4049     Visual::Base visual = factory.CreateVisual( properties );
4050
4051     DALI_TEST_CHECK( visual.GetType() == Visual::IMAGE );
4052   }
4053
4054   {
4055     Property::Map properties;
4056     properties[Visual::Property::TYPE] = Visual::MESH;
4057     Visual::Base visual = factory.CreateVisual( properties );
4058
4059     DALI_TEST_CHECK( visual.GetType() == Visual::MESH );
4060   }
4061
4062   {
4063     Property::Map properties;
4064     properties[Visual::Property::TYPE] = Visual::PRIMITIVE;
4065     properties[PrimitiveVisual::Property::SHAPE] = PrimitiveVisual::Shape::CUBE;
4066     Visual::Base visual = factory.CreateVisual( properties );
4067
4068     DALI_TEST_CHECK( visual.GetType() == Visual::PRIMITIVE );
4069   }
4070
4071   {
4072     Property::Map properties;
4073     properties[Visual::Property::TYPE] = Visual::WIREFRAME;
4074     Visual::Base visual = factory.CreateVisual( properties );
4075
4076     DALI_TEST_CHECK( visual.GetType() == Visual::WIREFRAME );
4077   }
4078
4079   {
4080     Property::Map properties;
4081     properties[Visual::Property::TYPE] = Visual::TEXT;
4082     Visual::Base visual = factory.CreateVisual( properties );
4083
4084     DALI_TEST_CHECK( visual.GetType() == Visual::TEXT );
4085   }
4086
4087   {
4088     Property::Map properties;
4089     properties[Visual::Property::TYPE] = Visual::N_PATCH;
4090     properties[ImageVisual::Property::URL] =  TEST_NPATCH_FILE_NAME;
4091     Visual::Base visual = factory.CreateVisual( properties );
4092
4093     DALI_TEST_CHECK( visual.GetType() == Visual::N_PATCH );
4094   }
4095
4096   {
4097     Property::Map properties;
4098     properties[Visual::Property::TYPE] = Visual::SVG;
4099     properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
4100     Visual::Base visual = factory.CreateVisual( properties );
4101
4102     DALI_TEST_CHECK( visual.GetType() == Visual::SVG );
4103   }
4104
4105   {
4106     Property::Map properties;
4107     properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
4108     properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
4109     Visual::Base visual = factory.CreateVisual( properties );
4110
4111     DALI_TEST_CHECK( visual.GetType() == Visual::ANIMATED_IMAGE );
4112   }
4113
4114   {
4115     Property::Map properties;
4116     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_GRADIENT;
4117     Visual::Base visual = factory.CreateVisual( properties );
4118
4119     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_GRADIENT ) );
4120   }
4121
4122   {
4123     Property::Map properties;
4124     properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
4125     properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
4126     Visual::Base visual = factory.CreateVisual( properties );
4127
4128     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ANIMATED_VECTOR_IMAGE ) );
4129   }
4130
4131   {
4132     Property::Map properties;
4133     properties[Visual::Property::TYPE] = DevelVisual::ARC;
4134     Visual::Base visual = factory.CreateVisual( properties );
4135
4136     DALI_TEST_CHECK( visual.GetType() == static_cast<Visual::Type>( DevelVisual::ARC ) );
4137   }
4138
4139   END_TEST;
4140 }
4141
4142 int UtcDaliVisualGetVisualProperty01(void)
4143 {
4144   ToolkitTestApplication application;
4145   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, Visual::Base, ColorVisual" );
4146
4147   static std::vector<UniformData> customUniforms =
4148   {
4149     UniformData("mixColor", Property::Type::VECTOR3),
4150     UniformData("offset", Property::Type::VECTOR2),
4151     UniformData("size", Property::Type::VECTOR2),
4152     UniformData("cornerRadius", Property::Type::VECTOR4),
4153     UniformData("blurRadius", Property::Type::FLOAT),
4154   };
4155
4156   TestGraphicsController& graphics = application.GetGraphicsController();
4157   graphics.AddCustomUniforms(customUniforms);
4158
4159   VisualFactory factory = VisualFactory::Get();
4160   Property::Map propertyMap;
4161   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4162   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
4163   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
4164   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
4165   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
4166   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4167
4168   DummyControl dummyControl = DummyControl::New(true);
4169   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4170   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4171   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4172   application.GetScene().Add(dummyControl);
4173
4174   application.SendNotification();
4175   application.Render();
4176
4177   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4178   Vector2 targetOffset(0.05f, 0.05f);
4179   Vector2 targetSize(1.1f, 1.1f);
4180   float targetOpacity = 0.5f;
4181   Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
4182   float targetBlurRadius = 10.0f;
4183
4184   Animation animation = Animation::New(1.0f);
4185   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), targetColor);
4186   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4187   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::OFFSET), targetOffset);
4188   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Transform::Property::SIZE), targetSize);
4189   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4190   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::BLUR_RADIUS), targetBlurRadius);
4191   animation.Play();
4192
4193   application.SendNotification();
4194   application.Render();
4195   application.Render(1001u); // End of animation
4196
4197   Property::Map resultMap;
4198   colorVisual.CreatePropertyMap( resultMap );
4199
4200   // Test property values: they should be updated
4201   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4202   DALI_TEST_CHECK(colorValue);
4203   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4204
4205   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4206   Dali::Property::Map* transformMap = transformValue->GetMap();
4207   DALI_TEST_CHECK(transformMap);
4208
4209   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4210   DALI_TEST_CHECK(offsetValue);
4211   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4212
4213   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4214   DALI_TEST_CHECK(sizeValue);
4215   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4216
4217   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4218   DALI_TEST_CHECK(cornerRadiusValue);
4219   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4220
4221   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4222   DALI_TEST_CHECK(blurRadiusValue);
4223   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4224
4225   // Test uniform values
4226   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4227   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4228   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4229   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4230   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4231
4232   // Test not-supported property
4233   Property property1 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::PREMULTIPLIED_ALPHA);
4234   DALI_TEST_CHECK(!property1.object);
4235   DALI_TEST_CHECK(property1.propertyIndex == Property::INVALID_INDEX);
4236
4237   // Test not-supported property
4238   Property property2 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelColorVisual::Property::RENDER_IF_TRANSPARENT);
4239   DALI_TEST_CHECK(!property2.object);
4240   DALI_TEST_CHECK(property2.propertyIndex == Property::INVALID_INDEX);
4241
4242   // Test unregistered visual
4243   Property property3 = DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL2, Visual::Property::MIX_COLOR);
4244   DALI_TEST_CHECK(!property3.object);
4245   DALI_TEST_CHECK(property3.propertyIndex == Property::INVALID_INDEX);
4246
4247   END_TEST;
4248 }
4249
4250 int UtcDaliVisualGetVisualProperty02(void)
4251 {
4252   ToolkitTestApplication application;
4253   tet_infoline( "UtcDaliVisualGetVisualProperty02: Test animatable property" );
4254
4255   static std::vector<UniformData> customUniforms =
4256   {
4257     UniformData("mixColor", Property::Type::VECTOR3),
4258     UniformData("offset", Property::Type::VECTOR2),
4259     UniformData("size", Property::Type::VECTOR2),
4260     UniformData("cornerRadius", Property::Type::VECTOR4),
4261     UniformData("blurRadius", Property::Type::FLOAT),
4262   };
4263
4264   TestGraphicsController& graphics = application.GetGraphicsController();
4265   graphics.AddCustomUniforms(customUniforms);
4266
4267   VisualFactory factory = VisualFactory::Get();
4268   Property::Map propertyMap;
4269   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
4270   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
4271
4272   DummyControl dummyControl = DummyControl::New(true);
4273   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4274   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, colorVisual);
4275   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4276   application.GetScene().Add(dummyControl);
4277
4278   application.SendNotification();
4279   application.Render();
4280
4281   Vector3 targetColor(1.0f, 1.0f, 1.0f);
4282   Vector2 targetOffset(0.05f, 0.05f);
4283   Vector2 targetSize(1.1f, 1.1f);
4284   float targetOpacity = 0.5f;
4285   Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
4286   float targetBlurRadius = 10.0f;
4287
4288   // Should work when the properties are not set before
4289   Animation animation = Animation::New(1.0f);
4290   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "mixColor"), targetColor);
4291   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "opacity"), targetOpacity);
4292   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "offset"), targetOffset);
4293   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "size"), targetSize);
4294   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "cornerRadius"), targetCornerRadius);
4295   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, "blurRadius"), targetBlurRadius);
4296   animation.Play();
4297
4298   application.SendNotification();
4299   application.Render();
4300   application.Render(1001u); // End of animation
4301
4302   Property::Map resultMap;
4303   colorVisual.CreatePropertyMap(resultMap);
4304
4305   // Test property values: they should be updated
4306   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
4307   DALI_TEST_CHECK(colorValue);
4308   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(targetColor.r, targetColor.g, targetColor.b, targetOpacity), TEST_LOCATION);
4309
4310   Property::Value* transformValue = resultMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
4311   Dali::Property::Map* transformMap = transformValue->GetMap();
4312   DALI_TEST_CHECK(transformMap);
4313
4314   Property::Value* offsetValue = transformMap->Find(Toolkit::Visual::Transform::Property::OFFSET);
4315   DALI_TEST_CHECK(offsetValue);
4316   DALI_TEST_EQUALS(offsetValue->Get<Vector2>(), targetOffset, TEST_LOCATION);
4317
4318   Property::Value* sizeValue = transformMap->Find(Toolkit::Visual::Transform::Property::SIZE);
4319   DALI_TEST_CHECK(sizeValue);
4320   DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
4321
4322   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4323   DALI_TEST_CHECK(cornerRadiusValue);
4324   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4325
4326   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
4327   DALI_TEST_CHECK(blurRadiusValue);
4328   DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
4329
4330 #ifdef OLD_GRAPHICS_TEST
4331   // Test uniform values
4332   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
4333   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
4334   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
4335   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4336   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
4337 #endif
4338
4339   END_TEST;
4340 }
4341
4342 int UtcDaliVisualGetVisualProperty03(void)
4343 {
4344 #ifdef OLD_GRAPHICS_TEST
4345   ToolkitTestApplication application;
4346   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, ImageVisual" );
4347
4348   static std::vector<UniformData> customUniforms =
4349   {
4350     UniformData("cornerRadius", Property::Type::VECTOR4),
4351   };
4352
4353   TestGraphicsController& graphics = application.GetGraphicsController();
4354   graphics.AddCustomUniforms(customUniforms);
4355
4356   VisualFactory factory = VisualFactory::Get();
4357   Property::Map propertyMap;
4358   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
4359   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
4360   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
4361
4362   DummyControl dummyControl = DummyControl::New(true);
4363   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4364   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
4365   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4366   application.GetScene().Add(dummyControl);
4367
4368   // Wait for image loading
4369   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4370
4371   application.SendNotification();
4372   application.Render();
4373
4374   float targetOpacity = 0.5f;
4375   Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
4376
4377   Animation animation = Animation::New(1.0f);
4378   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4379   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4380   animation.Play();
4381
4382   application.SendNotification();
4383   application.Render();
4384   application.Render(1001u); // End of animation
4385
4386   Property::Map resultMap;
4387   imageVisual.CreatePropertyMap( resultMap );
4388
4389   // Test property values: they should be updated
4390   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4391   DALI_TEST_CHECK(colorValue);
4392   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4393
4394   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4395   DALI_TEST_CHECK(cornerRadiusValue);
4396   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4397
4398   // Test uniform value
4399   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4400 #else
4401   tet_result(TET_PASS);
4402 #endif
4403
4404   END_TEST;
4405 }
4406
4407 int UtcDaliVisualGetVisualProperty04(void)
4408 {
4409 #ifdef OLD_GRAPHICS_TEST
4410   ToolkitTestApplication application;
4411   tet_infoline( "UtcDaliVisualGetVisualProperty01: Test animatable property, GradientVisual" );
4412
4413   static std::vector<UniformData> customUniforms =
4414   {
4415     UniformData("cornerRadius", Property::Type::VECTOR4),
4416   };
4417
4418   TestGraphicsController& graphics = application.GetGraphicsController();
4419   graphics.AddCustomUniforms(customUniforms);
4420
4421   Vector2 start(-1.f, -1.f);
4422   Vector2 end(1.f, 1.f);
4423   Property::Array stopColors;
4424   stopColors.PushBack( Color::RED );
4425   stopColors.PushBack( Color::GREEN );
4426
4427   VisualFactory factory = VisualFactory::Get();
4428   Property::Map propertyMap;
4429   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
4430   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
4431   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
4432   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
4433   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
4434   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
4435   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
4436
4437   DummyControl dummyControl = DummyControl::New(true);
4438   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
4439   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, gradientVisual);
4440   dummyControl[Actor::Property::SIZE] = Vector2(200.f, 200.f);
4441   application.GetScene().Add(dummyControl);
4442
4443   application.SendNotification();
4444   application.Render();
4445
4446   float targetOpacity = 0.5f;
4447   Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
4448
4449   Animation animation = Animation::New(1.0f);
4450   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
4451   animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), targetCornerRadius);
4452   animation.Play();
4453
4454   application.SendNotification();
4455   application.Render();
4456   application.Render(1001u); // End of animation
4457
4458   Property::Map resultMap;
4459   gradientVisual.CreatePropertyMap( resultMap );
4460
4461   // Test property values: they should be updated
4462   Property::Value* colorValue = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
4463   DALI_TEST_CHECK(colorValue);
4464   DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
4465
4466   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
4467   DALI_TEST_CHECK(cornerRadiusValue);
4468   DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
4469
4470   // Test uniform value
4471   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
4472 #else
4473   tet_result(TET_PASS);
4474 #endif
4475
4476   END_TEST;
4477 }