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

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