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

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