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