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