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