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