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

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