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

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <iostream>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22 #include <dali/public-api/rendering/renderer.h>
  23 #include <dali/public-api/rendering/texture-set.h>
  24 #include <dali/public-api/rendering/shader.h>
  25 #include <dali/devel-api/object/handle-devel.h>
  26 #include <dali-toolkit/devel-api/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 = DefaultTransform();
1699   transform.Insert( DevelVisual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
1700   transform.Insert( DevelVisual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
1701   transform.Insert( DevelVisual::Transform::Property::OFFSET_SIZE_MODE, Vector4(0.0f, 0.0f, 1.0f,1.0f) );
1702   visual.SetTransformAndSize( transform, Vector2(100, 100) );
1703   application.SendNotification();
1704   application.Render(0);
1705
1706   //Check that the values have changed in the renderer
1707   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
1708   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
1709
1710   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
1711   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
1712
1713   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
1714   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
1715
1716   //Parent origin and anchor point should have default values
1717   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
1718   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
1719
1720   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
1721   DALI_TEST_EQUALS( anchorPoint, Vector2(0.0f,0.0f), TEST_LOCATION );
1722 }
1723
1724 int UtcDaliVisualSetTransform0(void)
1725 {
1726   ToolkitTestApplication application;
1727   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
1728
1729   VisualFactory factory = VisualFactory::Get();
1730   Property::Map propertyMap;
1731   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1732   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1733   Visual::Base visual = factory.CreateVisual( propertyMap );
1734   TestTransform( application, visual );
1735   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
1736
1737   END_TEST;
1738 }
1739
1740 int UtcDaliVisualSetTransform1(void)
1741 {
1742   ToolkitTestApplication application;
1743   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
1744
1745   VisualFactory factory = VisualFactory::Get();
1746   Property::Map propertyMap;
1747   propertyMap[ Visual::Property::TYPE           ] = Visual::PRIMITIVE;
1748   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
1749   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
1750   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
1751   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
1752   Visual::Base visual = factory.CreateVisual( propertyMap );
1753   TestTransform( application, visual );
1754   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
1755
1756   END_TEST;
1757 }
1758
1759 int UtcDaliVisualSetTransform2(void)
1760 {
1761   ToolkitTestApplication application;
1762   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
1763
1764   VisualFactory factory = VisualFactory::Get();
1765   Property::Map propertyMap;
1766   propertyMap.Insert( Visual::Property::TYPE,  Visual::GRADIENT );
1767   propertyMap.Insert( DevelVisual::Property::MIX_COLOR,  Color::GREEN );
1768
1769   Property::Array stopOffsets;
1770   stopOffsets.PushBack( 0.0f );
1771   stopOffsets.PushBack( 0.3f );
1772   stopOffsets.PushBack( 0.6f );
1773   stopOffsets.PushBack( 0.8f );
1774   stopOffsets.PushBack( 1.0f );
1775   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
1776
1777   Property::Array stopColors;
1778   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
1779   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
1780   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
1781   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
1782   stopColors.PushBack( Color::YELLOW );
1783   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
1784   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
1785   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
1786   Visual::Base visual = factory.CreateVisual( propertyMap );
1787   TestTransform( application, visual );
1788   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::GREEN );
1789
1790   END_TEST;
1791 }
1792
1793 int UtcDaliVisualSetTransform3(void)
1794 {
1795   ToolkitTestApplication application;
1796   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
1797
1798   VisualFactory factory = VisualFactory::Get();
1799   Property::Map propertyMap;
1800   propertyMap.Insert( Visual::Property::TYPE, Visual::BORDER );
1801   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1802   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
1803   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
1804   Visual::Base visual = factory.CreateVisual( propertyMap );
1805   TestTransform( application, visual );
1806   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::MAGENTA );
1807
1808   END_TEST;
1809 }
1810
1811 int UtcDaliVisualSetTransform4(void)
1812 {
1813   ToolkitTestApplication application;
1814   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
1815
1816   VisualFactory factory = VisualFactory::Get();
1817   Property::Map propertyMap;
1818   propertyMap.Insert( Visual::Property::TYPE, Visual::MESH );
1819   propertyMap.Insert( DevelVisual::Property::MIX_COLOR, Color::CYAN );
1820
1821   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1822   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1823   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
1824   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1825   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
1826   Visual::Base visual = factory.CreateVisual( propertyMap );
1827   TestTransform( application, visual );
1828   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::CYAN );
1829
1830   END_TEST;
1831 }
1832
1833 int UtcDaliVisualSetTransform5(void)
1834 {
1835   ToolkitTestApplication application;
1836   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
1837
1838   VisualFactory factory = VisualFactory::Get();
1839   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
1840   Visual::Base visual = factory.CreateVisual(image);
1841   TestTransform( application, visual );
1842   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1843
1844   END_TEST;
1845 }
1846
1847 int UtcDaliVisualSetTransform6(void)
1848 {
1849   ToolkitTestApplication application;
1850   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
1851
1852   VisualFactory factory = VisualFactory::Get();
1853   Property::Map propertyMap;
1854   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
1855   propertyMap[DevelVisual::Property::MIX_COLOR] = Color::YELLOW;
1856   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1857   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
1858   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
1859   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
1860   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
1861   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
1862   Visual::Base visual = factory.CreateVisual(propertyMap);
1863   TestTransform( application, visual );
1864   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::YELLOW );
1865
1866   END_TEST;
1867 }
1868
1869 int UtcDaliVisualSetTransform7(void)
1870 {
1871   ToolkitTestApplication application;
1872   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
1873
1874   VisualFactory factory = VisualFactory::Get();
1875   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
1876   Visual::Base visual = factory.CreateVisual(image);
1877   TestTransform( application, visual );
1878   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::WHITE );
1879
1880   END_TEST;
1881 }
1882
1883 int UtcDaliNPatchVisualCustomShader(void)
1884 {
1885   ToolkitTestApplication application;
1886   tet_infoline( "NPatchVisual with custom shader" );
1887
1888   VisualFactory factory = VisualFactory::Get();
1889   Property::Map properties;
1890   Property::Map shader;
1891   const std::string fragmentShader = "Foobar";
1892   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
1893
1894   Property::Map transformMap;
1895   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
1896   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
1897   transformMap["offsetSizeMode"] = Vector4( 1.0f, 1.0f, 0.0f, 0.0f );
1898   transformMap["anchorPoint"] = Align::CENTER;
1899   transformMap["origin"] = Align::CENTER;
1900   properties[DevelVisual::Property::TRANSFORM] = transformMap;
1901
1902   properties[Visual::Property::TYPE] = Visual::IMAGE;
1903   properties[DevelVisual::Property::MIX_COLOR] = Color::BLUE;
1904   properties[Visual::Property::SHADER]=shader;
1905   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
1906
1907   Visual::Base visual = factory.CreateVisual( properties );
1908   TestMixColor( visual, DevelVisual::Property::MIX_COLOR, Color::BLUE );
1909
1910   // trigger creation through setting on stage
1911   DummyControl dummy = DummyControl::New(true);
1912   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
1913   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1914   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
1915   dummy.SetSize(2000, 2000);
1916   dummy.SetParentOrigin(ParentOrigin::CENTER);
1917   Stage::GetCurrent().Add(dummy);
1918   application.SendNotification();
1919
1920   Renderer renderer = dummy.GetRendererAt( 0 );
1921   Shader shader2 = renderer.GetShader();
1922   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
1923   Property::Map* map = value.GetMap();
1924   DALI_TEST_CHECK( map );
1925
1926   Property::Index index = renderer.GetPropertyIndex("size");
1927   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
1928
1929   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
1930   // *map["vertex"]; is default here so not verifying it
1931
1932   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
1933
1934   END_TEST;
1935 }
1936
1937 int UtcDaliGradientVisualBlendMode(void)
1938 {
1939   ToolkitTestApplication application;
1940   VisualFactory factory = VisualFactory::Get();
1941
1942   Visual::Base opaqueGradientVisual = factory.CreateVisual(
1943       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1944                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1945                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1946                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1947                                                                                   .Add( Color::GREEN ) ) );
1948
1949   Visual::Base alphaGradientVisual = factory.CreateVisual(
1950       Property::Map().Add( Visual::Property::TYPE, Visual::GRADIENT )
1951                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
1952                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
1953                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
1954                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
1955
1956   DummyControl control = DummyControl::New(true);
1957   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
1958   Stage::GetCurrent().Add( control );
1959
1960   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
1961   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
1962   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
1963
1964   application.SendNotification();
1965   application.Render();
1966
1967   // 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
1968   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
1969   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
1970   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1971
1972   END_TEST;
1973 }
1974
1975 int UtcDaliVisualRendererRemovalAndReAddition(void)
1976 {
1977   ToolkitTestApplication application;
1978   tet_infoline( "UtcDaliVisualRendererRemoval" );
1979
1980   VisualFactory factory = VisualFactory::Get();
1981   Property::Map propertyMap;
1982   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1983   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
1984   Visual::Base visual = factory.CreateVisual( propertyMap );
1985
1986   visual.SetDepthIndex( 1.f );
1987
1988   DummyControl dummyControl = DummyControl::New(true);
1989   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1990   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1991   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
1992
1993   dummyControl.SetSize(200.f, 200.f);
1994   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
1995
1996   Stage::GetCurrent().Add( dummyControl );
1997
1998   application.SendNotification();
1999   application.Render();
2000
2001   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2002
2003   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
2004   Stage::GetCurrent().Remove( dummyControl );
2005   application.SendNotification();
2006   application.Render();
2007
2008   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2009
2010   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
2011
2012   Stage::GetCurrent().Add( dummyControl );
2013
2014   application.SendNotification();
2015   application.Render();
2016
2017   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2018
2019   END_TEST;
2020 }
2021
2022
2023
2024 int UtcDaliVisualTextVisualRender(void)
2025 {
2026   ToolkitTestApplication application;
2027   tet_infoline( "UtcDaliVisualTextVisualRender" );
2028
2029   VisualFactory factory = VisualFactory::Get();
2030   Property::Map propertyMap;
2031   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
2032   propertyMap.Insert( "mixColor", Color::WHITE );
2033   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
2034   propertyMap.Insert( "enableMarkup", false );
2035   propertyMap.Insert( "text", "Hello world" );
2036   propertyMap.Insert( "fontFamily", "TizenSans" );
2037
2038   Property::Map fontStyleMapSet;
2039   fontStyleMapSet.Insert( "weight", "bold" );
2040   propertyMap.Insert( "fontStyle", fontStyleMapSet );
2041
2042   propertyMap.Insert( "pointSize", 12.f );
2043   propertyMap.Insert( "multiLine", true );
2044   propertyMap.Insert( "horizontalAlignment", "CENTER" );
2045   propertyMap.Insert( "verticalAlignment", "CENTER" );
2046   propertyMap.Insert( "textColor", Color::RED );
2047   Visual::Base textVisual = factory.CreateVisual( propertyMap );
2048   textVisual.SetDepthIndex( 1.f );
2049
2050   DummyControl dummyControl = DummyControl::New(true);
2051   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2052   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
2053   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2054
2055   dummyControl.SetSize(200.f, 200.f);
2056   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
2057
2058   Stage::GetCurrent().Add( dummyControl );
2059   application.SendNotification();
2060   application.Render();
2061
2062
2063   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
2064   propertyMap.Clear();
2065   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
2066   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
2067   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
2068   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
2069
2070   Property::Map transformMap;
2071   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
2072   propertyMap.Insert( DevelVisual::Property::TRANSFORM, transformMap );
2073
2074   textVisual = factory.CreateVisual( propertyMap );
2075   textVisual.SetDepthIndex( 1.f );
2076
2077   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
2078   dummyControl.SetSize( 720.f, 640.f );
2079
2080   application.SendNotification(); // force process events to ensure text visual
2081   // adds renderer to the dummy control in OnRelayout
2082   application.Render();
2083
2084   Renderer renderer = dummyControl.GetRendererAt(0u);
2085   Property::Index index = renderer.GetPropertyIndex("size");
2086
2087   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
2088   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
2089
2090   END_TEST;
2091 }
2092
2093 int UtcDaliVisualTextVisualDisableEnable(void)
2094 {
2095   ToolkitTestApplication application;
2096   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
2097
2098   VisualFactory factory = VisualFactory::Get();
2099   Property::Map propertyMap;
2100   propertyMap.Insert( Visual::Property::TYPE, DevelVisual::TEXT );
2101   propertyMap.Insert( "mixColor", Color::WHITE );
2102   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
2103   propertyMap.Insert( "enableMarkup", false );
2104   propertyMap.Insert( "text", "Hello world" );
2105   propertyMap.Insert( "fontFamily", "TizenSans" );
2106
2107   Property::Map fontStyleMapSet;
2108   fontStyleMapSet.Insert( "weight", "bold" );
2109   propertyMap.Insert( "fontStyle", fontStyleMapSet );
2110
2111   propertyMap.Insert( "pointSize", 12.f );
2112   propertyMap.Insert( "multiLine", true );
2113   propertyMap.Insert( "horizontalAlignment", "CENTER" );
2114   propertyMap.Insert( "verticalAlignment", "CENTER" );
2115   propertyMap.Insert( "textColor", Color::RED );
2116   Visual::Base textVisual = factory.CreateVisual( propertyMap );
2117   textVisual.SetDepthIndex( 1.f );
2118
2119   DummyControl dummyControl = DummyControl::New(true);
2120   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2121   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
2122   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2123
2124   dummyControl.SetSize(200.f, 200.f);
2125   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
2126
2127   Stage::GetCurrent().Add( dummyControl );
2128   application.SendNotification();
2129   application.Render();
2130
2131   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2132
2133   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
2134
2135   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2136
2137   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
2138
2139   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2140
2141   END_TEST;
2142 }
2143
2144 int UtcDaliVisualPremultipliedAlpha(void)
2145 {
2146   ToolkitTestApplication application;
2147   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
2148
2149   VisualFactory factory = VisualFactory::Get();
2150
2151   // image visual, test default value ( false )
2152   {
2153     Visual::Base imageVisual = factory.CreateVisual(
2154           Property::Map()
2155           .Add( Visual::Property::TYPE, Visual::IMAGE )
2156           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
2157
2158     Dali::Property::Map visualMap;
2159     imageVisual.CreatePropertyMap( visualMap );
2160     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2161
2162     // test values
2163     DALI_TEST_CHECK( value );
2164     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
2165   }
2166
2167   // image visual, override premultiplied
2168   {
2169     Visual::Base imageVisual = factory.CreateVisual(
2170           Property::Map()
2171           .Add( Visual::Property::TYPE, Visual::IMAGE )
2172           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
2173           .Add( DevelVisual::Property::PREMULTIPLIED_ALPHA, true ) );
2174
2175     Dali::Property::Map visualMap;
2176     imageVisual.CreatePropertyMap( visualMap );
2177     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2178
2179     // test values
2180     DALI_TEST_CHECK( value );
2181     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
2182   }
2183
2184   // svg visual ( premultiplied alpha by default is true )
2185   {
2186     Visual::Base imageVisual = factory.CreateVisual(
2187           Property::Map()
2188           .Add( Visual::Property::TYPE, Visual::IMAGE )
2189           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
2190
2191     Dali::Property::Map visualMap;
2192     imageVisual.CreatePropertyMap( visualMap );
2193     Property::Value* value = visualMap.Find( DevelVisual::Property::PREMULTIPLIED_ALPHA );
2194
2195     // test values
2196     DALI_TEST_CHECK( value );
2197     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
2198   }
2199
2200   END_TEST;
2201 }