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

   1 /*
   2  * Copyright (c) 2017 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 <dali-toolkit-test-suite-utils.h>
  22 #include <dali/public-api/rendering/renderer.h>
  23 #include <dali/public-api/rendering/texture-set.h>
  24 #include <dali/public-api/rendering/shader.h>
  25 #include <dali/devel-api/object/handle-devel.h>
  26 #include <dali-toolkit/devel-api/controls/control-devel.h>
  27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  28 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  29 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
  30 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  31 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  32 #include <dali-toolkit/devel-api/align-enums.h>
  33 #include <dali-toolkit/dali-toolkit.h>
  34 #include "dummy-control.h"
  35
  36 using namespace Dali;
  37 using namespace Dali::Toolkit;
  38
  39 namespace
  40 {
  41 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  42 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  43 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  44 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  45 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  46 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  47 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
  48
  49 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
  50
  51 Property::Map DefaultTransform()
  52 {
  53   Property::Map transformMap;
  54   transformMap
  55     .Add( Toolkit::DevelVisual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  56     .Add( Toolkit::DevelVisual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  57     .Add( Toolkit::DevelVisual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
  58     .Add( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN )
  59     .Add( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ) )
  60     .Add( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ) );
  61   return transformMap;
  62 }
  63
  64 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
  65 {
  66   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
  67   {
  68     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
  69     {
  70       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
  71
  72       Property::Value* valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
  73       if( NULL != valueSet )
  74       {
  75         if( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() )
  76         {
  77           tet_printf( "  Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
  78           return false;
  79         }
  80       }
  81       else
  82       {
  83         tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
  84         return false;
  85       }
  86     }
  87   }
  88
  89   return true;
  90 }
  91
  92 void PrepareResourceImage( ToolkitTestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  93 {
  94   TestPlatformAbstraction& platform = application.GetPlatform();
  95   platform.SetClosestImageSize(Vector2( imageWidth, imageHeight));
  96
  97   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  98   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  99   unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
 100   unsigned int initialColor = 0xFF;
 101   memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
 102
 103   Integration::ResourcePointer resourcePtr(bitmap);
 104   platform.SetSynchronouslyLoadedResource( resourcePtr );
 105 }
 106 } //namespace
 107
 108 void dali_visual_startup(void)
 109 {
 110   test_return_value = TET_UNDEF;
 111 }
 112
 113 void dali_visual_cleanup(void)
 114 {
 115   test_return_value = TET_PASS;
 116 }
 117
 118
 119 static void TestMixColor( Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor )
 120 {
 121   Property::Map map;
 122   visual.CreatePropertyMap(map);
 123   Property::Value* value = map.Find( mixColorIndex );
 124   DALI_TEST_CHECK( value );
 125   Vector3 mixColor1;
 126   DALI_TEST_CHECK( value->Get( mixColor1 ) );
 127   DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
 128
 129   value = map.Find( DevelVisual::Property::MIX_COLOR );
 130   DALI_TEST_CHECK( value );
 131   Vector4 mixColor2;
 132   DALI_TEST_CHECK( value->Get( mixColor2 ) );
 133   DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
 134
 135   value = map.Find( DevelVisual::Property::OPACITY );
 136   DALI_TEST_CHECK( value );
 137   float opacity;
 138   DALI_TEST_CHECK( value->Get( opacity ) );
 139   DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
 140 }
 141
 142
 143 int UtcDaliVisualCopyAndAssignment(void)
 144 {
 145   ToolkitTestApplication application;
 146   tet_infoline( "UtcDaliVisualCopyAndAssignment" );
 147
 148   VisualFactory factory = VisualFactory::Get();
 149   Property::Map propertyMap;
 150   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 151   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 152   Visual::Base visual = factory.CreateVisual( propertyMap );
 153
 154   Visual::Base visualCopy( visual );
 155   DALI_TEST_CHECK(visual == visualCopy);
 156
 157   Visual::Base emptyVisual;
 158   Visual::Base emptyVisualCopy( emptyVisual );
 159   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 160
 161   Visual::Base visualEquals;
 162   visualEquals = visual;
 163   DALI_TEST_CHECK(visual == visualEquals);
 164
 165   Visual::Base emptyVisualEquals;
 166   emptyVisualEquals = emptyVisual;
 167   DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
 168
 169   //self assignment
 170   visual = visual;
 171   DALI_TEST_CHECK( visual = visualCopy );
 172
 173   END_TEST;
 174 }
 175
 176 int UtcDaliVisualSetName01(void)
 177 {
 178   ToolkitTestApplication application;
 179   tet_infoline( "UtcDaliVisualSetName" );
 180
 181   VisualFactory factory = VisualFactory::Get();
 182   Property::Map propertyMap;
 183   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 184   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 185   Visual::Base visual = factory.CreateVisual( propertyMap );
 186
 187   const char* visualName = "backgroundVisual";
 188   visual.SetName( visualName );
 189
 190   DALI_TEST_EQUALS( visual.GetName(), visualName, TEST_LOCATION );
 191
 192   END_TEST;
 193 }
 194
 195 int UtcDaliVisualSetGetDepthIndex(void)
 196 {
 197   ToolkitTestApplication application;
 198   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 199
 200   VisualFactory factory = VisualFactory::Get();
 201   Property::Map propertyMap;
 202   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 203   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 204   Visual::Base visual = factory.CreateVisual( propertyMap );
 205
 206   visual.SetDepthIndex( 1 );
 207
 208   DummyControl dummyControl = DummyControl::New(true);
 209   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 210   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 211
 212   dummyControl.SetSize(200.f, 200.f);
 213   Stage::GetCurrent().Add( dummyControl );
 214
 215
 216   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 217   DALI_TEST_EQUALS( depthIndex, 1, TEST_LOCATION );
 218   DALI_TEST_EQUALS( visual.GetDepthIndex(), 1, TEST_LOCATION );
 219
 220   visual.SetDepthIndex( -1 );
 221   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 222   DALI_TEST_EQUALS( depthIndex, -1, TEST_LOCATION );
 223   DALI_TEST_EQUALS( visual.GetDepthIndex(), -1, TEST_LOCATION );
 224
 225   END_TEST;
 226 }
 227
 228 int UtcDaliVisualSize(void)
 229 {
 230   ToolkitTestApplication application;
 231   tet_infoline( "UtcDaliVisualGetNaturalSize" );
 232
 233   VisualFactory factory = VisualFactory::Get();
 234   Vector2 controlSize( 20.f, 30.f );
 235   Vector2 naturalSize;
 236
 237   // color colorVisual
 238   Dali::Property::Map map;
 239   map[ Visual::Property::TYPE ] = Visual::COLOR;
 240   map[ ColorVisual::Property::MIX_COLOR ] = Color::MAGENTA;
 241
 242   Visual::Base colorVisual = factory.CreateVisual( map );
 243   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 244
 245   colorVisual.GetNaturalSize(naturalSize);
 246   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 247
 248   // image visual
 249   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 250   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 251   Visual::Base imageVisual = factory.CreateVisual( image );
 252   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 253
 254   imageVisual.GetNaturalSize(naturalSize);
 255   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
 256
 257   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 258
 259   // border visual
 260   float borderSize = 5.f;
 261   map.Clear();
 262   map[ Visual::Property::TYPE ] = Visual::BORDER;
 263   map[ BorderVisual::Property::COLOR  ] = Color::RED;
 264   map[ BorderVisual::Property::SIZE   ] = borderSize;
 265   Visual::Base borderVisual = factory.CreateVisual( map );
 266   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 267   borderVisual.GetNaturalSize(naturalSize);
 268   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 269
 270   // gradient gradientVisual
 271   Property::Map propertyMap;
 272   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 273   Vector2 start(-1.f, -1.f);
 274   Vector2 end(1.f, 1.f);
 275   propertyMap.Insert( "mixColor", Color::MAGENTA );
 276   propertyMap.Insert( GradientVisual::Property::START_POSITION,   start) ;
 277   propertyMap.Insert( GradientVisual::Property::END_POSITION,   end );
 278   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET,   Vector2(0.f, 1.f) );
 279   propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
 280   Property::Array stopColors;
 281   stopColors.PushBack( Color::RED );
 282   stopColors.PushBack( Color::GREEN );
 283   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 284   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 285   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 286   gradientVisual.GetNaturalSize(naturalSize);
 287   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
 288
 289   // svg visual
 290   Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 291   svgVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 292   svgVisual.GetNaturalSize(naturalSize);
 293   // TEST_SVG_FILE:
 294   //  <svg width="100" height="100">
 295   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 296   //  </svg>
 297   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION );
 298
 299   // svg visual with a size
 300   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions(200, 200) );
 301   svgVisual2.GetNaturalSize(naturalSize);
 302   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
 303
 304   // Text visual.
 305
 306   // Load some fonts to get the same metrics on different platforms.
 307   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 308   fontClient.SetDpi( 96u, 96u );
 309
 310   char* pathNamePtr = get_current_dir_name();
 311   const std::string pathName( pathNamePtr );
 312   free( pathNamePtr );
 313
 314   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf" );
 315
 316   propertyMap.Clear();
 317   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
 318   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
 319   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
 320   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
 321
 322   Visual::Base textVisual = factory.CreateVisual( propertyMap );
 323   textVisual.GetNaturalSize( naturalSize );
 324   DALI_TEST_EQUALS( naturalSize, Size( 80.f, 20.f ), TEST_LOCATION );
 325
 326   const float height = textVisual.GetHeightForWidth( 40.f );
 327   DALI_TEST_EQUALS( height, 40.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 328
 329   //AnimatedImageVisual
 330   Visual::Base animatedImageVisual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
 331   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 332   animatedImageVisual.GetNaturalSize(naturalSize);
 333   // TEST_GIF_FILE: anim.gif
 334   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 335   DALI_TEST_EQUALS( naturalSize, Vector2(50.f, 50.f), TEST_LOCATION );
 336
 337   END_TEST;
 338 }
 339
 340 int UtcDaliVisualSetOnOffStage(void)
 341 {
 342   ToolkitTestApplication application;
 343   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 344
 345   VisualFactory factory = VisualFactory::Get();
 346   Property::Map propertyMap;
 347   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 348   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 349   Visual::Base visual = factory.CreateVisual( propertyMap );
 350
 351   DummyControl actor = DummyControl::New(true);
 352   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 353   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 354
 355   actor.SetSize(200.f, 200.f);
 356
 357   application.SendNotification();
 358   application.Render(0);
 359   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 360
 361   Stage::GetCurrent().Add( actor );
 362
 363   application.SendNotification();
 364   application.Render(0);
 365   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 366
 367   Stage::GetCurrent().Remove( actor );
 368
 369   application.SendNotification();
 370   application.Render(0);
 371   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 372
 373   END_TEST;
 374 }
 375
 376 int UtcDaliVisualGetPropertyMap1(void)
 377 {
 378   ToolkitTestApplication application;
 379   tet_infoline( "UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor" );
 380
 381   VisualFactory factory = VisualFactory::Get();
 382   Property::Map propertyMap;
 383   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 384   propertyMap.Insert(DevelVisual::Property::MIX_COLOR,  Color::BLUE);
 385   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 386
 387   Property::Map resultMap;
 388   colorVisual.CreatePropertyMap( resultMap );
 389
 390   Property::Value* typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 391   DALI_TEST_CHECK( typeValue );
 392   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 393
 394   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 395   DALI_TEST_CHECK( colorValue );
 396   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 397
 398   // change the blend color
 399   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 400   colorVisual = factory.CreateVisual( propertyMap  );
 401   colorVisual.CreatePropertyMap( resultMap );
 402
 403   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 404   DALI_TEST_CHECK( colorValue );
 405   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 406
 407   END_TEST;
 408 }
 409
 410 int UtcDaliVisualGetPropertyMap2(void)
 411 {
 412   ToolkitTestApplication application;
 413   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 414
 415   VisualFactory factory = VisualFactory::Get();
 416   Property::Map propertyMap;
 417   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 418   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
 419   propertyMap.Insert("borderColor",  Color::BLUE);
 420   propertyMap.Insert("borderSize",  5.f);
 421   propertyMap.Insert("antiAliasing",  true);
 422   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 423
 424   Property::Map resultMap;
 425   borderVisual.CreatePropertyMap( resultMap );
 426
 427   // check the property values from the returned map from visual
 428   Property::Value* typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 429   DALI_TEST_CHECK( typeValue );
 430   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 431
 432   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 433   DALI_TEST_CHECK( colorValue );
 434   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 435
 436   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 437   DALI_TEST_CHECK( sizeValue );
 438   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 439
 440   Property::Value* AAValue = resultMap.Find( BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN );
 441   DALI_TEST_CHECK( AAValue );
 442   DALI_TEST_CHECK( AAValue->Get<bool>() == true );
 443
 444   Property::Map propertyMap1;
 445   propertyMap1[ Visual::Property::TYPE ] = Visual::BORDER;
 446   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 447   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 448   borderVisual = factory.CreateVisual( propertyMap1 );
 449   borderVisual.CreatePropertyMap( resultMap );
 450
 451   typeValue = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 452   DALI_TEST_CHECK( typeValue );
 453   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 454
 455   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 456   DALI_TEST_CHECK( colorValue );
 457   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 458
 459   colorValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 460   DALI_TEST_CHECK( colorValue );
 461   DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
 462
 463
 464   END_TEST;
 465 }
 466
 467 int UtcDaliVisualGetPropertyMap2N(void)
 468 {
 469   ToolkitTestApplication application;
 470   tet_infoline( "UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties" );
 471
 472   VisualFactory factory = VisualFactory::Get();
 473   Property::Map propertyMap;
 474   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 475   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 476
 477   tet_infoline( "Test that the visual is created, with a default renderer" );
 478   DALI_TEST_CHECK( borderVisual );
 479
 480   DummyControl dummyControl = DummyControl::New(true);
 481   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 482   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
 483   Stage::GetCurrent().Add( dummyControl );
 484
 485   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
 486
 487   END_TEST;
 488 }
 489
 490
 491 int UtcDaliVisualGetPropertyMap3(void)
 492 {
 493   ToolkitTestApplication application;
 494   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 495
 496   VisualFactory factory = VisualFactory::Get();
 497   DALI_TEST_CHECK( factory );
 498
 499   Property::Map propertyMap;
 500   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 501
 502   Vector2 start(-1.f, -1.f);
 503   Vector2 end(1.f, 1.f);
 504   propertyMap.Insert( "startPosition", start);
 505   propertyMap.Insert( "endPosition", end);
 506   propertyMap.Insert( "spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 507
 508   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 509
 510   Property::Array stopColors;
 511   stopColors.PushBack( Color::RED );
 512   stopColors.PushBack( Color::GREEN );
 513   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 514
 515   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 516
 517   Property::Map resultMap;
 518   gradientVisual.CreatePropertyMap( resultMap );
 519
 520   // check the property values from the returned map from visual
 521   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 522   DALI_TEST_CHECK( value );
 523   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 524
 525   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 526   DALI_TEST_CHECK( value );
 527   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 528
 529   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 530   DALI_TEST_CHECK( value );
 531   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 532
 533   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 534   DALI_TEST_CHECK( value );
 535   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 536
 537   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 538   DALI_TEST_CHECK( value );
 539   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 540
 541   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 542   DALI_TEST_CHECK( value );
 543   Property::Array* offsetArray = value->GetArray();
 544   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 545   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 546   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 547
 548   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 549   DALI_TEST_CHECK( value );
 550   Property::Array* colorArray = value->GetArray();
 551   DALI_TEST_CHECK( colorArray->Count() == 2 );
 552   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 553   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 554
 555   END_TEST;
 556 }
 557
 558 int UtcDaliVisualGetPropertyMap4(void)
 559 {
 560   ToolkitTestApplication application;
 561   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 562
 563   VisualFactory factory = VisualFactory::Get();
 564   DALI_TEST_CHECK( factory );
 565
 566   Property::Map propertyMap;
 567   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 568
 569   Vector2 center(100.f, 100.f);
 570   float radius = 100.f;
 571   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 572   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 573   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 574   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 575
 576   Property::Array stopColors;
 577   stopColors.PushBack( Color::RED );
 578   stopColors.PushBack( Color::BLACK );
 579   stopColors.PushBack( Color::GREEN );
 580   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 581
 582   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 583   DALI_TEST_CHECK( gradientVisual );
 584
 585   Property::Map resultMap;
 586   gradientVisual.CreatePropertyMap( resultMap );
 587
 588   // check the property values from the returned map from visual
 589   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 590   DALI_TEST_CHECK( value );
 591   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 592
 593   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 594   DALI_TEST_CHECK( value );
 595   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 596
 597   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 598   DALI_TEST_CHECK( value );
 599   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 600
 601   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 602   DALI_TEST_CHECK( value );
 603   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 604
 605   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 606   DALI_TEST_CHECK( value );
 607   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 608
 609   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 610   DALI_TEST_CHECK( value );
 611   Property::Array* offsetArray = value->GetArray();
 612   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 613   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 614   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 615   // any stop value will be clamped to [0.0, 1.0];
 616   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 617
 618   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 619   DALI_TEST_CHECK( value );
 620   Property::Array* colorArray = value->GetArray();
 621   DALI_TEST_CHECK( colorArray->Count() == 3 );
 622   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 623   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 624   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 625
 626   END_TEST;
 627 }
 628
 629 int UtcDaliVisualGetPropertyMap5(void)
 630 {
 631   ToolkitTestApplication application;
 632   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 633
 634   VisualFactory factory = VisualFactory::Get();
 635   Property::Map propertyMap;
 636   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
 637   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
 638   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 639   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 640   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 641   propertyMap.Insert( "fittingMode",   FittingMode::FIT_HEIGHT );
 642   propertyMap.Insert( "samplingMode",   SamplingMode::BOX_THEN_NEAREST );
 643   propertyMap.Insert( "pixelArea", Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 644   propertyMap.Insert( "wrapModeU", WrapMode::REPEAT );
 645   propertyMap.Insert( "wrapModeV", WrapMode::MIRRORED_REPEAT );
 646   propertyMap.Insert( "synchronousLoading",   true );
 647
 648   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 649   DALI_TEST_CHECK( imageVisual );
 650
 651   Property::Map resultMap;
 652   imageVisual.CreatePropertyMap( resultMap );
 653
 654   // check the property values from the returned map from visual
 655   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 656   DALI_TEST_CHECK( value );
 657   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 658
 659   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 660   DALI_TEST_CHECK( value );
 661   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 662
 663   value = resultMap.Find( DevelVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 664   DALI_TEST_CHECK( value );
 665   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 666
 667   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 668   DALI_TEST_CHECK( value );
 669   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 670
 671   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 672   DALI_TEST_CHECK( value );
 673   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX_THEN_NEAREST );
 674
 675   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 676   DALI_TEST_CHECK( value );
 677   DALI_TEST_CHECK( value->Get<int>() == 20 );
 678
 679   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 680   DALI_TEST_CHECK( value );
 681   DALI_TEST_CHECK( value->Get<int>() == 30 );
 682
 683   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 684   DALI_TEST_CHECK( value );
 685   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.25f, 0.25f, 0.5f, 0.5f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 686
 687   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 688   DALI_TEST_CHECK( value );
 689   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::REPEAT);
 690
 691   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 692   DALI_TEST_CHECK( value );
 693   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::MIRRORED_REPEAT);
 694
 695   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 696   DALI_TEST_CHECK( value );
 697   DALI_TEST_CHECK( value->Get<bool>() == true );
 698
 699   // Get an image visual with an image handle, and test the default property values
 700   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 701   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 702   imageVisual = factory.CreateVisual(image);
 703   imageVisual.CreatePropertyMap( resultMap );
 704
 705   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 706   DALI_TEST_CHECK( value );
 707   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 708
 709   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 710   DALI_TEST_CHECK( value );
 711   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 712
 713   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 714   DALI_TEST_CHECK( value );
 715   DALI_TEST_CHECK( value->Get<int>() == FittingMode::SHRINK_TO_FIT );
 716
 717   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 718   DALI_TEST_CHECK( value );
 719   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX );
 720
 721   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 722   DALI_TEST_CHECK( value );
 723   DALI_TEST_CHECK( value->Get<int>() == 100 );
 724
 725   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 726   DALI_TEST_CHECK( value );
 727   DALI_TEST_CHECK( value->Get<int>() == 200 );
 728
 729   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 730   DALI_TEST_CHECK( value );
 731   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.f, 0.f, 1.f, 1.f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 732
 733   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 734   DALI_TEST_CHECK( value );
 735   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 736
 737   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 738   DALI_TEST_CHECK( value );
 739   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 740
 741   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 742   DALI_TEST_CHECK( value );
 743   DALI_TEST_CHECK( value->Get<bool>() == false );
 744
 745   END_TEST;
 746 }
 747
 748 int UtcDaliVisualGetPropertyMap6(void)
 749 {
 750   ToolkitTestApplication application;
 751   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 752
 753   Rect< int > border( 1, 1, 1, 1 );
 754
 755   VisualFactory factory = VisualFactory::Get();
 756   Property::Map propertyMap;
 757   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::N_PATCH );
 758   propertyMap.Insert( "mixColor",  Color::MAGENTA );
 759   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 760   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 761   propertyMap.Insert( DevelImageVisual::Property::BORDER, border );
 762   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 763
 764   Property::Map resultMap;
 765   nPatchVisual.CreatePropertyMap( resultMap );
 766
 767   // check the property values from the returned map from visual
 768   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 769   DALI_TEST_CHECK( value );
 770   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::N_PATCH );
 771
 772   value = resultMap.Find( DevelVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 773   DALI_TEST_CHECK( value );
 774   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 775
 776   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 777   DALI_TEST_CHECK( value );
 778   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 779
 780   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 781   DALI_TEST_CHECK( value );
 782   DALI_TEST_CHECK( value->Get<bool>() );
 783
 784   value = resultMap.Find( DevelImageVisual::Property::BORDER,  Property::RECTANGLE );
 785   DALI_TEST_CHECK( value );
 786   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 787
 788   Vector4 border1( 1.0f, 1.0f, 1.0f, 1.0f );
 789
 790   Property::Map propertyMap1;
 791   propertyMap1.Insert( Visual::Property::TYPE, DevelVisual::N_PATCH );
 792   propertyMap1.Insert( "mixColor",  Color::MAGENTA );
 793   propertyMap1.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 794   propertyMap1.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 795   propertyMap1.Insert( DevelImageVisual::Property::BORDER, border1 );
 796   nPatchVisual = factory.CreateVisual( propertyMap1 );
 797
 798   nPatchVisual.CreatePropertyMap( resultMap );
 799
 800   // check the property values from the returned map from visual
 801   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 802   DALI_TEST_CHECK( value );
 803   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::N_PATCH );
 804
 805   value = resultMap.Find( DevelVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 806   DALI_TEST_CHECK( value );
 807   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 808
 809   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 810   DALI_TEST_CHECK( value );
 811   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 812
 813   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 814   DALI_TEST_CHECK( value );
 815   DALI_TEST_CHECK( value->Get<bool>() );
 816
 817   value = resultMap.Find( DevelImageVisual::Property::BORDER,  Property::RECTANGLE );
 818   DALI_TEST_CHECK( value );
 819   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 820
 821   END_TEST;
 822 }
 823
 824 int UtcDaliVisualGetPropertyMap7(void)
 825 {
 826   ToolkitTestApplication application;
 827   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 828
 829   // request SvgVisual with a property map
 830   VisualFactory factory = VisualFactory::Get();
 831   Property::Map propertyMap;
 832   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::SVG );
 833   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::WHITE );
 834   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 835   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 836
 837   Property::Map resultMap;
 838   svgVisual.CreatePropertyMap( resultMap );
 839   // check the property values from the returned map from a visual
 840   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 841   DALI_TEST_CHECK( value );
 842   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::SVG );
 843
 844   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 845   DALI_TEST_CHECK( value );
 846   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 847
 848   // request SvgVisual with an URL
 849   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 850   resultMap.Clear();
 851   svgVisual2.CreatePropertyMap( resultMap );
 852   // check the property values from the returned map from a visual
 853   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
 854   DALI_TEST_CHECK( value );
 855   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::SVG );
 856
 857   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 858   DALI_TEST_CHECK( value );
 859   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 860
 861   END_TEST;
 862 }
 863
 864 //Mesh visual
 865 int UtcDaliVisualGetPropertyMap8(void)
 866 {
 867   ToolkitTestApplication application;
 868   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
 869
 870   //Request MeshVisual using a property map.
 871   VisualFactory factory = VisualFactory::Get();
 872   Property::Map propertyMap;
 873   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
 874   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::BLUE );
 875   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
 876   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
 877   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
 878   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
 879   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 880   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
 881
 882   Property::Map resultMap;
 883   meshVisual.CreatePropertyMap( resultMap );
 884   TestMixColor( meshVisual, DevelVisual::Property::MIX_COLOR, Color::BLUE );
 885
 886   //Check values in the result map are identical to the initial map's values.
 887   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 888   DALI_TEST_CHECK( value );
 889   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
 890
 891   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
 892   DALI_TEST_CHECK( value );
 893   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
 894
 895   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
 896   DALI_TEST_CHECK( value );
 897   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
 898
 899   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
 900   DALI_TEST_CHECK( value );
 901   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
 902
 903   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
 904   DALI_TEST_CHECK( value );
 905   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
 906
 907   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 908   DALI_TEST_CHECK( value );
 909   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 910
 911  END_TEST;
 912 }
 913
 914 //Primitive shape visual
 915 int UtcDaliVisualGetPropertyMap9(void)
 916 {
 917   ToolkitTestApplication application;
 918   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
 919
 920   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
 921   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
 922
 923   //Request PrimitiveVisual using a property map.
 924   VisualFactory factory = VisualFactory::Get();
 925   Property::Map propertyMap;
 926   propertyMap.Insert( Visual::Property::TYPE, Visual::PRIMITIVE );
 927   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
 928   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
 929   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
 930   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
 931   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
 932   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
 933   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
 934   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
 935   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
 936   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
 937   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
 938   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 939   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
 940
 941   Property::Map resultMap;
 942   primitiveVisual.CreatePropertyMap( resultMap );
 943
 944   //Check values in the result map are identical to the initial map's values.
 945   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
 946   DALI_TEST_CHECK( value );
 947   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
 948
 949   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
 950   DALI_TEST_CHECK( value );
 951   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
 952
 953   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
 954   DALI_TEST_CHECK( value );
 955   DALI_TEST_CHECK( value->Get<Vector4>() == color );
 956   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 957
 958   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
 959   DALI_TEST_CHECK( value );
 960   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
 961
 962   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
 963   DALI_TEST_CHECK( value );
 964   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
 965
 966   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
 967   DALI_TEST_CHECK( value );
 968   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 969
 970   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
 971   DALI_TEST_CHECK( value );
 972   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 973
 974   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
 975   DALI_TEST_CHECK( value );
 976   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 977
 978   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
 979   DALI_TEST_CHECK( value );
 980   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 981
 982   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
 983   DALI_TEST_CHECK( value );
 984   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 985
 986   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
 987   DALI_TEST_CHECK( value );
 988   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 989
 990   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
 991   DALI_TEST_CHECK( value );
 992   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 993
 994   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 995   DALI_TEST_CHECK( value );
 996   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 997
 998   END_TEST;
 999 }
1000
1001 //Text shape visual
1002 int UtcDaliVisualGetPropertyMap10(void)
1003 {
1004   ToolkitTestApplication application;
1005   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
1006
1007   //Request PrimitiveVisual using a property map.
1008   VisualFactory factory = VisualFactory::Get();
1009
1010   Property::Map propertyMap;
1011   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1012   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::BLACK );
1013   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1014   propertyMap.Insert( "enableMarkup", false );
1015   propertyMap.Insert( "text", "Hello world" );
1016   propertyMap.Insert( "fontFamily", "TizenSans" );
1017
1018   Property::Map fontStyleMapSet;
1019   fontStyleMapSet.Insert( "weight", "bold" );
1020   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1021
1022   propertyMap.Insert( "pointSize", 12.f );
1023   propertyMap.Insert( "multiLine", true );
1024   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1025   propertyMap.Insert( "verticalAlignment", "CENTER" );
1026   propertyMap.Insert( "textColor", Color::RED );
1027   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1028
1029   Property::Map resultMap;
1030   textVisual.CreatePropertyMap( resultMap );
1031
1032   //Check values in the result map are identical to the initial map's values.
1033   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
1034   DALI_TEST_CHECK( value );
1035   DALI_TEST_EQUALS( value->Get<int>(), (int)DevelVisual::TEXT, TEST_LOCATION );
1036
1037   value = resultMap.Find( DevelVisual::Property::MIX_COLOR, Property::VECTOR4 );
1038   DALI_TEST_CHECK( value );
1039   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1040
1041   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1042   DALI_TEST_CHECK( value );
1043   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1044
1045   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1046   DALI_TEST_CHECK( value );
1047   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1048
1049   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1050   DALI_TEST_CHECK( value );
1051
1052   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1053   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1054   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1055
1056   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1057   DALI_TEST_CHECK( value );
1058   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1059
1060   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1061   DALI_TEST_CHECK( value );
1062   DALI_TEST_CHECK( value->Get<bool>() );
1063
1064   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::STRING );
1065   DALI_TEST_CHECK( value );
1066   DALI_TEST_EQUALS( value->Get<std::string>(), "CENTER", TEST_LOCATION );
1067
1068   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::STRING );
1069   DALI_TEST_CHECK( value );
1070   DALI_TEST_EQUALS( value->Get<std::string>(), "CENTER", TEST_LOCATION );
1071
1072   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1073   DALI_TEST_CHECK( value );
1074   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1075
1076   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1077   DALI_TEST_CHECK( value );
1078   DALI_TEST_CHECK( !value->Get<bool>() );
1079
1080   END_TEST;
1081 }
1082
1083 int UtcDaliVisualGetPropertyMap11(void)
1084 {
1085   ToolkitTestApplication application;
1086   tet_infoline( "UtcDaliVisualGetPropertyMap11: AnimatedImageVisual" );
1087
1088   // request AnimatedImageVisual with a property map
1089   VisualFactory factory = VisualFactory::Get();
1090   Visual::Base animatedImageVisual = factory.CreateVisual( Property::Map()
1091                                                  .Add( Visual::Property::TYPE, DevelVisual::ANIMATED_IMAGE )
1092                                                  .Add( ImageVisual::Property::URL, TEST_GIF_FILE_NAME ) );
1093
1094   Property::Map resultMap;
1095   animatedImageVisual.CreatePropertyMap( resultMap );
1096   // check the property values from the returned map from a visual
1097   Property::Value* value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
1098   DALI_TEST_CHECK( value );
1099   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_IMAGE );
1100
1101   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
1102   DALI_TEST_CHECK( value );
1103   DALI_TEST_CHECK( value->Get<std::string>() == TEST_GIF_FILE_NAME );
1104
1105   // request AnimatedImageVisual with an URL
1106   Visual::Base animatedImageVisual2 = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
1107   resultMap.Clear();
1108   animatedImageVisual2.CreatePropertyMap( resultMap );
1109   // check the property values from the returned map from a visual
1110   value = resultMap.Find( Visual::Property::TYPE,  Property::INTEGER );
1111   DALI_TEST_CHECK( value );
1112   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_IMAGE );
1113
1114   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
1115   DALI_TEST_CHECK( value );
1116   DALI_TEST_CHECK( value->Get<std::string>() == TEST_GIF_FILE_NAME );
1117
1118   END_TEST;
1119 }
1120
1121 int UtcDaliVisualAnimateBorderVisual01(void)
1122 {
1123   ToolkitTestApplication application;
1124   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1125
1126   VisualFactory factory = VisualFactory::Get();
1127   Property::Map propertyMap;
1128   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1129   propertyMap.Insert(DevelVisual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1130   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1131   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1132   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1133
1134   Property::Map map;
1135   map["target"] = "testVisual";
1136   map["property"] = "mixColor";
1137   map["targetValue"] = Vector4(1,1,1,0);
1138   map["animator"] = Property::Map()
1139     .Add("alphaFunction", "LINEAR")
1140     .Add("timePeriod", Property::Map()
1141          .Add("delay", 0.0f)
1142          .Add("duration", 4.0f));
1143
1144   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1145
1146   DummyControl actor = DummyControl::New(true);
1147   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1148   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1149   actor.SetSize(2000, 2000);
1150   actor.SetParentOrigin(ParentOrigin::CENTER);
1151   Stage::GetCurrent().Add(actor);
1152
1153   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1154
1155   Renderer renderer = actor.GetRendererAt(0);
1156   Property::Index borderColorIndex = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::COLOR );
1157   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, DevelVisual::Property::MIX_COLOR );
1158
1159   Animation animation = dummyImpl.CreateTransition( transition );
1160
1161   // Animate the mix color through the transition, and the border color through
1162   // programmatic method.
1163   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1164   animation.Play();
1165
1166   application.SendNotification();
1167   application.Render(0);
1168   application.Render(2000u); // halfway point between blue and white
1169
1170   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1171   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1172   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1173   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1174
1175   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1176   testColor = Vector4( 1,1,1,0.4f );
1177   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1178   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1179   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ) , true, TEST_LOCATION );
1180
1181   application.Render(2000u);
1182
1183   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1184   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1185   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1186
1187   color = renderer.GetCurrentProperty< Vector4 >( mixColorIndex );
1188   testColor = Vector4(1,1,1,0);
1189   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1190   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1191   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ), true, TEST_LOCATION );
1192
1193   END_TEST;
1194 }
1195
1196
1197 int UtcDaliVisualAnimateBorderVisual02(void)
1198 {
1199   ToolkitTestApplication application;
1200   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1201
1202   VisualFactory factory = VisualFactory::Get();
1203   Property::Map propertyMap;
1204   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1205   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1206   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1207   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1208
1209   DummyControl actor = DummyControl::New(true);
1210   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1211   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1212   actor.SetSize(2000, 2000);
1213   actor.SetParentOrigin(ParentOrigin::CENTER);
1214   Stage::GetCurrent().Add(actor);
1215
1216   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1217
1218   Renderer renderer = actor.GetRendererAt(0);
1219   Property::Index index = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::SIZE );
1220
1221   Animation animation = Animation::New(4.0f);
1222   animation.AnimateTo( Property(renderer, index), 9.0f );
1223   animation.Play();
1224
1225   application.SendNotification();
1226   application.Render(0);
1227   application.Render(2000u); // halfway point
1228
1229   float size = renderer.GetCurrentProperty< float >( index );
1230   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1231   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1232
1233   application.Render(2000u); // halfway point between blue and white
1234
1235   size = renderer.GetCurrentProperty< float >( index );
1236   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1237   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1238
1239   END_TEST;
1240 }
1241
1242 int UtcDaliVisualAnimateColorVisual(void)
1243 {
1244   ToolkitTestApplication application;
1245   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1246
1247   VisualFactory factory = VisualFactory::Get();
1248   Property::Map propertyMap;
1249   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1250   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1251   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1252
1253   DummyControl actor = DummyControl::New(true);
1254   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1255   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1256   actor.SetSize(2000, 2000);
1257   actor.SetParentOrigin(ParentOrigin::CENTER);
1258   Stage::GetCurrent().Add(actor);
1259
1260   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1261
1262   Renderer renderer = actor.GetRendererAt(0);
1263   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
1264
1265   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1266   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1267
1268   Animation animation = Animation::New(4.0f);
1269   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1270   animation.Play();
1271
1272   application.SendNotification();
1273   application.Render(0);
1274   application.Render(2000u); // halfway point
1275
1276   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1277   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1278   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1279
1280   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1281
1282   application.Render(2000u); // halfway point between blue and white
1283
1284   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1285   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1286
1287   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1288
1289   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1290   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1291
1292   END_TEST;
1293 }
1294
1295 int UtcDaliVisualAnimatePrimitiveVisual(void)
1296 {
1297   ToolkitTestApplication application;
1298   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1299
1300   {
1301     VisualFactory factory = VisualFactory::Get();
1302     Property::Map propertyMap;
1303     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1304     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1305     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1306     Visual::Base visual = factory.CreateVisual( propertyMap );
1307
1308     DummyControl actor = DummyControl::New(true);
1309     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1310     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1311     actor.SetSize(2000, 2000);
1312     actor.SetParentOrigin(ParentOrigin::CENTER);
1313     actor.SetColor(Color::BLACK);
1314     Stage::GetCurrent().Add(actor);
1315
1316     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1317
1318     Renderer renderer = actor.GetRendererAt(0);
1319     Property::Index index = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
1320
1321     tet_infoline("Test that the renderer has the Primitive mix color");
1322     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1323
1324     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1325     const Vector4 TARGET_MIX_COLOR( Color::RED );
1326
1327     Property::Map map;
1328     map["target"] = "testVisual";
1329     map["property"] = "mixColor";
1330     map["initialValue"] = INITIAL_MIX_COLOR;
1331     map["targetValue"] = TARGET_MIX_COLOR;
1332     map["animator"] = Property::Map()
1333       .Add("alphaFunction", "LINEAR")
1334       .Add("timePeriod", Property::Map()
1335            .Add("delay", 0.0f)
1336            .Add("duration", 4.0f));
1337
1338     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1339
1340     Animation animation = dummyImpl.CreateTransition( transition );
1341     Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1342     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
1343
1344     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1345     animation.Play();
1346
1347     application.SendNotification();
1348     application.Render(0);
1349     application.Render(2000u); // halfway point
1350     application.SendNotification();
1351
1352     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
1353
1354     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1355     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1356     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", halfwayColor.a ), true, TEST_LOCATION );
1357
1358     application.Render(2001u); // go past end
1359     application.SendNotification(); // Trigger signals
1360
1361     DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1362     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
1363     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1364     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a ), true, TEST_LOCATION );
1365
1366     blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1367     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1368
1369     actor.Unparent();
1370   }
1371
1372   END_TEST;
1373 }
1374
1375
1376 int UtcDaliVisualWireframeVisual(void)
1377 {
1378   ToolkitTestApplication application;
1379
1380   VisualFactory factory = VisualFactory::Get();
1381   Property::Map propertyMap;
1382   propertyMap.Insert( Visual::Property::TYPE, Visual::WIREFRAME );
1383
1384   // Create the visual.
1385   Visual::Base visual = factory.CreateVisual( propertyMap );
1386
1387   DALI_TEST_CHECK( visual );
1388
1389   Property::Map resultMap;
1390   visual.CreatePropertyMap( resultMap );
1391
1392   // Check the property values from the returned map from visual
1393   Property::Value* value = resultMap.Find( Visual::Property::TYPE, Property::INTEGER );
1394   DALI_TEST_CHECK( value );
1395   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
1396
1397   END_TEST;
1398 }
1399
1400 int UtcDaliVisualGetTransform(void)
1401 {
1402   ToolkitTestApplication application;
1403   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
1404
1405   VisualFactory factory = VisualFactory::Get();
1406   Property::Map propertyMap;
1407   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1408   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1409   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
1410
1411   Dali::Property::Map visualMap;
1412   colorVisual.CreatePropertyMap( visualMap );
1413   Property::Value* value = visualMap.Find( Dali::Toolkit::DevelVisual::Property::TRANSFORM );
1414   Dali::Property::Map* map = value->GetMap();
1415   DALI_TEST_CHECK( map );
1416
1417   //Test default values
1418   {
1419     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET );
1420     DALI_TEST_CHECK( typeValue );
1421     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
1422   }
1423   {
1424     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE );
1425     DALI_TEST_CHECK( typeValue );
1426     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
1427   }
1428   {
1429     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY );
1430     DALI_TEST_CHECK( typeValue );
1431     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ) );
1432   }
1433   {
1434     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY );
1435     DALI_TEST_CHECK( typeValue );
1436     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ) );
1437   }
1438   {
1439     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ORIGIN );
1440     DALI_TEST_CHECK( typeValue );
1441     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
1442   }
1443   {
1444     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT );
1445     DALI_TEST_CHECK( typeValue );
1446     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
1447   }
1448
1449   END_TEST;
1450 }
1451
1452 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
1453 {
1454   Property::Map transform;
1455   transform.Insert( DevelVisual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
1456   transform.Insert( DevelVisual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
1457   transform.Insert( DevelVisual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::DevelVisual::Transform::Policy::ABSOLUTE, Toolkit::DevelVisual::Transform::Policy::ABSOLUTE ) );
1458   transform.Insert( DevelVisual::Transform::Property::ORIGIN, "CENTER" );
1459   transform.Insert( DevelVisual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
1460
1461   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1462
1463   Dali::Property::Map visualMap;
1464   visual.CreatePropertyMap( visualMap );
1465   Property::Value* value = visualMap.Find( Dali::Toolkit::DevelVisual::Property::TRANSFORM );
1466   Dali::Property::Map* map = value->GetMap();
1467   DALI_TEST_CHECK( map );
1468
1469   {
1470     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET );
1471     DALI_TEST_CHECK( typeValue );
1472     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
1473   }
1474   {
1475     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE );
1476     DALI_TEST_CHECK( typeValue );
1477     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
1478   }
1479   {
1480     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY );
1481     DALI_TEST_CHECK( typeValue );
1482     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::DevelVisual::Transform::Policy::ABSOLUTE, Toolkit::DevelVisual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
1483   }
1484   {
1485     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY );
1486     DALI_TEST_CHECK( typeValue );
1487     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ), TEST_LOCATION );
1488   }
1489   {
1490     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ORIGIN );
1491     DALI_TEST_CHECK( typeValue );
1492     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
1493   }
1494   {
1495     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::ANCHOR_POINT );
1496     DALI_TEST_CHECK( typeValue );
1497     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
1498   }
1499
1500   //Put the visual on the stage
1501   DummyControl actor = DummyControl::New(true);
1502   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1503   actor.SetSize(2000, 2000);
1504   actor.SetParentOrigin(ParentOrigin::CENTER);
1505   Stage::GetCurrent().Add(actor);
1506
1507   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1508   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
1509
1510   application.SendNotification();
1511   application.Render(0);
1512   Renderer renderer( actor.GetRendererAt(0) );
1513
1514   //Check that the properties have been registered on the Renderer
1515   Property::Index index = renderer.GetPropertyIndex( "offset" );
1516   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1517   Vector2 offset = renderer.GetProperty<Vector2>( index );
1518   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
1519
1520   index = renderer.GetPropertyIndex( "size" );
1521   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1522   Vector2 size = renderer.GetProperty<Vector2>( index );
1523   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
1524
1525   index = renderer.GetPropertyIndex( "offsetSizeMode" );
1526   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1527   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
1528   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
1529
1530   index = renderer.GetPropertyIndex( "origin" );
1531   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1532   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
1533   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
1534
1535   index = renderer.GetPropertyIndex( "anchorPoint" );
1536   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1537   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
1538   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1539
1540   //Set a new transform
1541   transform.Clear();
1542   transform = DefaultTransform();
1543   transform.Insert( DevelVisual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
1544   transform.Insert( DevelVisual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
1545   transform.Insert( DevelVisual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::DevelVisual::Transform::Policy::ABSOLUTE, Toolkit::DevelVisual::Transform::Policy::ABSOLUTE ) );
1546   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1547   application.SendNotification();
1548   application.Render(0);
1549
1550   //Check that the values have changed in the renderer
1551   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1552   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
1553
1554   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1555   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
1556
1557   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1558   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
1559
1560   //Parent origin and anchor point should have the default values
1561   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1562   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
1563
1564   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1565   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
1566 }
1567
1568 int UtcDaliVisualSetTransform0(void)
1569 {
1570   ToolkitTestApplication application;
1571   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
1572
1573   VisualFactory factory = VisualFactory::Get();
1574   Property::Map propertyMap;
1575   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1576   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1577   Visual::Base visual = factory.CreateVisual( propertyMap );
1578   TestTransform( application, visual );
1579   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
1580
1581   END_TEST;
1582 }
1583
1584 int UtcDaliVisualSetTransform1(void)
1585 {
1586   ToolkitTestApplication application;
1587   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
1588
1589   VisualFactory factory = VisualFactory::Get();
1590   Property::Map propertyMap;
1591   propertyMap[ Visual::Property::TYPE           ] = Visual::PRIMITIVE;
1592   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
1593   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
1594   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
1595   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
1596   Visual::Base visual = factory.CreateVisual( propertyMap );
1597   TestTransform( application, visual );
1598   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
1599
1600   END_TEST;
1601 }
1602
1603 int UtcDaliVisualSetTransform2(void)
1604 {
1605   ToolkitTestApplication application;
1606   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
1607
1608   VisualFactory factory = VisualFactory::Get();
1609   Property::Map propertyMap;
1610   propertyMap.Insert( Visual::Property::TYPE,  Visual::GRADIENT );
1611   propertyMap.Insert( DevelVisual::Property::MIX_COLOR,  Color::GREEN );
1612
1613   Property::Array stopOffsets;
1614   stopOffsets.PushBack( 0.0f );
1615   stopOffsets.PushBack( 0.3f );
1616   stopOffsets.PushBack( 0.6f );
1617   stopOffsets.PushBack( 0.8f );
1618   stopOffsets.PushBack( 1.0f );
1619   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
1620
1621   Property::Array stopColors;
1622   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
1623   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
1624   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
1625   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
1626   stopColors.PushBack( Color::YELLOW );
1627   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
1628   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
1629   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
1630   Visual::Base visual = factory.CreateVisual( propertyMap );
1631   TestTransform( application, visual );
1632   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::GREEN );
1633
1634   END_TEST;
1635 }
1636
1637 int UtcDaliVisualSetTransform3(void)
1638 {
1639   ToolkitTestApplication application;
1640   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
1641
1642   VisualFactory factory = VisualFactory::Get();
1643   Property::Map propertyMap;
1644   propertyMap.Insert( Visual::Property::TYPE, Visual::BORDER );
1645   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1646   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
1647   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
1648   Visual::Base visual = factory.CreateVisual( propertyMap );
1649   TestTransform( application, visual );
1650   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1651
1652   END_TEST;
1653 }
1654
1655 int UtcDaliVisualSetTransform4(void)
1656 {
1657   ToolkitTestApplication application;
1658   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
1659
1660   VisualFactory factory = VisualFactory::Get();
1661   Property::Map propertyMap;
1662   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
1663   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::CYAN );
1664
1665   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1666   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1667   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
1668   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1669   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
1670   Visual::Base visual = factory.CreateVisual( propertyMap );
1671   TestTransform( application, visual );
1672   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::CYAN );
1673
1674   END_TEST;
1675 }
1676
1677 int UtcDaliVisualSetTransform5(void)
1678 {
1679   ToolkitTestApplication application;
1680   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
1681
1682   VisualFactory factory = VisualFactory::Get();
1683   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
1684   Visual::Base visual = factory.CreateVisual(image);
1685   TestTransform( application, visual );
1686   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1687
1688   END_TEST;
1689 }
1690
1691 int UtcDaliVisualSetTransform6(void)
1692 {
1693   ToolkitTestApplication application;
1694   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
1695
1696   VisualFactory factory = VisualFactory::Get();
1697   Property::Map propertyMap;
1698   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
1699   propertyMap[DevelVisual::Property::MIX_COLOR] = Color::YELLOW;
1700   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1701   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
1702   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
1703   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
1704   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
1705   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
1706   Visual::Base visual = factory.CreateVisual(propertyMap);
1707   TestTransform( application, visual );
1708   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::YELLOW );
1709
1710   END_TEST;
1711 }
1712
1713 int UtcDaliVisualSetTransform7(void)
1714 {
1715   ToolkitTestApplication application;
1716   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
1717
1718   VisualFactory factory = VisualFactory::Get();
1719   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
1720   Visual::Base visual = factory.CreateVisual(image);
1721   TestTransform( application, visual );
1722   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1723
1724   END_TEST;
1725 }
1726
1727 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
1728 {
1729   ToolkitTestApplication application;
1730   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
1731
1732   VisualFactory factory = VisualFactory::Get();
1733   Property::Map propertyMap;
1734   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1735   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1736   Visual::Base visual = factory.CreateVisual( propertyMap );
1737
1738   Property::Map transform;
1739   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
1740                                                  .Add( "RELATIVE" );
1741   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
1742                                                  .Add( "ABSOLUTE" );
1743   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1744
1745   Dali::Property::Map visualMap;
1746   visual.CreatePropertyMap( visualMap );
1747   Property::Value* value = visualMap.Find( Dali::Toolkit::DevelVisual::Property::TRANSFORM );
1748   Dali::Property::Map* map = value->GetMap();
1749   DALI_TEST_CHECK( map );
1750
1751   {
1752     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::OFFSET_POLICY );
1753     DALI_TEST_CHECK( typeValue );
1754     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::DevelVisual::Transform::Policy::ABSOLUTE, Toolkit::DevelVisual::Transform::Policy::RELATIVE ), TEST_LOCATION );
1755   }
1756   {
1757     Property::Value* typeValue = map->Find( Toolkit::DevelVisual::Transform::Property::SIZE_POLICY );
1758     DALI_TEST_CHECK( typeValue );
1759     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::DevelVisual::Transform::Policy::RELATIVE, Toolkit::DevelVisual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
1760   }
1761
1762   END_TEST;
1763 }
1764
1765 int UtcDaliNPatchVisualCustomShader(void)
1766 {
1767   ToolkitTestApplication application;
1768   tet_infoline( "NPatchVisual with custom shader" );
1769
1770   VisualFactory factory = VisualFactory::Get();
1771   Property::Map properties;
1772   Property::Map shader;
1773   const std::string fragmentShader = "Foobar";
1774   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
1775
1776   Property::Map transformMap;
1777   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
1778   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
1779   transformMap["offsetPolicy"] = Vector2( DevelVisual::Transform::Policy::ABSOLUTE, DevelVisual::Transform::Policy::ABSOLUTE );
1780   transformMap["anchorPoint"] = Align::CENTER;
1781   transformMap["origin"] = Align::CENTER;
1782   properties[DevelVisual::Property::TRANSFORM] = transformMap;
1783
1784   properties[Visual::Property::TYPE] = Visual::IMAGE;
1785   properties[DevelVisual::Property::MIX_COLOR] = Color::BLUE;
1786   properties[Visual::Property::SHADER]=shader;
1787   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
1788
1789   Visual::Base visual = factory.CreateVisual( properties );
1790   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::BLUE );
1791
1792   // trigger creation through setting on stage
1793   DummyControl dummy = DummyControl::New(true);
1794   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
1795   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1796   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
1797   dummy.SetSize(2000, 2000);
1798   dummy.SetParentOrigin(ParentOrigin::CENTER);
1799   Stage::GetCurrent().Add(dummy);
1800   application.SendNotification();
1801
1802   Renderer renderer = dummy.GetRendererAt( 0 );
1803   Shader shader2 = renderer.GetShader();
1804   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
1805   Property::Map* map = value.GetMap();
1806   DALI_TEST_CHECK( map );
1807
1808   Property::Index index = renderer.GetPropertyIndex("size");
1809   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
1810
1811   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
1812   // *map["vertex"]; is default here so not verifying it
1813
1814   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
1815
1816   END_TEST;
1817 }
1818
1819 int UtcDaliGradientVisualBlendMode(void)
1820 {
1821   ToolkitTestApplication application;
1822   VisualFactory factory = VisualFactory::Get();
1823
1824   Visual::Base opaqueGradientVisual = factory.CreateVisual(
1825       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1826                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1827                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1828                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1829                                                                                   .Add( Color::GREEN ) ) );
1830
1831   Visual::Base alphaGradientVisual = factory.CreateVisual(
1832       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1833                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1834                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1835                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1836                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
1837
1838   DummyControl control = DummyControl::New(true);
1839   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1840   Stage::GetCurrent().Add( control );
1841
1842   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
1843   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
1844   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
1845
1846   application.SendNotification();
1847   application.Render();
1848
1849   // 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
1850   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
1851   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
1852   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1853
1854   END_TEST;
1855 }
1856
1857 int UtcDaliVisualRendererRemovalAndReAddition(void)
1858 {
1859   ToolkitTestApplication application;
1860   tet_infoline( "UtcDaliVisualRendererRemoval" );
1861
1862   VisualFactory factory = VisualFactory::Get();
1863   Property::Map propertyMap;
1864   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1865   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1866   Visual::Base visual = factory.CreateVisual( propertyMap );
1867
1868   visual.SetDepthIndex( 1 );
1869
1870   DummyControl dummyControl = DummyControl::New(true);
1871   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1872   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1873   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1874
1875   dummyControl.SetSize(200.f, 200.f);
1876   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
1877
1878   Stage::GetCurrent().Add( dummyControl );
1879
1880   application.SendNotification();
1881   application.Render();
1882
1883   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1884
1885   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
1886   Stage::GetCurrent().Remove( dummyControl );
1887   application.SendNotification();
1888   application.Render();
1889
1890   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1891
1892   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
1893
1894   Stage::GetCurrent().Add( dummyControl );
1895
1896   application.SendNotification();
1897   application.Render();
1898
1899   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
1900
1901   END_TEST;
1902 }
1903
1904
1905
1906 int UtcDaliVisualTextVisualRender(void)
1907 {
1908   ToolkitTestApplication application;
1909   tet_infoline( "UtcDaliVisualTextVisualRender" );
1910
1911   VisualFactory factory = VisualFactory::Get();
1912   Property::Map propertyMap;
1913   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1914   propertyMap.Insert( "mixColor", Color::WHITE );
1915   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1916   propertyMap.Insert( "enableMarkup", false );
1917   propertyMap.Insert( "text", "Hello world" );
1918   propertyMap.Insert( "fontFamily", "TizenSans" );
1919
1920   Property::Map fontStyleMapSet;
1921   fontStyleMapSet.Insert( "weight", "bold" );
1922   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1923
1924   propertyMap.Insert( "pointSize", 12.f );
1925   propertyMap.Insert( "multiLine", true );
1926   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1927   propertyMap.Insert( "verticalAlignment", "CENTER" );
1928   propertyMap.Insert( "textColor", Color::RED );
1929   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1930   textVisual.SetDepthIndex( 1 );
1931
1932   DummyControl dummyControl = DummyControl::New(true);
1933   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1934   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1935   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1936
1937   dummyControl.SetSize(200.f, 200.f);
1938   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
1939
1940   Stage::GetCurrent().Add( dummyControl );
1941   application.SendNotification();
1942   application.Render();
1943
1944
1945   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
1946   propertyMap.Clear();
1947   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1948   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
1949   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
1950   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
1951
1952   Property::Map transformMap;
1953   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
1954   propertyMap.Insert( DevelVisual::Property::TRANSFORM, transformMap );
1955
1956   textVisual = factory.CreateVisual( propertyMap );
1957   textVisual.SetDepthIndex( 1 );
1958
1959   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
1960   dummyControl.SetSize( 720.f, 640.f );
1961
1962   application.SendNotification(); // force process events to ensure text visual
1963   // adds renderer to the dummy control in OnRelayout
1964   application.Render();
1965
1966   Renderer renderer = dummyControl.GetRendererAt(0u);
1967   Property::Index index = renderer.GetPropertyIndex("size");
1968
1969   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
1970   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
1971
1972   END_TEST;
1973 }
1974
1975 int UtcDaliVisualTextVisualDisableEnable(void)
1976 {
1977   ToolkitTestApplication application;
1978   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
1979
1980   VisualFactory factory = VisualFactory::Get();
1981   Property::Map propertyMap;
1982   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
1983   propertyMap.Insert( "mixColor", Color::WHITE );
1984   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1985   propertyMap.Insert( "enableMarkup", false );
1986   propertyMap.Insert( "text", "Hello world" );
1987   propertyMap.Insert( "fontFamily", "TizenSans" );
1988
1989   Property::Map fontStyleMapSet;
1990   fontStyleMapSet.Insert( "weight", "bold" );
1991   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1992
1993   propertyMap.Insert( "pointSize", 12.f );
1994   propertyMap.Insert( "multiLine", true );
1995   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1996   propertyMap.Insert( "verticalAlignment", "CENTER" );
1997   propertyMap.Insert( "textColor", Color::RED );
1998   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1999   textVisual.SetDepthIndex( 1 );
2000
2001   DummyControl dummyControl = DummyControl::New(true);
2002   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2003   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
2004   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2005
2006   dummyControl.SetSize(200.f, 200.f);
2007   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
2008
2009   Stage::GetCurrent().Add( dummyControl );
2010   application.SendNotification();
2011   application.Render();
2012
2013   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2014
2015   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
2016
2017   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2018
2019   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
2020
2021   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2022
2023   END_TEST;
2024 }
2025
2026 int UtcDaliVisualPremultipliedAlpha(void)
2027 {
2028   ToolkitTestApplication application;
2029   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
2030
2031   VisualFactory factory = VisualFactory::Get();
2032
2033   // image visual, test default value ( false )
2034   {
2035     Visual::Base imageVisual = factory.CreateVisual(
2036           Property::Map()
2037           .Add( Visual::Property::TYPE, Visual::IMAGE )
2038           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
2039
2040     Dali::Property::Map visualMap;
2041     imageVisual.CreatePropertyMap( visualMap );
2042     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2043
2044     // test values
2045     DALI_TEST_CHECK( value );
2046     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
2047   }
2048
2049   // image visual, override premultiplied
2050   {
2051     Visual::Base imageVisual = factory.CreateVisual(
2052           Property::Map()
2053           .Add( Visual::Property::TYPE, Visual::IMAGE )
2054           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
2055           .Add( DevelVisual::Property::PREMULTIPLIED_ALPHA, true ) );
2056
2057     Dali::Property::Map visualMap;
2058     imageVisual.CreatePropertyMap( visualMap );
2059     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2060
2061     // test values
2062     DALI_TEST_CHECK( value );
2063     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
2064   }
2065
2066   // svg visual ( premultiplied alpha by default is true )
2067   {
2068     Visual::Base imageVisual = factory.CreateVisual(
2069           Property::Map()
2070           .Add( Visual::Property::TYPE, Visual::IMAGE )
2071           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
2072
2073     Dali::Property::Map visualMap;
2074     imageVisual.CreatePropertyMap( visualMap );
2075     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2076
2077     // test values
2078     DALI_TEST_CHECK( value );
2079     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
2080   }
2081
2082   END_TEST;
2083 }
2084
2085 int UtcDaliRegisterVisualOrder(void)
2086 {
2087   ToolkitTestApplication application;
2088   tet_infoline( "Register Visual Order" );
2089
2090   DummyControl dummyControl = DummyControl::New(true);
2091   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2092
2093   VisualFactory factory = VisualFactory::Get();
2094   Property::Map propertyMap;
2095   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2096   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2097
2098   tet_infoline( "Register visual, should have depth index of 0.0f" );
2099   Visual::Base testVisual = factory.CreateVisual( propertyMap );
2100   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
2101   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
2102
2103   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
2104
2105   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
2106   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
2107   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
2108
2109   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
2110   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
2111   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
2112
2113   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
2114   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
2115   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
2116
2117   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
2118   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
2119   labelVisual.SetDepthIndex( -2000 );
2120   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
2121   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
2122
2123   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
2124   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
2125   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
2126   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
2127   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
2128   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
2129
2130   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
2131   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
2132   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
2133   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
2134   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
2135
2136   dummyControl.SetSize(200.f, 200.f);
2137   Stage::GetCurrent().Add( dummyControl );
2138
2139   END_TEST;
2140 }
2141
2142 int UtcDaliRegisterVisualWithDepthIndex(void)
2143 {
2144   ToolkitTestApplication application;
2145   tet_infoline( "Register a Visual With Depth Index" );
2146
2147   DummyControl dummyControl = DummyControl::New(true);
2148   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2149
2150   VisualFactory factory = VisualFactory::Get();
2151   Property::Map propertyMap;
2152   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2153   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2154
2155   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
2156   Visual::Base testVisual = factory.CreateVisual( propertyMap );
2157   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
2158   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
2159   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
2160
2161   tet_infoline( "Register another visual with a depth index and it disabled" );
2162   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
2163   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
2164   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
2165   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
2166
2167   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
2168   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
2169   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
2170   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
2171   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
2172
2173   dummyControl.SetSize(200.f, 200.f);
2174   Stage::GetCurrent().Add( dummyControl );
2175
2176   END_TEST;
2177 }