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

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