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

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