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