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