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

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