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