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

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