automated-tests/src/dali-toolkit/utc-Dali-Visual.cpp

   1 /*
   2  * Copyright (c) 2017 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/devel-api/object/handle-devel.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
  25 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  27 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
  29 #include <dali-toolkit/dali-toolkit.h>
  30 #include "dummy-control.h"
  31
  32 using namespace Dali;
  33 using namespace Dali::Toolkit;
  34
  35 namespace
  36 {
  37 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  38 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  39 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  40 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  41 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  42 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  43 const char* TEST_RESOURCE_LOCATION = TEST_RESOURCE_DIR "/";
  44
  45 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
  46
  47 Property::Map DefaultTransform()
  48 {
  49   Property::Map transformMap;
  50   transformMap
  51     .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  52     .Add( Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  53     .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
  54     .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN )
  55     .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) )
  56     .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
  57   return transformMap;
  58 }
  59
  60 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
  61 {
  62   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
  63   {
  64     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
  65     {
  66       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
  67
  68       Property::Value* valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
  69       if( NULL != valueSet )
  70       {
  71         if( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() )
  72         {
  73           tet_printf( "  Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
  74           return false;
  75         }
  76       }
  77       else
  78       {
  79         tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
  80         return false;
  81       }
  82     }
  83   }
  84
  85   return true;
  86 }
  87
  88 void PrepareResourceImage( ToolkitTestApplication& application, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  89 {
  90   TestPlatformAbstraction& platform = application.GetPlatform();
  91   platform.SetClosestImageSize(Vector2( imageWidth, imageHeight));
  92
  93   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  94   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  95   unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
  96   unsigned int initialColor = 0xFF;
  97   memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
  98
  99   Integration::ResourcePointer resourcePtr(bitmap);
 100   platform.SetSynchronouslyLoadedResource( resourcePtr );
 101 }
 102 } //namespace
 103
 104 void dali_visual_startup(void)
 105 {
 106   test_return_value = TET_UNDEF;
 107 }
 108
 109 void dali_visual_cleanup(void)
 110 {
 111   test_return_value = TET_PASS;
 112 }
 113
 114
 115 static void TestMixColor( Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor )
 116 {
 117   Property::Map map;
 118   visual.CreatePropertyMap(map);
 119   Property::Value* value = map.Find( mixColorIndex );
 120   DALI_TEST_CHECK( value );
 121   Vector3 mixColor1;
 122   DALI_TEST_CHECK( value->Get( mixColor1 ) );
 123   DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
 124
 125   value = map.Find( Visual::Property::MIX_COLOR );
 126   DALI_TEST_CHECK( value );
 127   Vector4 mixColor2;
 128   DALI_TEST_CHECK( value->Get( mixColor2 ) );
 129   DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
 130
 131   value = map.Find( Visual::Property::OPACITY );
 132   DALI_TEST_CHECK( value );
 133   float opacity;
 134   DALI_TEST_CHECK( value->Get( opacity ) );
 135   DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
 136 }
 137
 138
 139 int UtcDaliVisualCopyAndAssignment(void)
 140 {
 141   ToolkitTestApplication application;
 142   tet_infoline( "UtcDaliVisualCopyAndAssignment" );
 143
 144   VisualFactory factory = VisualFactory::Get();
 145   Property::Map propertyMap;
 146   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 147   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 148   Visual::Base visual = factory.CreateVisual( propertyMap );
 149
 150   Visual::Base visualCopy( visual );
 151   DALI_TEST_CHECK(visual == visualCopy);
 152
 153   Visual::Base emptyVisual;
 154   Visual::Base emptyVisualCopy( emptyVisual );
 155   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
 156
 157   Visual::Base visualEquals;
 158   visualEquals = visual;
 159   DALI_TEST_CHECK(visual == visualEquals);
 160
 161   Visual::Base emptyVisualEquals;
 162   emptyVisualEquals = emptyVisual;
 163   DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
 164
 165   //self assignment
 166   visual = visual;
 167   DALI_TEST_CHECK( visual = visualCopy );
 168
 169   END_TEST;
 170 }
 171
 172 int UtcDaliVisualSetName01(void)
 173 {
 174   ToolkitTestApplication application;
 175   tet_infoline( "UtcDaliVisualSetName" );
 176
 177   VisualFactory factory = VisualFactory::Get();
 178   Property::Map propertyMap;
 179   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 180   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 181   Visual::Base visual = factory.CreateVisual( propertyMap );
 182
 183   const char* visualName = "backgroundVisual";
 184   visual.SetName( visualName );
 185
 186   DALI_TEST_EQUALS( visual.GetName(), visualName, TEST_LOCATION );
 187
 188   END_TEST;
 189 }
 190
 191 int UtcDaliVisualSetGetDepthIndex(void)
 192 {
 193   ToolkitTestApplication application;
 194   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 195
 196   VisualFactory factory = VisualFactory::Get();
 197   Property::Map propertyMap;
 198   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 199   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 200   Visual::Base visual = factory.CreateVisual( propertyMap );
 201
 202   visual.SetDepthIndex( 1 );
 203
 204   DummyControl dummyControl = DummyControl::New(true);
 205   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 206   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 207
 208   dummyControl.SetSize(200.f, 200.f);
 209   Stage::GetCurrent().Add( dummyControl );
 210
 211
 212   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 213   DALI_TEST_EQUALS( depthIndex, 1, TEST_LOCATION );
 214   DALI_TEST_EQUALS( visual.GetDepthIndex(), 1, TEST_LOCATION );
 215
 216   visual.SetDepthIndex( -1 );
 217   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>( Renderer::Property::DEPTH_INDEX );
 218   DALI_TEST_EQUALS( depthIndex, -1, TEST_LOCATION );
 219   DALI_TEST_EQUALS( visual.GetDepthIndex(), -1, TEST_LOCATION );
 220
 221   END_TEST;
 222 }
 223
 224 int UtcDaliVisualSize(void)
 225 {
 226   ToolkitTestApplication application;
 227   tet_infoline( "UtcDaliVisualGetNaturalSize" );
 228
 229   VisualFactory factory = VisualFactory::Get();
 230   Vector2 controlSize( 20.f, 30.f );
 231   Vector2 naturalSize;
 232
 233   // color colorVisual
 234   Dali::Property::Map map;
 235   map[ Toolkit::Visual::Property::TYPE ] = Visual::COLOR;
 236   map[ ColorVisual::Property::MIX_COLOR ] = Color::MAGENTA;
 237
 238   Visual::Base colorVisual = factory.CreateVisual( map );
 239   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 240
 241   colorVisual.GetNaturalSize(naturalSize);
 242   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 243
 244   // image visual
 245   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 246   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 247   Visual::Base imageVisual = factory.CreateVisual( image );
 248   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 249
 250   imageVisual.GetNaturalSize(naturalSize);
 251   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 200.f), TEST_LOCATION );
 252
 253   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
 254
 255   // border visual
 256   float borderSize = 5.f;
 257   map.Clear();
 258   map[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 259   map[ BorderVisual::Property::COLOR  ] = Color::RED;
 260   map[ BorderVisual::Property::SIZE   ] = borderSize;
 261   Visual::Base borderVisual = factory.CreateVisual( map );
 262   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 263   borderVisual.GetNaturalSize(naturalSize);
 264   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 265
 266   // gradient gradientVisual
 267   Property::Map propertyMap;
 268   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 269   Vector2 start(-1.f, -1.f);
 270   Vector2 end(1.f, 1.f);
 271   propertyMap.Insert( "mixColor", Color::MAGENTA );
 272   propertyMap.Insert( GradientVisual::Property::START_POSITION,   start) ;
 273   propertyMap.Insert( GradientVisual::Property::END_POSITION,   end );
 274   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET,   Vector2(0.f, 1.f) );
 275   propertyMap.Insert( GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT) ;
 276   Property::Array stopColors;
 277   stopColors.PushBack( Color::RED );
 278   stopColors.PushBack( Color::GREEN );
 279   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 280   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 281   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 282   gradientVisual.GetNaturalSize(naturalSize);
 283   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
 284
 285   // animated gradient visual
 286   Vector2 animated_gradient_visual_size(10.f, 10.f);
 287   propertyMap.Clear();
 288   propertyMap.Insert( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT );
 289   Visual::Base animatedGradientVisual = factory.CreateVisual( propertyMap );
 290   animatedGradientVisual.GetNaturalSize(naturalSize);
 291   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 292   DALI_TEST_EQUALS( naturalSize, Vector2::ZERO, TEST_LOCATION );
 293
 294   // svg visual
 295   Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 296   svgVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 297   svgVisual.GetNaturalSize(naturalSize);
 298   // TEST_SVG_FILE:
 299   //  <svg width="100" height="100">
 300   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 301   //  </svg>
 302   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION );
 303
 304   // svg visual with a size
 305   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions(200, 200) );
 306   svgVisual2.GetNaturalSize(naturalSize);
 307   DALI_TEST_EQUALS( naturalSize, Vector2(100.f, 100.f), TEST_LOCATION ); // Natural size should still be 100, 100
 308
 309   // Text visual.
 310
 311   // Load some fonts to get the same metrics on different platforms.
 312   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 313   fontClient.SetDpi( 96u, 96u );
 314
 315   char* pathNamePtr = get_current_dir_name();
 316   const std::string pathName( pathNamePtr );
 317   free( pathNamePtr );
 318
 319   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf" );
 320
 321   propertyMap.Clear();
 322   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
 323   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
 324   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
 325   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
 326
 327   Visual::Base textVisual = factory.CreateVisual( propertyMap );
 328   textVisual.GetNaturalSize( naturalSize );
 329   DALI_TEST_EQUALS( naturalSize, Size( 80.f, 20.f ), TEST_LOCATION );
 330
 331   const float height = textVisual.GetHeightForWidth( 40.f );
 332   DALI_TEST_EQUALS( height, 40.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 333
 334   //AnimatedImageVisual
 335   Visual::Base animatedImageVisual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
 336   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize );
 337   animatedImageVisual.GetNaturalSize(naturalSize);
 338   // TEST_GIF_FILE: anim.gif
 339   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 340   DALI_TEST_EQUALS( naturalSize, Vector2(50.f, 50.f), TEST_LOCATION );
 341
 342   END_TEST;
 343 }
 344
 345 int UtcDaliVisualSetOnOffStage(void)
 346 {
 347   ToolkitTestApplication application;
 348   tet_infoline( "UtcDaliVisualSetDepthIndex" );
 349
 350   VisualFactory factory = VisualFactory::Get();
 351   Property::Map propertyMap;
 352   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 353   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
 354   Visual::Base visual = factory.CreateVisual( propertyMap );
 355
 356   DummyControl actor = DummyControl::New(true);
 357   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 358   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 359
 360   actor.SetSize(200.f, 200.f);
 361
 362   application.SendNotification();
 363   application.Render(0);
 364   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 365
 366   Stage::GetCurrent().Add( actor );
 367
 368   application.SendNotification();
 369   application.Render(0);
 370   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 371
 372   Stage::GetCurrent().Remove( actor );
 373
 374   application.SendNotification();
 375   application.Render(0);
 376   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 377
 378   END_TEST;
 379 }
 380
 381 int UtcDaliVisualGetPropertyMap1(void)
 382 {
 383   ToolkitTestApplication application;
 384   tet_infoline( "UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor" );
 385
 386   VisualFactory factory = VisualFactory::Get();
 387   Property::Map propertyMap;
 388   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 389   propertyMap.Insert(Visual::Property::MIX_COLOR,  Color::BLUE);
 390   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
 391
 392   Property::Map resultMap;
 393   colorVisual.CreatePropertyMap( resultMap );
 394
 395   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 396   DALI_TEST_CHECK( typeValue );
 397   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::COLOR );
 398
 399   Property::Value* colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 400   DALI_TEST_CHECK( colorValue );
 401   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 402
 403   // change the blend color
 404   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 405   colorVisual = factory.CreateVisual( propertyMap  );
 406   colorVisual.CreatePropertyMap( resultMap );
 407
 408   colorValue = resultMap.Find( ColorVisual::Property::MIX_COLOR,  Property::VECTOR4 );
 409   DALI_TEST_CHECK( colorValue );
 410   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 411
 412   END_TEST;
 413 }
 414
 415 int UtcDaliVisualGetPropertyMap2(void)
 416 {
 417   ToolkitTestApplication application;
 418   tet_infoline( "UtcDaliVisualGetPropertyMap2: BorderVisual" );
 419
 420   VisualFactory factory = VisualFactory::Get();
 421   Property::Map propertyMap;
 422   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 423   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
 424   propertyMap.Insert("borderColor",  Color::BLUE);
 425   propertyMap.Insert("borderSize",  5.f);
 426   propertyMap.Insert("antiAliasing",  true);
 427   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 428
 429   Property::Map resultMap;
 430   borderVisual.CreatePropertyMap( resultMap );
 431
 432   // check the property values from the returned map from visual
 433   Property::Value* typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 434   DALI_TEST_CHECK( typeValue );
 435   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 436
 437   Property::Value* colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 438   DALI_TEST_CHECK( colorValue );
 439   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
 440
 441   Property::Value* sizeValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 442   DALI_TEST_CHECK( sizeValue );
 443   DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
 444
 445   Property::Value* AAValue = resultMap.Find( BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN );
 446   DALI_TEST_CHECK( AAValue );
 447   DALI_TEST_CHECK( AAValue->Get<bool>() == true );
 448
 449   Property::Map propertyMap1;
 450   propertyMap1[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 451   propertyMap1[ BorderVisual::Property::COLOR  ] = Color::CYAN;
 452   propertyMap1[ BorderVisual::Property::SIZE   ] = 10.0f;
 453   borderVisual = factory.CreateVisual( propertyMap1 );
 454   borderVisual.CreatePropertyMap( resultMap );
 455
 456   typeValue = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 457   DALI_TEST_CHECK( typeValue );
 458   DALI_TEST_CHECK( typeValue->Get<int>() == Visual::BORDER );
 459
 460   colorValue = resultMap.Find( BorderVisual::Property::COLOR,  Property::VECTOR4 );
 461   DALI_TEST_CHECK( colorValue );
 462   DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::CYAN );
 463
 464   colorValue = resultMap.Find( BorderVisual::Property::SIZE,  Property::FLOAT );
 465   DALI_TEST_CHECK( colorValue );
 466   DALI_TEST_CHECK( colorValue->Get<float>() == 10.f );
 467
 468
 469   END_TEST;
 470 }
 471
 472 int UtcDaliVisualGetPropertyMap2N(void)
 473 {
 474   ToolkitTestApplication application;
 475   tet_infoline( "UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties" );
 476
 477   VisualFactory factory = VisualFactory::Get();
 478   Property::Map propertyMap;
 479   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 480   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
 481
 482   tet_infoline( "Test that the visual is created, with a default renderer" );
 483   DALI_TEST_CHECK( borderVisual );
 484
 485   DummyControl dummyControl = DummyControl::New(true);
 486   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
 487   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
 488   Stage::GetCurrent().Add( dummyControl );
 489
 490   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
 491
 492   END_TEST;
 493 }
 494
 495
 496 int UtcDaliVisualGetPropertyMap3(void)
 497 {
 498   ToolkitTestApplication application;
 499   tet_infoline( "UtcDaliVisualGetPropertyMap3: linear GradientVisual" );
 500
 501   VisualFactory factory = VisualFactory::Get();
 502   DALI_TEST_CHECK( factory );
 503
 504   Property::Map propertyMap;
 505   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 506
 507   Vector2 start(-1.f, -1.f);
 508   Vector2 end(1.f, 1.f);
 509   propertyMap.Insert( "startPosition", start);
 510   propertyMap.Insert( "endPosition", end);
 511   propertyMap.Insert( "spreadMethod", GradientVisual::SpreadMethod::REPEAT);
 512
 513   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector2(0.2f, 0.8f));
 514
 515   Property::Array stopColors;
 516   stopColors.PushBack( Color::RED );
 517   stopColors.PushBack( Color::GREEN );
 518   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 519
 520   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 521
 522   Property::Map resultMap;
 523   gradientVisual.CreatePropertyMap( resultMap );
 524
 525   // check the property values from the returned map from visual
 526   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 527   DALI_TEST_CHECK( value );
 528   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 529
 530   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 531   DALI_TEST_CHECK( value );
 532   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX );
 533
 534   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 535   DALI_TEST_CHECK( value );
 536   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::REPEAT );
 537
 538   value = resultMap.Find( GradientVisual::Property::START_POSITION,   Property::VECTOR2 );
 539   DALI_TEST_CHECK( value );
 540   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 541
 542   value = resultMap.Find( GradientVisual::Property::END_POSITION,   Property::VECTOR2 );
 543   DALI_TEST_CHECK( value );
 544   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 545
 546   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 547   DALI_TEST_CHECK( value );
 548   Property::Array* offsetArray = value->GetArray();
 549   DALI_TEST_CHECK( offsetArray->Count() == 2 );
 550   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.2f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 551   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.8f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 552
 553   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 554   DALI_TEST_CHECK( value );
 555   Property::Array* colorArray = value->GetArray();
 556   DALI_TEST_CHECK( colorArray->Count() == 2 );
 557   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 558   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 559
 560   END_TEST;
 561 }
 562
 563 int UtcDaliVisualGetPropertyMap4(void)
 564 {
 565   ToolkitTestApplication application;
 566   tet_infoline( "UtcDaliVisualGetPropertyMap4: radial GradientVisual" );
 567
 568   VisualFactory factory = VisualFactory::Get();
 569   DALI_TEST_CHECK( factory );
 570
 571   Property::Map propertyMap;
 572   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 573
 574   Vector2 center(100.f, 100.f);
 575   float radius = 100.f;
 576   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 577   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 578   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 579   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   Vector3(0.1f, 0.3f, 1.1f));
 580
 581   Property::Array stopColors;
 582   stopColors.PushBack( Color::RED );
 583   stopColors.PushBack( Color::BLACK );
 584   stopColors.PushBack( Color::GREEN );
 585   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 586
 587   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
 588   DALI_TEST_CHECK( gradientVisual );
 589
 590   Property::Map resultMap;
 591   gradientVisual.CreatePropertyMap( resultMap );
 592
 593   // check the property values from the returned map from visual
 594   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 595   DALI_TEST_CHECK( value );
 596   DALI_TEST_CHECK( value->Get<int>() == Visual::GRADIENT );
 597
 598   value = resultMap.Find( GradientVisual::Property::UNITS,  Property::INTEGER );
 599   DALI_TEST_CHECK( value );
 600   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::Units::USER_SPACE );
 601
 602   value = resultMap.Find( GradientVisual::Property::SPREAD_METHOD,   Property::INTEGER );
 603   DALI_TEST_CHECK( value );
 604   DALI_TEST_CHECK( value->Get<int>() == GradientVisual::SpreadMethod::PAD );
 605
 606   value = resultMap.Find( GradientVisual::Property::CENTER,  Property::VECTOR2 );
 607   DALI_TEST_CHECK( value );
 608   DALI_TEST_EQUALS( value->Get<Vector2>(), center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 609
 610   value = resultMap.Find( GradientVisual::Property::RADIUS,  Property::FLOAT );
 611   DALI_TEST_CHECK( value );
 612   DALI_TEST_EQUALS( value->Get<float>(), radius , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 613
 614   value = resultMap.Find( GradientVisual::Property::STOP_OFFSET,   Property::ARRAY );
 615   DALI_TEST_CHECK( value );
 616   Property::Array* offsetArray = value->GetArray();
 617   DALI_TEST_CHECK( offsetArray->Count() == 3 );
 618   DALI_TEST_EQUALS( offsetArray->GetElementAt(0).Get<float>(), 0.1f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 619   DALI_TEST_EQUALS( offsetArray->GetElementAt(1).Get<float>(), 0.3f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 620   // any stop value will be clamped to [0.0, 1.0];
 621   DALI_TEST_EQUALS( offsetArray->GetElementAt(2).Get<float>(), 1.0f , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 622
 623   value = resultMap.Find( GradientVisual::Property::STOP_COLOR,   Property::ARRAY );
 624   DALI_TEST_CHECK( value );
 625   Property::Array* colorArray = value->GetArray();
 626   DALI_TEST_CHECK( colorArray->Count() == 3 );
 627   DALI_TEST_EQUALS( colorArray->GetElementAt(0).Get<Vector4>(), Color::RED , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 628   DALI_TEST_EQUALS( colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 629   DALI_TEST_EQUALS( colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN , Math::MACHINE_EPSILON_100, TEST_LOCATION );
 630
 631   END_TEST;
 632 }
 633
 634 int UtcDaliVisualGetPropertyMap5(void)
 635 {
 636   ToolkitTestApplication application;
 637   tet_infoline( "UtcDaliVisualGetPropertyMap5: ImageVisual" );
 638
 639   VisualFactory factory = VisualFactory::Get();
 640   Property::Map propertyMap;
 641   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 642   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
 643   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 644   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
 645   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
 646   propertyMap.Insert( "fittingMode",   FittingMode::FIT_HEIGHT );
 647   propertyMap.Insert( "samplingMode",   SamplingMode::BOX_THEN_NEAREST );
 648   propertyMap.Insert( "pixelArea", Vector4( 0.25f, 0.25f, 0.5f, 0.5f ) );
 649   propertyMap.Insert( "wrapModeU", WrapMode::REPEAT );
 650   propertyMap.Insert( "wrapModeV", WrapMode::MIRRORED_REPEAT );
 651   propertyMap.Insert( "synchronousLoading",   true );
 652
 653   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
 654   DALI_TEST_CHECK( imageVisual );
 655
 656   Property::Map resultMap;
 657   imageVisual.CreatePropertyMap( resultMap );
 658
 659   // check the property values from the returned map from visual
 660   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 661   DALI_TEST_CHECK( value );
 662   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 663
 664   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 665   DALI_TEST_CHECK( value );
 666   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 667
 668   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 669   DALI_TEST_CHECK( value );
 670   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 671
 672   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 673   DALI_TEST_CHECK( value );
 674   DALI_TEST_CHECK( value->Get<int>() == FittingMode::FIT_HEIGHT );
 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_THEN_NEAREST );
 679
 680   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 681   DALI_TEST_CHECK( value );
 682   DALI_TEST_CHECK( value->Get<int>() == 20 );
 683
 684   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 685   DALI_TEST_CHECK( value );
 686   DALI_TEST_CHECK( value->Get<int>() == 30 );
 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.25f, 0.25f, 0.5f, 0.5f ), 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::REPEAT);
 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::MIRRORED_REPEAT);
 699
 700   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 701   DALI_TEST_CHECK( value );
 702   DALI_TEST_CHECK( value->Get<bool>() == true );
 703
 704   // Get an image visual with an image handle, and test the default property values
 705   PrepareResourceImage( application, 100u, 200u, Pixel::RGBA8888 );
 706   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
 707   imageVisual = factory.CreateVisual(image);
 708   imageVisual.CreatePropertyMap( resultMap );
 709
 710   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 711   DALI_TEST_CHECK( value );
 712   DALI_TEST_CHECK( value->Get<int>() == Visual::IMAGE );
 713
 714   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 715   DALI_TEST_CHECK( value );
 716   DALI_TEST_CHECK( value->Get<std::string>() == TEST_IMAGE_FILE_NAME );
 717
 718   value = resultMap.Find( ImageVisual::Property::FITTING_MODE,   Property::INTEGER );
 719   DALI_TEST_CHECK( value );
 720   DALI_TEST_CHECK( value->Get<int>() == FittingMode::SHRINK_TO_FIT );
 721
 722   value = resultMap.Find( ImageVisual::Property::SAMPLING_MODE,   Property::INTEGER );
 723   DALI_TEST_CHECK( value );
 724   DALI_TEST_CHECK( value->Get<int>() == SamplingMode::BOX );
 725
 726   value = resultMap.Find( ImageVisual::Property::DESIRED_WIDTH,   Property::INTEGER );
 727   DALI_TEST_CHECK( value );
 728   DALI_TEST_CHECK( value->Get<int>() == 100 );
 729
 730   value = resultMap.Find( ImageVisual::Property::DESIRED_HEIGHT,   Property::INTEGER );
 731   DALI_TEST_CHECK( value );
 732   DALI_TEST_CHECK( value->Get<int>() == 200 );
 733
 734   value = resultMap.Find( ImageVisual::Property::PIXEL_AREA, Property::VECTOR4 );
 735   DALI_TEST_CHECK( value );
 736   DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4( 0.f, 0.f, 1.f, 1.f ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 737
 738   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_U, Property::INTEGER );
 739   DALI_TEST_CHECK( value );
 740   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 741
 742   value = resultMap.Find( ImageVisual::Property::WRAP_MODE_V, Property::INTEGER );
 743   DALI_TEST_CHECK( value );
 744   DALI_TEST_CHECK(  value->Get<int>() == WrapMode::DEFAULT);
 745
 746   value = resultMap.Find( "synchronousLoading",   Property::BOOLEAN );
 747   DALI_TEST_CHECK( value );
 748   DALI_TEST_CHECK( value->Get<bool>() == false );
 749
 750   END_TEST;
 751 }
 752
 753 int UtcDaliVisualGetPropertyMap6(void)
 754 {
 755   ToolkitTestApplication application;
 756   tet_infoline( "UtcDaliVisualGetPropertyMap6: NPatchVisual" );
 757
 758   Rect< int > border( 1, 1, 1, 1 );
 759
 760   VisualFactory factory = VisualFactory::Get();
 761   Property::Map propertyMap;
 762   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 763   propertyMap.Insert( "mixColor",  Color::MAGENTA );
 764   propertyMap.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 765   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 766   propertyMap.Insert( ImageVisual::Property::BORDER, border );
 767   Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
 768
 769   Property::Map resultMap;
 770   nPatchVisual.CreatePropertyMap( resultMap );
 771
 772   // check the property values from the returned map from visual
 773   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 774   DALI_TEST_CHECK( value );
 775   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 776
 777   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 778   DALI_TEST_CHECK( value );
 779   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 780
 781   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 782   DALI_TEST_CHECK( value );
 783   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 784
 785   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 786   DALI_TEST_CHECK( value );
 787   DALI_TEST_CHECK( value->Get<bool>() );
 788
 789   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 790   DALI_TEST_CHECK( value );
 791   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 792
 793   Vector4 border1( 1.0f, 1.0f, 1.0f, 1.0f );
 794
 795   Property::Map propertyMap1;
 796   propertyMap1.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 797   propertyMap1.Insert( "mixColor",  Color::MAGENTA );
 798   propertyMap1.Insert( ImageVisual::Property::URL,  TEST_NPATCH_FILE_NAME );
 799   propertyMap1.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 800   propertyMap1.Insert( ImageVisual::Property::BORDER, border1 );
 801   nPatchVisual = factory.CreateVisual( propertyMap1 );
 802
 803   nPatchVisual.CreatePropertyMap( resultMap );
 804
 805   // check the property values from the returned map from visual
 806   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 807   DALI_TEST_CHECK( value );
 808   DALI_TEST_CHECK( value->Get<int>() == Visual::N_PATCH );
 809
 810   value = resultMap.Find( Visual::Property::MIX_COLOR,  Property::VECTOR4 );
 811   DALI_TEST_CHECK( value );
 812   DALI_TEST_CHECK( value->Get<Vector4>() == Color::MAGENTA );
 813
 814   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 815   DALI_TEST_CHECK( value );
 816   DALI_TEST_CHECK( value->Get<std::string>() == TEST_NPATCH_FILE_NAME );
 817
 818   value = resultMap.Find( ImageVisual::Property::BORDER_ONLY,  Property::BOOLEAN );
 819   DALI_TEST_CHECK( value );
 820   DALI_TEST_CHECK( value->Get<bool>() );
 821
 822   value = resultMap.Find( ImageVisual::Property::BORDER,  Property::RECTANGLE );
 823   DALI_TEST_CHECK( value );
 824   DALI_TEST_CHECK( value->Get< Rect< int > >() == border );
 825
 826   END_TEST;
 827 }
 828
 829 int UtcDaliVisualGetPropertyMap7(void)
 830 {
 831   ToolkitTestApplication application;
 832   tet_infoline( "UtcDaliVisualGetPropertyMap7: SvgVisual" );
 833
 834   // request SvgVisual with a property map
 835   VisualFactory factory = VisualFactory::Get();
 836   Property::Map propertyMap;
 837   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
 838   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::WHITE );
 839   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
 840   propertyMap.Insert( ImageVisual::Property::ATLASING, false );
 841   Visual::Base svgVisual = factory.CreateVisual( propertyMap );
 842
 843   Property::Map resultMap;
 844   svgVisual.CreatePropertyMap( resultMap );
 845   // check the property values from the returned map from a visual
 846   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 847   DALI_TEST_CHECK( value );
 848   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 849
 850   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 851   DALI_TEST_CHECK( value );
 852   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 853
 854   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 855   DALI_TEST_CHECK( value );
 856   DALI_TEST_CHECK( value->Get<bool>() == false );
 857
 858   // request SvgVisual with a property map 2
 859   propertyMap.Clear();
 860   propertyMap[ "visualType" ] = Visual::SVG;
 861   propertyMap[ "mixColor" ] = Color::WHITE;
 862   propertyMap[ "url" ] = TEST_SVG_FILE_NAME;
 863   propertyMap[ "atlasing" ] = true;
 864   Visual::Base svgVisual1 = factory.CreateVisual( propertyMap );
 865
 866   resultMap.Clear();
 867   svgVisual1.CreatePropertyMap( resultMap );
 868   // check the property values from the returned map from a visual
 869   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 870   DALI_TEST_CHECK( value );
 871   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 872
 873   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 874   DALI_TEST_CHECK( value );
 875   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 876
 877   value = resultMap.Find( ImageVisual::Property::ATLASING, Property::BOOLEAN );
 878   DALI_TEST_CHECK( value );
 879   DALI_TEST_CHECK( value->Get<bool>() == true );
 880
 881   // request SvgVisual with an URL
 882   Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
 883   resultMap.Clear();
 884   svgVisual2.CreatePropertyMap( resultMap );
 885   // check the property values from the returned map from a visual
 886   value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
 887   DALI_TEST_CHECK( value );
 888   DALI_TEST_CHECK( value->Get<int>() == Visual::SVG );
 889
 890   value = resultMap.Find( ImageVisual::Property::URL,  Property::STRING );
 891   DALI_TEST_CHECK( value );
 892   DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
 893
 894   END_TEST;
 895 }
 896
 897 //Mesh visual
 898 int UtcDaliVisualGetPropertyMap8(void)
 899 {
 900   ToolkitTestApplication application;
 901   tet_infoline( "UtcDaliVisualGetPropertyMap8: MeshVisual" );
 902
 903   //Request MeshVisual using a property map.
 904   VisualFactory factory = VisualFactory::Get();
 905   Property::Map propertyMap;
 906   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
 907   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLUE );
 908   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
 909   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
 910   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION );
 911   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
 912   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 913   Visual::Base meshVisual = factory.CreateVisual( propertyMap );
 914
 915   Property::Map resultMap;
 916   meshVisual.CreatePropertyMap( resultMap );
 917   TestMixColor( meshVisual, Visual::Property::MIX_COLOR, Color::BLUE );
 918
 919   //Check values in the result map are identical to the initial map's values.
 920   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
 921   DALI_TEST_CHECK( value );
 922   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::MESH, TEST_LOCATION );
 923
 924   value = resultMap.Find( MeshVisual::Property::OBJECT_URL, Property::STRING );
 925   DALI_TEST_CHECK( value );
 926   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
 927
 928   value = resultMap.Find( MeshVisual::Property::MATERIAL_URL, Property::STRING );
 929   DALI_TEST_CHECK( value );
 930   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION );
 931
 932   value = resultMap.Find( MeshVisual::Property::TEXTURES_PATH, Property::STRING );
 933   DALI_TEST_CHECK( value );
 934   DALI_TEST_EQUALS( value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION );
 935
 936   value = resultMap.Find( MeshVisual::Property::SHADING_MODE, Property::INTEGER );
 937   DALI_TEST_CHECK( value );
 938   DALI_TEST_EQUALS( value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION );
 939
 940   value = resultMap.Find( MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
 941   DALI_TEST_CHECK( value );
 942   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
 943
 944  END_TEST;
 945 }
 946
 947 //Primitive shape visual
 948 int UtcDaliVisualGetPropertyMap9(void)
 949 {
 950   ToolkitTestApplication application;
 951   tet_infoline( "UtcDaliVisualGetPropertyMap9: PrimitiveVisual" );
 952
 953   Vector4 color = Vector4( 1.0, 0.8, 0.6, 1.0);
 954   Vector3 dimensions = Vector3( 1.0, 2.0, 3.0 );
 955
 956   //Request PrimitiveVisual using a property map.
 957   VisualFactory factory = VisualFactory::Get();
 958   Property::Map propertyMap;
 959   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
 960   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
 961   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, color );
 962   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
 963   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
 964   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
 965   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
 966   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
 967   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
 968   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions );
 969   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f );
 970   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f );
 971   propertyMap.Insert( PrimitiveVisual::Property::LIGHT_POSITION, Vector3( 5.0f, 10.0f, 15.0f) );
 972   Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
 973
 974   Property::Map resultMap;
 975   primitiveVisual.CreatePropertyMap( resultMap );
 976
 977   //Check values in the result map are identical to the initial map's values.
 978   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
 979   DALI_TEST_CHECK( value );
 980   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION );
 981
 982   value = resultMap.Find( PrimitiveVisual::Property::SHAPE, Property::INTEGER );
 983   DALI_TEST_CHECK( value );
 984   DALI_TEST_EQUALS( value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION );
 985
 986   value = resultMap.Find( PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4 );
 987   DALI_TEST_CHECK( value );
 988   DALI_TEST_CHECK( value->Get<Vector4>() == color );
 989   DALI_TEST_EQUALS( value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 990
 991   value = resultMap.Find( PrimitiveVisual::Property::SLICES, Property::INTEGER );
 992   DALI_TEST_CHECK( value );
 993   DALI_TEST_EQUALS( value->Get<int>(), 10, TEST_LOCATION );
 994
 995   value = resultMap.Find( PrimitiveVisual::Property::STACKS, Property::INTEGER );
 996   DALI_TEST_CHECK( value );
 997   DALI_TEST_EQUALS( value->Get<int>(), 20, TEST_LOCATION );
 998
 999   value = resultMap.Find( PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT );
1000   DALI_TEST_CHECK( value );
1001   DALI_TEST_EQUALS( value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1002
1003   value = resultMap.Find( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT );
1004   DALI_TEST_CHECK( value );
1005   DALI_TEST_EQUALS( value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1006
1007   value = resultMap.Find( PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT );
1008   DALI_TEST_CHECK( value );
1009   DALI_TEST_EQUALS( value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1010
1011   value = resultMap.Find( PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT );
1012   DALI_TEST_CHECK( value );
1013   DALI_TEST_EQUALS( value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1014
1015   value = resultMap.Find( PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3 );
1016   DALI_TEST_CHECK( value );
1017   DALI_TEST_EQUALS( value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1018
1019   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT );
1020   DALI_TEST_CHECK( value );
1021   DALI_TEST_EQUALS( value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1022
1023   value = resultMap.Find( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT );
1024   DALI_TEST_CHECK( value );
1025   DALI_TEST_EQUALS( value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1026
1027   value = resultMap.Find( PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3 );
1028   DALI_TEST_CHECK( value );
1029   DALI_TEST_EQUALS( value->Get<Vector3>(), Vector3( 5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1030
1031   END_TEST;
1032 }
1033
1034 //Text shape visual
1035 int UtcDaliVisualGetPropertyMap10(void)
1036 {
1037   ToolkitTestApplication application;
1038   tet_infoline( "UtcDaliVisualGetPropertyMap10: TextVisual" );
1039
1040   //Request PrimitiveVisual using a property map.
1041   VisualFactory factory = VisualFactory::Get();
1042
1043   Property::Map propertyMap;
1044   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
1045   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::BLACK );
1046   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
1047   propertyMap.Insert( "enableMarkup", false );
1048   propertyMap.Insert( "text", "Hello world" );
1049   propertyMap.Insert( "fontFamily", "TizenSans" );
1050
1051   Property::Map fontStyleMapSet;
1052   fontStyleMapSet.Insert( "weight", "bold" );
1053   propertyMap.Insert( "fontStyle", fontStyleMapSet );
1054
1055   propertyMap.Insert( "pointSize", 12.f );
1056   propertyMap.Insert( "multiLine", true );
1057   propertyMap.Insert( "horizontalAlignment", "CENTER" );
1058   propertyMap.Insert( "verticalAlignment", "CENTER" );
1059   propertyMap.Insert( "textColor", Color::RED );
1060   Visual::Base textVisual = factory.CreateVisual( propertyMap );
1061
1062   Property::Map resultMap;
1063   textVisual.CreatePropertyMap( resultMap );
1064
1065   //Check values in the result map are identical to the initial map's values.
1066   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
1067   DALI_TEST_CHECK( value );
1068   DALI_TEST_EQUALS( value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION );
1069
1070   value = resultMap.Find( Visual::Property::MIX_COLOR, Property::VECTOR4 );
1071   DALI_TEST_CHECK( value );
1072   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION );
1073
1074   value = resultMap.Find( TextVisual::Property::TEXT, Property::STRING );
1075   DALI_TEST_CHECK( value );
1076   DALI_TEST_EQUALS( value->Get<std::string>(), "Hello world", TEST_LOCATION );
1077
1078   value = resultMap.Find( TextVisual::Property::FONT_FAMILY, Property::STRING );
1079   DALI_TEST_CHECK( value );
1080   DALI_TEST_EQUALS( value->Get<std::string>(), "TizenSans", TEST_LOCATION );
1081
1082   value = resultMap.Find( TextVisual::Property::FONT_STYLE, Property::MAP );
1083   DALI_TEST_CHECK( value );
1084
1085   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1086   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1087   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1088
1089   value = resultMap.Find( TextVisual::Property::POINT_SIZE, Property::FLOAT );
1090   DALI_TEST_CHECK( value );
1091   DALI_TEST_EQUALS( value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1092
1093   value = resultMap.Find( TextVisual::Property::MULTI_LINE, Property::BOOLEAN );
1094   DALI_TEST_CHECK( value );
1095   DALI_TEST_CHECK( value->Get<bool>() );
1096
1097   value = resultMap.Find( TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER );
1098   DALI_TEST_CHECK( value );
1099   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION );
1100
1101   value = resultMap.Find( TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER );
1102   DALI_TEST_CHECK( value );
1103   DALI_TEST_EQUALS( value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION );
1104
1105   value = resultMap.Find( TextVisual::Property::TEXT_COLOR, Property::VECTOR4 );
1106   DALI_TEST_CHECK( value );
1107   DALI_TEST_EQUALS( value->Get<Vector4>(), Color::RED, TEST_LOCATION );
1108
1109   value = resultMap.Find( TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN );
1110   DALI_TEST_CHECK( value );
1111   DALI_TEST_CHECK( !value->Get<bool>() );
1112
1113   END_TEST;
1114 }
1115
1116 int UtcDaliVisualGetPropertyMap11(void)
1117 {
1118   ToolkitTestApplication application;
1119   tet_infoline( "UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual" );
1120
1121   VisualFactory factory = VisualFactory::Get();
1122   DALI_TEST_CHECK( factory );
1123
1124   Property::Map propertyMap;
1125   propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1126
1127   Vector2 start(-0.5f, 0.5f);
1128   Vector2 end  (0.5f, -0.0f);
1129   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1130   Vector4 end_color  (0.7f, 0.5f, 1.0f, 1.0f);
1131   Vector2 rotate_center(0.0f, 0.4f);
1132   float rotate_amount = 1.57f;
1133   float offset = 100.f;
1134
1135   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::RADIAL);
1136   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1137   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::CLAMP);
1138
1139   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION,  start);
1140   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,  end);
1141   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,  start_color);
1142   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,  end_color);
1143   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  rotate_center);
1144   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  rotate_amount);
1145   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,  offset);
1146
1147   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1148   DALI_TEST_CHECK( animatedGradientVisual );
1149
1150   Property::Map resultMap;
1151   animatedGradientVisual.CreatePropertyMap( resultMap );
1152
1153   // check the property values from the returned map from visual
1154   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1155   DALI_TEST_CHECK( value );
1156   DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1157
1158   value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1159   DALI_TEST_CHECK( value );
1160   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1161
1162   value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1163   DALI_TEST_CHECK( value );
1164   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1165
1166   value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1167   DALI_TEST_CHECK( value );
1168   DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP );
1169
1170
1171   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1172   DALI_TEST_CHECK( value );
1173   DALI_TEST_EQUALS( value->Get<Vector2>(), start , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1174
1175   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1176   DALI_TEST_CHECK( value );
1177   DALI_TEST_EQUALS( value->Get<Vector2>(), end , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1178
1179   value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1180   DALI_TEST_CHECK( value );
1181   DALI_TEST_EQUALS( value->Get<Vector4>(), start_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1182
1183   value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1184   DALI_TEST_CHECK( value );
1185   DALI_TEST_EQUALS( value->Get<Vector4>(), end_color , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1186
1187   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1188   DALI_TEST_CHECK( value );
1189   DALI_TEST_EQUALS( value->Get<Vector2>(), rotate_center , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1190
1191   value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1192   DALI_TEST_CHECK( value );
1193   DALI_TEST_EQUALS( value->Get<float>(), rotate_amount , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1194
1195   value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1196   DALI_TEST_CHECK( value );
1197   DALI_TEST_EQUALS( value->Get<float>(), offset , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1198
1199   END_TEST;
1200 }
1201
1202 int UtcDaliVisualGetPropertyMap12(void)
1203 {
1204   ToolkitTestApplication application;
1205   tet_infoline( "UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param" );
1206
1207   // Case 1 : Set values by index
1208   {
1209     tet_printf( " - Set Values by Index\n" );
1210     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1211     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1212     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1213     {
1214       tet_printf( "test with delay [%f]\n", _delay );
1215       VisualFactory factory = VisualFactory::Get();
1216       DALI_TEST_CHECK( factory );
1217
1218       Property::Map propertyMap;
1219       Property::Map animationMap;
1220       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1221
1222       float duration = 1.1f;
1223       float delay = _delay;
1224       float repeat_delay = 0.4f;
1225
1226       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1227       int loop_count = 5;
1228       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1229       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1230
1231       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1232       {
1233         animationMap.Clear();
1234         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1235         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1236         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1237         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1238         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1239         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1240         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1241         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1242         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1243
1244         return animationMap;
1245       };
1246
1247       Vector2 start1(-0.5f, 0.5f);
1248       Vector2 end1  (0.5f, -0.5f);
1249       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1250       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1251       Vector2 rotate_center1(0.0f, 0.4f);
1252       float rotate_amount1 = 0.0f;
1253       float offset1 = 0.f;
1254
1255       Vector2 start2(-0.5f, -0.5f);
1256       Vector2 end2  (0.5f, 0.5f);
1257       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1258       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1259       Vector2 rotate_center2(0.0f, -0.4f);
1260       float rotate_amount2 = 6.2832f;
1261       float offset2 = 2.f;
1262
1263       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1264       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1265       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REPEAT);
1266
1267       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1268       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1269       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1270       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1271       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1272       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1273       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1274
1275       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1276       DALI_TEST_CHECK( animatedGradientVisual );
1277
1278       Property::Map resultMap;
1279       animatedGradientVisual.CreatePropertyMap( resultMap );
1280
1281       // check the property values from the returned map from visual
1282       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1283       DALI_TEST_CHECK( value );
1284       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1285
1286       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1287       DALI_TEST_CHECK( value );
1288       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1289
1290       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1291       DALI_TEST_CHECK( value );
1292       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1293
1294       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1295       DALI_TEST_CHECK( value );
1296       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT );
1297
1298       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index &index, const Property::Value &start, const Property::Value &target, int line_num)->void
1299       {
1300         tet_printf("Check value at %d\n", line_num);
1301         value = resultMap.Find( index, Property::MAP );
1302         DALI_TEST_CHECK( value );
1303         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1304         Property::Map *temp_map = value->GetMap();
1305         DALI_TEST_CHECK( temp_map );
1306
1307         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1308         {
1309           Property::Value *res = temp_map->Find( index );
1310           DALI_TEST_CHECK( res );
1311           return *res;
1312         };
1313
1314         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1315         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1316         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1317         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1318         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1319         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1320         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1321         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1322         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1323       };
1324
1325       // check the animation map data is good
1326       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1327       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1328       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1329       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1330       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1331       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1332       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1333     }
1334   }
1335
1336   // Case 2 : Set values by string
1337   {
1338     tet_printf( " - Set Values by String\n" );
1339     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1340     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1341     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1342     {
1343       tet_printf( "test with delay [%f]\n", _delay );
1344       VisualFactory factory = VisualFactory::Get();
1345       DALI_TEST_CHECK( factory );
1346
1347       Property::Map propertyMap;
1348       Property::Map animationMap;
1349       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1350
1351       float duration = 1.1f;
1352       float delay = _delay;
1353       float repeat_delay = 0.4f;
1354
1355       int direction = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1356       int loop_count = 5;
1357       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1358       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1359
1360       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value &start, const Property::Value &target)->Property::Map&
1361       {
1362         animationMap.Clear();
1363         animationMap.Insert("startValue"   , start);
1364         animationMap.Insert("targetValue"  , target);
1365         animationMap.Insert("directionType", "BACKWARD");
1366         animationMap.Insert("duration"     , duration);
1367         animationMap.Insert("delay"        , delay);
1368         animationMap.Insert("repeat"       , loop_count);
1369         animationMap.Insert("repeatDelay"  , repeat_delay);
1370         animationMap.Insert("motionType"   , "MIRROR");
1371         animationMap.Insert("easingType"   , "IN_OUT");
1372
1373         return animationMap;
1374       };
1375
1376       Vector2 start1(-0.5f, 0.5f);
1377       Vector2 end1  (0.5f, -0.5f);
1378       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1379       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1380       Vector2 rotate_center1(0.0f, 0.4f);
1381       float rotate_amount1 = 0.0f;
1382       float offset1 = 0.f;
1383
1384       Vector2 start2(-0.5f, -0.5f);
1385       Vector2 end2  (0.5f, 0.5f);
1386       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1387       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1388       Vector2 rotate_center2(0.0f, -0.4f);
1389       float rotate_amount2 = 6.2832f;
1390       float offset2 = 2.f;
1391
1392       // For test mix the type string/index key and string/index value works well.
1393       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  "RADIAL");
1394       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1395       propertyMap.Insert("spreadType"  , DevelAnimatedGradientVisual::SpreadType::REFLECT);
1396
1397       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ));
1398       propertyMap.Insert("endPosition"  , buildAnimatedMap(end1          , end2          ));
1399       propertyMap.Insert("startColor"   , buildAnimatedMap(start_color1  , start_color2  ));
1400       propertyMap.Insert("endColor"     , buildAnimatedMap(end_color1    , end_color2    ));
1401       propertyMap.Insert("rotateCenter" , buildAnimatedMap(rotate_center1, rotate_center2));
1402       propertyMap.Insert("rotateAmount" , buildAnimatedMap(rotate_amount1, rotate_amount2));
1403       propertyMap.Insert("offset"       , buildAnimatedMap(offset1       , offset2       ));
1404
1405       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1406       DALI_TEST_CHECK( animatedGradientVisual );
1407
1408       Property::Map resultMap;
1409       animatedGradientVisual.CreatePropertyMap( resultMap );
1410
1411       // check the property values from the returned map from visual
1412       // Note : resultMap from CreatePropertyMap only contain indexKey
1413       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1414       DALI_TEST_CHECK( value );
1415       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1416
1417       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1418       DALI_TEST_CHECK( value );
1419       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL );
1420
1421       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1422       DALI_TEST_CHECK( value );
1423       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE );
1424
1425       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1426       DALI_TEST_CHECK( value );
1427       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1428
1429       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index &index, const Property::Value &start, const Property::Value &target, int line_num)->void
1430       {
1431         tet_printf("Check value at %d\n", line_num);
1432         value = resultMap.Find( index, Property::MAP );
1433         DALI_TEST_CHECK( value );
1434         DALI_TEST_CHECK( value->GetType() == Property::MAP );
1435         Property::Map *temp_map = value->GetMap();
1436         DALI_TEST_CHECK( temp_map );
1437
1438         auto checkMapValue = [&temp_map](const Property::Index index)->Property::Value
1439         {
1440           Property::Value *res = temp_map->Find( index );
1441           DALI_TEST_CHECK( res );
1442           return *res;
1443         };
1444
1445         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START)       , start, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1446         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET)      , target, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1447         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION)   , Property::Value( direction ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1448         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION)    , Property::Value( duration ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1449         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY)       , Property::Value( delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1450         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT)      , Property::Value( loop_count ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1451         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value( repeat_delay ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1452         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE) , Property::Value( motion ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1453         DALI_TEST_EQUALS( checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE) , Property::Value( easing ), Math::MACHINE_EPSILON_100, TEST_LOCATION );
1454       };
1455
1456       // check the animation map data is good
1457       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1        , start2        , __LINE__);
1458       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION  , end1          , end2          , __LINE__);
1459       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR   , start_color1  , start_color2  , __LINE__);
1460       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR     , end_color1    , end_color2    , __LINE__);
1461       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER , rotate_center1, rotate_center2, __LINE__);
1462       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT , rotate_amount1, rotate_amount2, __LINE__);
1463       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET        , offset1       , offset2       , __LINE__);
1464     }
1465   }
1466
1467   END_TEST;
1468 }
1469 int UtcDaliVisualGetPropertyMap13(void)
1470 {
1471   ToolkitTestApplication application;
1472   tet_infoline( "UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0" );
1473
1474   for(int _direction = 0; _direction <= 1; ++_direction)
1475   {
1476     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1477     {
1478       tet_printf( ((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n") , _delay );
1479       VisualFactory factory = VisualFactory::Get();
1480       DALI_TEST_CHECK( factory );
1481
1482       Property::Map propertyMap;
1483       Property::Map animationMap;
1484       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1485
1486       float duration = 1.0f;
1487       float delay = _delay;
1488       float repeat_delay = 0.5f;
1489
1490       int direction = _direction;
1491       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1492       int motion = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1493       int easing = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1494
1495       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value &start, const Property::Value &target)->Property::Map&
1496       {
1497         animationMap.Clear();
1498         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1499         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1500         if(direction == 0)animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1501         else animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1502         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1503         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1504         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1505         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1506         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1507         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1508         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1509
1510         return animationMap;
1511       };
1512
1513       Vector2 start1(-0.5f, 0.5f);
1514       Vector2 end1  (0.5f, -0.5f);
1515       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1516       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
1517       Vector2 rotate_center1(1.0f, 0.4f);
1518       float rotate_amount1 = 2.0f;
1519       float offset1 = 1.f;
1520
1521       Vector2 start2(-0.5f, -0.5f);
1522       Vector2 end2  (0.5f, 0.5f);
1523       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1524       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
1525       Vector2 rotate_center2(1.0f, -0.4f);
1526       float rotate_amount2 = 1.0f;
1527       float offset2 = 3.f;
1528
1529       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  DevelAnimatedGradientVisual::GradientType::LINEAR);
1530       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,  DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1531       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  DevelAnimatedGradientVisual::SpreadType::REFLECT);
1532
1533       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ));
1534       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ));
1535       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ));
1536       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ));
1537       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2));
1538       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2));
1539       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ));
1540
1541       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1542       DALI_TEST_CHECK( animatedGradientVisual );
1543
1544       Property::Map resultMap;
1545       animatedGradientVisual.CreatePropertyMap( resultMap );
1546
1547       // check the property values from the returned map from visual
1548       Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE,  Property::INTEGER );
1549       DALI_TEST_CHECK( value );
1550       DALI_TEST_CHECK( value->Get<int>() == DevelVisual::ANIMATED_GRADIENT );
1551
1552       value = resultMap.Find( DevelAnimatedGradientVisual::Property::GRADIENT_TYPE,  Property::INTEGER );
1553       DALI_TEST_CHECK( value );
1554       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR );
1555
1556       value = resultMap.Find( DevelAnimatedGradientVisual::Property::UNIT_TYPE,  Property::INTEGER );
1557       DALI_TEST_CHECK( value );
1558       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX );
1559
1560       value = resultMap.Find( DevelAnimatedGradientVisual::Property::SPREAD_TYPE,  Property::INTEGER );
1561       DALI_TEST_CHECK( value );
1562       DALI_TEST_CHECK( value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT );
1563
1564       // If loop_count = 0, Animation doesn't created.
1565       // Optimized resultMap only have one value, which is target value
1566       // Note: target value will be changed by direction option.
1567       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_POSITION,  Property::VECTOR2 );
1568       DALI_TEST_CHECK( value );
1569       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? start1 : start2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1570
1571       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_POSITION,  Property::VECTOR2 );
1572       DALI_TEST_CHECK( value );
1573       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? end1 : end2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1574
1575       value = resultMap.Find( DevelAnimatedGradientVisual::Property::START_COLOR,  Property::VECTOR4 );
1576       DALI_TEST_CHECK( value );
1577       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? start_color1 : start_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1578
1579       value = resultMap.Find( DevelAnimatedGradientVisual::Property::END_COLOR,  Property::VECTOR4 );
1580       DALI_TEST_CHECK( value );
1581       DALI_TEST_EQUALS( value->Get<Vector4>(), direction ? end_color1 : end_color2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1582
1583       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  Property::VECTOR2 );
1584       DALI_TEST_CHECK( value );
1585       DALI_TEST_EQUALS( value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1586
1587       value = resultMap.Find( DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  Property::FLOAT );
1588       DALI_TEST_CHECK( value );
1589       DALI_TEST_EQUALS( value->Get<float>(), direction ? rotate_amount1 : rotate_amount2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1590
1591       value = resultMap.Find( DevelAnimatedGradientVisual::Property::OFFSET,  Property::FLOAT );
1592       DALI_TEST_CHECK( value );
1593       DALI_TEST_EQUALS( value->Get<float>(), direction ? offset1 : offset2 , Math::MACHINE_EPSILON_100, TEST_LOCATION );
1594     }
1595   }
1596
1597   END_TEST;
1598 }
1599
1600 int UtcDaliVisualAnimateBorderVisual01(void)
1601 {
1602   ToolkitTestApplication application;
1603   tet_infoline( "UtcDaliAnimateBorderVisual Color" );
1604
1605   VisualFactory factory = VisualFactory::Get();
1606   Property::Map propertyMap;
1607   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1608   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1609   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1610   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1611   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1612
1613   Property::Map map;
1614   map["target"] = "testVisual";
1615   map["property"] = "mixColor";
1616   map["targetValue"] = Vector4(1,1,1,0);
1617   map["animator"] = Property::Map()
1618     .Add("alphaFunction", "LINEAR")
1619     .Add("timePeriod", Property::Map()
1620          .Add("delay", 0.0f)
1621          .Add("duration", 4.0f));
1622
1623   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1624
1625   DummyControl actor = DummyControl::New(true);
1626   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1627   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1628   actor.SetSize(2000, 2000);
1629   actor.SetParentOrigin(ParentOrigin::CENTER);
1630   Stage::GetCurrent().Add(actor);
1631
1632   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1633
1634   Renderer renderer = actor.GetRendererAt(0);
1635   Property::Index borderColorIndex = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::COLOR );
1636   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, Visual::Property::MIX_COLOR );
1637
1638   Animation animation = dummyImpl.CreateTransition( transition );
1639
1640   // Animate the mix color through the transition, and the border color through
1641   // programmatic method.
1642   animation.AnimateTo( Property(renderer, borderColorIndex), Color::WHITE );
1643   animation.Play();
1644
1645   application.SendNotification();
1646   application.Render(0);
1647   application.Render(2000u); // halfway point between blue and white
1648
1649   Vector4 color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1650   Vector4 testColor = (Color::BLUE + Color::WHITE)*0.5f;
1651   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1652   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor ), true, TEST_LOCATION );
1653
1654   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1655   testColor = Vector4( 1,1,1,0.4f );
1656   DALI_TEST_EQUALS( Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION );
1657   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1658   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ) , true, TEST_LOCATION );
1659
1660   application.Render(2000u);
1661
1662   color = renderer.GetCurrentProperty< Vector4 >( borderColorIndex );
1663   DALI_TEST_EQUALS( color, Color::WHITE, TEST_LOCATION );
1664   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE ), true, TEST_LOCATION );
1665
1666   color = renderer.GetCurrentProperty< Vector4 >( mixColorIndex );
1667   testColor = Vector4(1,1,1,0);
1668   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1669   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor) ), true, TEST_LOCATION );
1670   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", testColor.a ), true, TEST_LOCATION );
1671
1672   END_TEST;
1673 }
1674
1675
1676 int UtcDaliVisualAnimateBorderVisual02(void)
1677 {
1678   ToolkitTestApplication application;
1679   tet_infoline( "UtcDaliAnimateBorderVisual Size" );
1680
1681   VisualFactory factory = VisualFactory::Get();
1682   Property::Map propertyMap;
1683   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
1684   propertyMap.Insert(BorderVisual::Property::COLOR,  Color::BLUE);
1685   propertyMap.Insert(BorderVisual::Property::SIZE,  5.f);
1686   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1687
1688   DummyControl actor = DummyControl::New(true);
1689   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1690   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1691   actor.SetSize(2000, 2000);
1692   actor.SetParentOrigin(ParentOrigin::CENTER);
1693   Stage::GetCurrent().Add(actor);
1694
1695   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1696
1697   Renderer renderer = actor.GetRendererAt(0);
1698   Property::Index index = DevelHandle::GetPropertyIndex( renderer, BorderVisual::Property::SIZE );
1699
1700   Animation animation = Animation::New(4.0f);
1701   animation.AnimateTo( Property(renderer, index), 9.0f );
1702   animation.Play();
1703
1704   application.SendNotification();
1705   application.Render(0);
1706   application.Render(2000u); // halfway point
1707
1708   float size = renderer.GetCurrentProperty< float >( index );
1709   DALI_TEST_EQUALS( size, 7.0f, 0.0001f, TEST_LOCATION );
1710   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f ), true, TEST_LOCATION );
1711
1712   application.Render(2000u); // halfway point between blue and white
1713
1714   size = renderer.GetCurrentProperty< float >( index );
1715   DALI_TEST_EQUALS( size, 9.0f, 0.0001f, TEST_LOCATION );
1716   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f ), true, TEST_LOCATION );
1717
1718   END_TEST;
1719 }
1720
1721 int UtcDaliVisualAnimateColorVisual(void)
1722 {
1723   ToolkitTestApplication application;
1724   tet_infoline( "UtcDaliAnimateColorVisual mixColor" );
1725
1726   VisualFactory factory = VisualFactory::Get();
1727   Property::Map propertyMap;
1728   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
1729   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1730   Visual::Base borderVisual = factory.CreateVisual( propertyMap );
1731
1732   DummyControl actor = DummyControl::New(true);
1733   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1734   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
1735   actor.SetSize(2000, 2000);
1736   actor.SetParentOrigin(ParentOrigin::CENTER);
1737   Stage::GetCurrent().Add(actor);
1738
1739   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1740
1741   Renderer renderer = actor.GetRendererAt(0);
1742   Property::Index mixColorIndex = DevelHandle::GetPropertyIndex( renderer, ColorVisual::Property::MIX_COLOR );
1743
1744   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1745   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1746
1747   Animation animation = Animation::New(4.0f);
1748   animation.AnimateTo( Property(renderer, mixColorIndex), Vector3(Color::WHITE) );
1749   animation.Play();
1750
1751   application.SendNotification();
1752   application.Render(0);
1753   application.Render(2000u); // halfway point
1754
1755   Vector3 color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1756   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE)*0.5f;
1757   DALI_TEST_EQUALS( color, testColor, TEST_LOCATION );
1758
1759   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor ), true, TEST_LOCATION );
1760
1761   application.Render(2000u); // halfway point between blue and white
1762
1763   color = renderer.GetCurrentProperty< Vector3 >( mixColorIndex );
1764   DALI_TEST_EQUALS( color, Vector3(Color::WHITE), TEST_LOCATION );
1765
1766   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE) ), true, TEST_LOCATION );
1767
1768   blendModeValue = renderer.GetCurrentProperty( Renderer::Property::BLEND_MODE );
1769   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1770
1771   END_TEST;
1772 }
1773
1774 int UtcDaliVisualAnimatePrimitiveVisual(void)
1775 {
1776   ToolkitTestApplication application;
1777   tet_infoline( "UtcDaliAnimatePrimitiveVisual color" );
1778
1779   {
1780     VisualFactory factory = VisualFactory::Get();
1781     Property::Map propertyMap;
1782     propertyMap.Insert(Visual::Property::TYPE,  Visual::PRIMITIVE);
1783     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1784     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
1785     Visual::Base visual = factory.CreateVisual( propertyMap );
1786
1787     DummyControl actor = DummyControl::New(true);
1788     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1789     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1790     actor.SetSize(2000, 2000);
1791     actor.SetParentOrigin(ParentOrigin::CENTER);
1792     actor.SetColor(Color::BLACK);
1793     Stage::GetCurrent().Add(actor);
1794
1795     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1796
1797     Renderer renderer = actor.GetRendererAt(0);
1798     Property::Index index = DevelHandle::GetPropertyIndex( renderer, PrimitiveVisual::Property::MIX_COLOR );
1799
1800     tet_infoline("Test that the renderer has the Primitive mix color");
1801     DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1802
1803     const Vector4 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f,0.5f ); // Magenta with half alpha
1804     const Vector4 TARGET_MIX_COLOR( Color::RED );
1805
1806     Property::Map map;
1807     map["target"] = "testVisual";
1808     map["property"] = "mixColor";
1809     map["initialValue"] = INITIAL_MIX_COLOR;
1810     map["targetValue"] = TARGET_MIX_COLOR;
1811     map["animator"] = Property::Map()
1812       .Add("alphaFunction", "LINEAR")
1813       .Add("timePeriod", Property::Map()
1814            .Add("delay", 0.0f)
1815            .Add("duration", 4.0f));
1816
1817     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1818
1819     Animation animation = dummyImpl.CreateTransition( transition );
1820     Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1821     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON, TEST_LOCATION );
1822
1823     animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1824     animation.Play();
1825
1826     application.SendNotification();
1827     application.Render(0);
1828     application.Render(2000u); // halfway point
1829     application.SendNotification();
1830
1831     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 1.0f )), true, TEST_LOCATION );
1832
1833     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR)*0.5;
1834     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor) ), true, TEST_LOCATION );
1835     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", halfwayColor.a ), true, TEST_LOCATION );
1836
1837     application.Render(2001u); // go past end
1838     application.SendNotification(); // Trigger signals
1839
1840     DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
1841     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Color::WHITE ), true, TEST_LOCATION );
1842     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR) ), true, TEST_LOCATION );
1843     DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>("opacity", TARGET_MIX_COLOR.a ), true, TEST_LOCATION );
1844
1845     blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1846     DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1847
1848     actor.Unparent();
1849   }
1850
1851   END_TEST;
1852 }
1853
1854 int UtcDaliVisualAnimatedGradientVisual01(void)
1855 {
1856   ToolkitTestApplication application;
1857   tet_infoline( "UtcDaliAnimatedGradientVisual with default" );
1858
1859   {
1860     VisualFactory factory = VisualFactory::Get();
1861     Property::Map propertyMap;
1862     propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1863     Visual::Base visual = factory.CreateVisual( propertyMap );
1864
1865     DummyControl actor = DummyControl::New(true);
1866     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1867     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1868     actor.SetSize(2000, 2000);
1869     actor.SetParentOrigin(ParentOrigin::CENTER);
1870     actor.SetColor(Color::BLACK);
1871     Stage::GetCurrent().Add(actor);
1872
1873     application.SendNotification();
1874     application.Render(0);
1875     application.SendNotification();
1876
1877     DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1878
1879     for(int step_iter = 0; step_iter < 3; step_iter++)
1880     {
1881       application.SendNotification();
1882       application.Render(0);
1883       application.Render(750u); // step i/4
1884       application.SendNotification();
1885
1886       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "start_point"  , Vector2( -0.5f, 0.0f ) ), true, TEST_LOCATION );
1887       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "end_point"    , Vector2( 0.5f, 0.0f ) ), true, TEST_LOCATION );
1888       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "start_color"  , Vector4( 143.0f, 170.0f, 220.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1889       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "end_color"    , Vector4( 255.0f, 163.0f, 163.0f, 255.0f ) / 255.0f ), true, TEST_LOCATION );
1890       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector2>( "rotate_center", Vector2( 0.0f, 0.0f ) ), true, TEST_LOCATION );
1891       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "rotate_angle"   , 0.0f ), true, TEST_LOCATION );
1892       DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<float>( "gradient_offset", 0.5f * step_iter + 0.5f ), true, TEST_LOCATION );
1893     }
1894
1895     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
1896     application.Render(750u); // go to end
1897     application.SendNotification();
1898
1899     application.Render(10u); // finish
1900     application.SendNotification();
1901
1902     actor.Unparent();
1903     application.SendNotification();
1904     application.Render(0u);
1905     application.SendNotification();
1906   }
1907
1908   END_TEST;
1909 }
1910
1911 int UtcDaliVisualAnimatedGradientVisual02(void)
1912 {
1913   ToolkitTestApplication application;
1914   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option" );
1915
1916   {
1917     float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
1918     int _direction[2] = {0, 1};
1919     int _loop_count[3] = {-1, 0, 1};
1920     int _motion[2] = {0, 1};
1921     int _easing[4] = {0, 1, 2, 3};
1922
1923     int test_case_max = 4 * 2 * 3 * 2 * 4;
1924     int test_case = 0;
1925     int test_case_d = 7; // 7 is the number of animated properties.
1926
1927     float _duration = 0.4f;
1928     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
1929     float noise_maker = 0.0f;
1930     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
1931     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
1932     {
1933       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
1934
1935       VisualFactory factory = VisualFactory::Get();
1936       Property::Map propertyMap;
1937       Property::Map animationMap;
1938       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
1939
1940       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
1941       int unit_type = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
1942       int spread_type = DevelAnimatedGradientVisual::SpreadType::REPEAT;
1943
1944       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value &start, const Property::Value &target, int tc_offset)->Property::Map&
1945       {
1946         int tc = (test_case + tc_offset);
1947         int idx_easing = tc % 4; tc /= 4;
1948         int idx_motion = tc % 2; tc /= 2;
1949         int idx_loop_count = tc % 3; tc /= 3;
1950         int idx_direction = tc % 2; tc /= 2;
1951         int idx_delay = tc % 4; tc /= 4;
1952
1953         float duration = _duration - _repeat_delay;
1954         float repeat_delay = _repeat_delay;
1955         float delay = _delay[idx_delay] * _duration;
1956         int direction = _direction[idx_direction];
1957         int loop_count = _loop_count[idx_loop_count];
1958         int motion = _motion[idx_motion];
1959         int easing = _easing[idx_easing];
1960
1961         animationMap.Clear();
1962         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::START, start );
1963         animationMap.Insert( DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target );
1964         if( direction == 0 )
1965         {
1966           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1967         }
1968         else
1969         {
1970           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1971         }
1972         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1973         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1974         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1975         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1976         if( motion == 0 )
1977         {
1978           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
1979         }
1980         else
1981         {
1982           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
1983         }
1984         if( easing == 0 )
1985         {
1986           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
1987         }
1988         else if( easing == 1 )
1989         {
1990           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
1991         }
1992         else if( easing == 2 )
1993         {
1994           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
1995         }
1996         else
1997         {
1998           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
1999         }
2000
2001         return animationMap;
2002       };
2003
2004       // Give different values for debuging
2005       noise_maker += 1.0f;
2006       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2007       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2008       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2009       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2010       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2011       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2012       float offset1 = 0.f + noise_maker * 0.1f;
2013
2014       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2015       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2016       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2017       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2018       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2019       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2020       float offset2 = 2.f + noise_maker * 0.1f;
2021
2022       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2023       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE,     unit_type);
2024       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE,   spread_type);
2025
2026       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1        , start2        ,0));
2027       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION,   buildAnimatedMap(end1          , end2          ,1));
2028       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR,    buildAnimatedMap(start_color1  , start_color2  ,2));
2029       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR,      buildAnimatedMap(end_color1    , end_color2    ,3));
2030       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER,  buildAnimatedMap(rotate_center1, rotate_center2,4));
2031       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT,  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2032       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET,         buildAnimatedMap(offset1       , offset2       ,6));
2033
2034       Visual::Base visual = factory.CreateVisual( propertyMap );
2035
2036       DummyControl actor = DummyControl::New( true );
2037       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2038       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2039       actor.SetSize( 2000, 2000 );
2040       actor.SetParentOrigin(ParentOrigin::CENTER);
2041       actor.SetColor(Color::BLACK);
2042       Stage::GetCurrent().Add(actor);
2043
2044       application.SendNotification();
2045       application.Render( 0 );
2046       application.SendNotification();
2047
2048       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2049
2050       application.SendNotification();
2051
2052       //Compare between CPU calculated value and Shader Visual calculated value
2053       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress)->void
2054       {
2055         int tc = (test_case + tc_offset);
2056         int idx_easing = tc % 4; tc /= 4;
2057         int idx_motion = tc % 2; tc /= 2;
2058         int idx_loop_count = tc % 3; tc /= 3;
2059         int idx_direction = tc % 2; tc /= 2;
2060         int idx_delay = tc % 4; tc /= 4;
2061
2062         float duration = _duration - _repeat_delay;
2063         float repeat_delay = _repeat_delay;
2064         float delay = _delay[idx_delay] * _duration;
2065         int direction = _direction[idx_direction];
2066         int loop_count = _loop_count[idx_loop_count];
2067         int motion = _motion[idx_motion];
2068         int easing = _easing[idx_easing];
2069
2070         progress -= delay / _duration;
2071
2072         Property::Value s = start;
2073         Property::Value t = target;
2074         if( direction == 1 )
2075         {
2076           s = target;
2077           t = start;
2078         }
2079         float x; ///< Animator progress value
2080         if( loop_count == 0 )
2081         {
2082           x = 1.0f;
2083         }
2084         else if( loop_count > 0 && progress + 0.01f > loop_count )
2085         {
2086           x = ( motion == 0 ) ? 1.0f : 0.0f;
2087         }
2088         else
2089         {
2090           if( progress < 0.0f )
2091           {
2092             progress = 0.0f;
2093           }
2094           progress = fmodf( progress, 1.0f );
2095           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2096
2097           x = progress;
2098           if( motion == 1 )
2099           {
2100             x = progress * 2.0f;
2101             if( x > 1.0f )
2102             {
2103               x = 2.0f - x;
2104             }
2105           }
2106
2107           if( easing == 1 ) // EASE_IN
2108           {
2109             x = x*x;
2110           }
2111           else if( easing == 2 ) // EASE_OUT
2112           {
2113             x = 2.0f*x - x*x;
2114           }
2115           else if( easing == 3 ) // EASE_IN_OUT
2116           {
2117             x = x * x * (3.0f - 2.0f * x);
2118           }
2119         }
2120         if( value_type == 0 ) // result type is Float
2121         {
2122           float res;
2123           float cur;
2124           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2125           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2126           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2127         }
2128         else if( value_type == 1 ) // result type is Vector2
2129         {
2130           Vector2 res;
2131           Vector2 cur;
2132           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2133           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2134           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2135         }
2136         else if( value_type == 2 ) // result type is Vector3
2137         {
2138           Vector3 res;
2139           Vector3 cur;
2140           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2141           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2142           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2143         }
2144         else // result type is Vector4
2145         {
2146           Vector4 res;
2147           Vector4 cur;
2148           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2149           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2150           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2151         }
2152       };
2153
2154       float step = 0.0f;
2155       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2156       {
2157         for( int step_iter = 0; step_iter < 3; step_iter++ )
2158         {
2159           application.SendNotification();
2160           application.Render( _duration * 250.f );  // step i/4
2161           application.SendNotification();
2162           step += 0.25f;
2163
2164           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2165           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2166           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2167           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2168           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2169           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2170           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2171         }
2172         application.SendNotification();
2173         application.Render(_duration * 250.f);  // step 4/4 will not test
2174         application.SendNotification();
2175         step += 0.25f;
2176       }
2177
2178       application.SendNotification();
2179       actor.Unparent();
2180       application.SendNotification();
2181       application.Render(10.f);  // tempral time
2182       application.SendNotification();
2183     }
2184   }
2185
2186   END_TEST;
2187 }
2188
2189 int UtcDaliVisualAnimatedGradientVisual03(void)
2190 {
2191   ToolkitTestApplication application;
2192   tet_infoline( "UtcDaliAnimatedGradientVisual with full-option use string key" );
2193
2194   {
2195     float _delay[4] = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2196     int _direction[2] = {0, 1};
2197     int _loop_count[3] = {-1, 0, 1};
2198     int _motion[2] = {0, 1};
2199     int _easing[4] = {0, 1, 2, 3};
2200
2201     int test_case_max = 4 * 2 * 3 * 2 * 4;
2202     int test_case = 0;
2203     int test_case_d = 7; // 7 is the number of animated properties.
2204
2205     float _duration = 0.4f;
2206     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2207     float noise_maker = 0.2f;
2208     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2209     for( test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d )
2210     {
2211       tet_printf( "test [%d ~ %d / %d]\n" , test_case, test_case + test_case_d - 1, test_case_max);
2212
2213       VisualFactory factory = VisualFactory::Get();
2214       Property::Map propertyMap;
2215       Property::Map animationMap;
2216       propertyMap.Insert(Visual::Property::TYPE,  DevelVisual::ANIMATED_GRADIENT);
2217
2218       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value &start, const Property::Value &target, int tc_offset)->Property::Map&
2219       {
2220         int tc = (test_case + tc_offset);
2221         int idx_easing = tc % 4; tc /= 4;
2222         int idx_motion = tc % 2; tc /= 2;
2223         int idx_loop_count = tc % 3; tc /= 3;
2224         int idx_direction = tc % 2; tc /= 2;
2225         int idx_delay = tc % 4; tc /= 4;
2226
2227         float duration = _duration - _repeat_delay;
2228         float repeat_delay = _repeat_delay;
2229         float delay = _delay[idx_delay] * _duration;
2230         int direction = _direction[idx_direction];
2231         int loop_count = _loop_count[idx_loop_count];
2232         int motion = _motion[idx_motion];
2233         int easing = _easing[idx_easing];
2234
2235         animationMap.Clear();
2236         animationMap.Insert( "startValue", start );
2237         animationMap.Insert( "targetValue", target );
2238         if( direction == 0 )
2239         {
2240           animationMap.Insert("directionType", "FORWARD");
2241         }
2242         else
2243         {
2244           animationMap.Insert("directionType", "BACKWARD");
2245         }
2246         animationMap.Insert("duration", duration);
2247         animationMap.Insert("delay", delay);
2248         animationMap.Insert("repeat", loop_count);
2249         animationMap.Insert("repeatDelay", repeat_delay);
2250         if( motion == 0 )
2251         {
2252           animationMap.Insert("motionType", "LOOP");
2253         }
2254         else
2255         {
2256           animationMap.Insert("motionType", "MIRROR");
2257         }
2258         if( easing == 0 )
2259         {
2260           animationMap.Insert("easingType", "LINEAR");
2261         }
2262         else if( easing == 1 )
2263         {
2264           animationMap.Insert("easingType", "IN");
2265         }
2266         else if( easing == 2 )
2267         {
2268           animationMap.Insert("easingType", "OUT");
2269         }
2270         else
2271         {
2272           animationMap.Insert("easingType", "IN_OUT");
2273         }
2274
2275         return animationMap;
2276       };
2277
2278       // Give different values for debuging
2279       noise_maker += 0.8f;
2280       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2281       Vector2 end1  (0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2282       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2283       Vector4 end_color1  (0.7f, 0.5f, 1.0f, 1.0f);
2284       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2285       float rotate_amount1 = 0.0f + noise_maker * 0.1f;
2286       float offset1 = 0.f + noise_maker * 0.1f;
2287
2288       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2289       Vector2 end2  (0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2290       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2291       Vector4 end_color2  (0.3f, 1.0f, 0.1f, 0.0f);
2292       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2293       float rotate_amount2 = 7.0f + noise_maker * 0.1f;
2294       float offset2 = 2.f + noise_maker * 0.1f;
2295
2296       propertyMap.Insert("gradientType", "LINEAR");
2297       propertyMap.Insert("unitType",     "USER_SPACE");
2298       propertyMap.Insert("spreadType",   "CLAMP");
2299
2300       propertyMap.Insert("startPosition", buildAnimatedMap(start1        , start2        ,0));
2301       propertyMap.Insert("endPosition",   buildAnimatedMap(end1          , end2          ,1));
2302       propertyMap.Insert("startColor",    buildAnimatedMap(start_color1  , start_color2  ,2));
2303       propertyMap.Insert("endColor",      buildAnimatedMap(end_color1    , end_color2    ,3));
2304       propertyMap.Insert("rotateCenter",  buildAnimatedMap(rotate_center1, rotate_center2,4));
2305       propertyMap.Insert("rotateAmount",  buildAnimatedMap(rotate_amount1, rotate_amount2,5));
2306       propertyMap.Insert("offset",        buildAnimatedMap(offset1       , offset2       ,6));
2307
2308       Visual::Base visual = factory.CreateVisual( propertyMap );
2309
2310       DummyControl actor = DummyControl::New( true );
2311       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( actor.GetImplementation() );
2312       dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2313       actor.SetSize( 2000, 2000 );
2314       actor.SetParentOrigin(ParentOrigin::CENTER);
2315       actor.SetColor(Color::BLACK);
2316       Stage::GetCurrent().Add(actor);
2317
2318       application.SendNotification();
2319       application.Render( 0 );
2320       application.SendNotification();
2321
2322       DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
2323
2324       application.SendNotification();
2325
2326       //Compare between CPU calculated value and Shader Visual calculated value
2327       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress)->void
2328       {
2329         int tc = (test_case + tc_offset);
2330         int idx_easing = tc % 4; tc /= 4;
2331         int idx_motion = tc % 2; tc /= 2;
2332         int idx_loop_count = tc % 3; tc /= 3;
2333         int idx_direction = tc % 2; tc /= 2;
2334         int idx_delay = tc % 4; tc /= 4;
2335
2336         float duration = _duration - _repeat_delay;
2337         float repeat_delay = _repeat_delay;
2338         float delay = _delay[idx_delay] * _duration;
2339         int direction = _direction[idx_direction];
2340         int loop_count = _loop_count[idx_loop_count];
2341         int motion = _motion[idx_motion];
2342         int easing = _easing[idx_easing];
2343
2344         progress -= delay / _duration;
2345
2346         Property::Value s = start;
2347         Property::Value t = target;
2348         if( direction == 1 )
2349         {
2350           s = target;
2351           t = start;
2352         }
2353         float x; ///< Animator progress value
2354         if( loop_count == 0 )
2355         {
2356           x = 1.0f;
2357         }
2358         else if( loop_count > 0 && progress + 0.01f > loop_count )
2359         {
2360           x = ( motion == 0 ) ? 1.0f : 0.0f;
2361         }
2362         else
2363         {
2364           if( progress < 0.0f )
2365           {
2366             progress = 0.0f;
2367           }
2368           progress = fmodf( progress, 1.0f );
2369           progress = Dali::Clamp( (progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f );
2370
2371           x = progress;
2372           if( motion == 1 )
2373           {
2374             x = progress * 2.0f;
2375             if( x > 1.0f )
2376             {
2377               x = 2.0f - x;
2378             }
2379           }
2380
2381           if( easing == 1 ) // EASE_IN
2382           {
2383             x = x*x;
2384           }
2385           else if( easing == 2 ) // EASE_OUT
2386           {
2387             x = 2.0f*x - x*x;
2388           }
2389           else if( easing == 3 ) // EASE_IN_OUT
2390           {
2391             x = x * x * (3.0f - 2.0f * x);
2392           }
2393         }
2394         if( value_type == 0 ) // result type is Float
2395         {
2396           float res;
2397           float cur;
2398           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2399           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION );
2400           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2401         }
2402         else if( value_type == 1 ) // result type is Vector2
2403         {
2404           Vector2 res;
2405           Vector2 cur;
2406           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2407           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION );
2408           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2409         }
2410         else if( value_type == 2 ) // result type is Vector3
2411         {
2412           Vector3 res;
2413           Vector3 cur;
2414           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2415           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION );
2416           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2417         }
2418         else // result type is Vector4
2419         {
2420           Vector4 res;
2421           Vector4 cur;
2422           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2423           DALI_TEST_EQUALS( application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION );
2424           DALI_TEST_EQUALS( res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2425         }
2426       };
2427
2428       float step = 0.0f;
2429       for( int iter = 0; iter < 2; iter++ ) // test 2*duration seconds
2430       {
2431         for( int step_iter = 0; step_iter < 3; step_iter++ )
2432         {
2433           application.SendNotification();
2434           application.Render( _duration * 250.f );  // step i/4
2435           application.SendNotification();
2436           step += 0.25f;
2437
2438           testProperty( "start_point"    , Property::Value( start1 )        , Property::Value( start2 )        , 0, 1, step );
2439           testProperty( "end_point"      , Property::Value( end1 )          , Property::Value( end2 )          , 1, 1, step );
2440           testProperty( "start_color"    , Property::Value( start_color1 )  , Property::Value( start_color2 )  , 2, 3, step );
2441           testProperty( "end_color"      , Property::Value( end_color1 )    , Property::Value( end_color2 )    , 3, 3, step );
2442           testProperty( "rotate_center"  , Property::Value( rotate_center1 ), Property::Value( rotate_center2 ), 4, 1, step );
2443           testProperty( "rotate_angle"   , Property::Value( rotate_amount1 ), Property::Value( rotate_amount2 ), 5, 0, step );
2444           testProperty( "gradient_offset", Property::Value( offset1 )       , Property::Value( offset2 )       , 6, 0, step );
2445         }
2446         application.SendNotification();
2447         application.Render(_duration * 250.f);  // step 4/4 will not test
2448         application.SendNotification();
2449         step += 0.25f;
2450       }
2451
2452       application.SendNotification();
2453       actor.Unparent();
2454       application.SendNotification();
2455       application.Render(10.f);  // tempral time
2456       application.SendNotification();
2457     }
2458   }
2459
2460   END_TEST;
2461 }
2462
2463 int UtcDaliVisualWireframeVisual(void)
2464 {
2465   ToolkitTestApplication application;
2466
2467   VisualFactory factory = VisualFactory::Get();
2468   Property::Map propertyMap;
2469   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::WIREFRAME );
2470
2471   // Create the visual.
2472   Visual::Base visual = factory.CreateVisual( propertyMap );
2473
2474   DALI_TEST_CHECK( visual );
2475
2476   Property::Map resultMap;
2477   visual.CreatePropertyMap( resultMap );
2478
2479   // Check the property values from the returned map from visual
2480   Property::Value* value = resultMap.Find( Toolkit::Visual::Property::TYPE, Property::INTEGER );
2481   DALI_TEST_CHECK( value );
2482   DALI_TEST_CHECK( value->Get<int>() == Visual::WIREFRAME );
2483
2484   END_TEST;
2485 }
2486
2487 int UtcDaliVisualGetTransform(void)
2488 {
2489   ToolkitTestApplication application;
2490   tet_infoline( "UtcDaliVisualGetTransform: ColorVisual" );
2491
2492   VisualFactory factory = VisualFactory::Get();
2493   Property::Map propertyMap;
2494   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2495   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2496   Visual::Base colorVisual = factory.CreateVisual( propertyMap );
2497
2498   Dali::Property::Map visualMap;
2499   colorVisual.CreatePropertyMap( visualMap );
2500   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2501   Dali::Property::Map* map = value->GetMap();
2502   DALI_TEST_CHECK( map );
2503
2504   //Test default values
2505   {
2506     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2507     DALI_TEST_CHECK( typeValue );
2508     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(0.0f,0.0f) );
2509   }
2510   {
2511     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2512     DALI_TEST_CHECK( typeValue );
2513     DALI_TEST_CHECK( typeValue->Get<Vector2>() == Vector2(1.0f,1.0f) );
2514   }
2515   {
2516     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2517     DALI_TEST_CHECK( typeValue );
2518     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2519   }
2520   {
2521     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2522     DALI_TEST_CHECK( typeValue );
2523     DALI_TEST_CHECK( typeValue->Get< Vector2 >() == Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
2524   }
2525   {
2526     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2527     DALI_TEST_CHECK( typeValue );
2528     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2529   }
2530   {
2531     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2532     DALI_TEST_CHECK( typeValue );
2533     DALI_TEST_CHECK( (Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN );
2534   }
2535
2536   END_TEST;
2537 }
2538
2539 static void TestTransform( ToolkitTestApplication& application, Visual::Base visual )
2540 {
2541   Property::Map transform;
2542   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f) );
2543   transform.Insert( Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f) );
2544   transform.Insert( Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2545   transform.Insert( Visual::Transform::Property::ORIGIN, "CENTER" );
2546   transform.Insert( Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END );
2547
2548   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2549
2550   Dali::Property::Map visualMap;
2551   visual.CreatePropertyMap( visualMap );
2552   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2553   Dali::Property::Map* map = value->GetMap();
2554   DALI_TEST_CHECK( map );
2555
2556   {
2557     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET );
2558     DALI_TEST_CHECK( typeValue );
2559     DALI_TEST_EQUALS( typeValue->Get<Vector2>(),Vector2(10.0f,10.0f), TEST_LOCATION );
2560   }
2561   {
2562     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE );
2563     DALI_TEST_CHECK( typeValue );
2564     DALI_TEST_EQUALS( typeValue->Get<Vector2>(), Vector2(0.2f,0.2f), TEST_LOCATION );
2565   }
2566   {
2567     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2568     DALI_TEST_CHECK( typeValue );
2569     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2570   }
2571   {
2572     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2573     DALI_TEST_CHECK( typeValue );
2574     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2575   }
2576   {
2577     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ORIGIN );
2578     DALI_TEST_CHECK( typeValue );
2579     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION );
2580   }
2581   {
2582     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::ANCHOR_POINT );
2583     DALI_TEST_CHECK( typeValue );
2584     DALI_TEST_EQUALS( (Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION );
2585   }
2586
2587   //Put the visual on the stage
2588   DummyControl actor = DummyControl::New(true);
2589   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2590   actor.SetSize(2000, 2000);
2591   actor.SetParentOrigin(ParentOrigin::CENTER);
2592   Stage::GetCurrent().Add(actor);
2593
2594   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2595   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transform );
2596
2597   application.SendNotification();
2598   application.Render(0);
2599   Renderer renderer( actor.GetRendererAt(0) );
2600
2601   //Check that the properties have been registered on the Renderer
2602   Property::Index index = renderer.GetPropertyIndex( "offset" );
2603   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2604   Vector2 offset = renderer.GetProperty<Vector2>( index );
2605   DALI_TEST_EQUALS( offset, Vector2(10.0f,10.0f), TEST_LOCATION );
2606
2607   index = renderer.GetPropertyIndex( "size" );
2608   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2609   Vector2 size = renderer.GetProperty<Vector2>( index );
2610   DALI_TEST_EQUALS( size, Vector2(0.2f,0.2f), TEST_LOCATION );
2611
2612   index = renderer.GetPropertyIndex( "offsetSizeMode" );
2613   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2614   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>( index );
2615   DALI_TEST_EQUALS( offsetSizeMode, Vector4(1.0f,1.0f,0.0f,0.0f), TEST_LOCATION );
2616
2617   index = renderer.GetPropertyIndex( "origin" );
2618   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2619   Vector2 parentOrigin = renderer.GetProperty<Vector2>( index );
2620   DALI_TEST_EQUALS( parentOrigin, Vector2(0.0f,0.0f), TEST_LOCATION );
2621
2622   index = renderer.GetPropertyIndex( "anchorPoint" );
2623   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
2624   Vector2 anchorPoint = renderer.GetProperty<Vector2>( index );
2625   DALI_TEST_EQUALS( anchorPoint, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2626
2627   //Set a new transform
2628   transform.Clear();
2629   transform = DefaultTransform();
2630   transform.Insert( Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f) );
2631   transform.Insert( Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f) );
2632   transform.Insert( Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) );
2633   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2634   application.SendNotification();
2635   application.Render(0);
2636
2637   //Check that the values have changed in the renderer
2638   offset = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "offset" ) );
2639   DALI_TEST_EQUALS( offset, Vector2(20.0f,20.0f), TEST_LOCATION );
2640
2641   size = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "size" ) );
2642   DALI_TEST_EQUALS( size, Vector2(100.0f,100.0f), TEST_LOCATION );
2643
2644   offsetSizeMode = renderer.GetProperty<Vector4>( renderer.GetPropertyIndex( "offsetSizeMode" ) );
2645   DALI_TEST_EQUALS( offsetSizeMode, Vector4(0.0f,0.0f,1.0f,1.0f), TEST_LOCATION );
2646
2647   //Parent origin and anchor point should have the default values
2648   parentOrigin = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "origin" ) );
2649   DALI_TEST_EQUALS( parentOrigin, Vector2(-0.5f,-0.5f), TEST_LOCATION );
2650
2651   anchorPoint = renderer.GetProperty<Vector2>( renderer.GetPropertyIndex( "anchorPoint" ) );
2652   DALI_TEST_EQUALS( anchorPoint, Vector2(0.5f,0.5f), TEST_LOCATION );
2653 }
2654
2655 int UtcDaliVisualSetTransform0(void)
2656 {
2657   ToolkitTestApplication application;
2658   tet_infoline( "UtcDaliVisualSetTransform: ColorVisual" );
2659
2660   VisualFactory factory = VisualFactory::Get();
2661   Property::Map propertyMap;
2662   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2663   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2664   Visual::Base visual = factory.CreateVisual( propertyMap );
2665   TestTransform( application, visual );
2666   TestMixColor( visual, ColorVisual::Property::MIX_COLOR, Color::BLUE );
2667
2668   END_TEST;
2669 }
2670
2671 int UtcDaliVisualSetTransform1(void)
2672 {
2673   ToolkitTestApplication application;
2674   tet_infoline( "UtcDaliVisualSetTransform: PrimitiveVisual" );
2675
2676   VisualFactory factory = VisualFactory::Get();
2677   Property::Map propertyMap;
2678   propertyMap[ Toolkit::Visual::Property::TYPE           ] = Visual::PRIMITIVE;
2679   propertyMap[ PrimitiveVisual::Property::MIX_COLOR ] = Color::WHITE;
2680   propertyMap[ PrimitiveVisual::Property::SHAPE  ] = PrimitiveVisual::Shape::SPHERE;
2681   propertyMap[ PrimitiveVisual::Property::SLICES ] = 10;
2682   propertyMap[ PrimitiveVisual::Property::STACKS ] = 10;
2683   Visual::Base visual = factory.CreateVisual( propertyMap );
2684   TestTransform( application, visual );
2685   TestMixColor( visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE );
2686
2687   END_TEST;
2688 }
2689
2690 int UtcDaliVisualSetTransform2(void)
2691 {
2692   ToolkitTestApplication application;
2693   tet_infoline( "UtcDaliVisualSetTransform: GradientVisual" );
2694
2695   VisualFactory factory = VisualFactory::Get();
2696   Property::Map propertyMap;
2697   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::GRADIENT );
2698   propertyMap.Insert( Visual::Property::MIX_COLOR,  Color::GREEN );
2699
2700   Property::Array stopOffsets;
2701   stopOffsets.PushBack( 0.0f );
2702   stopOffsets.PushBack( 0.3f );
2703   stopOffsets.PushBack( 0.6f );
2704   stopOffsets.PushBack( 0.8f );
2705   stopOffsets.PushBack( 1.0f );
2706   propertyMap.Insert( GradientVisual::Property::STOP_OFFSET, stopOffsets );
2707
2708   Property::Array stopColors;
2709   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 255.f )/255.f );
2710   stopColors.PushBack( Vector4( 196.f, 198.f, 71.f, 122.f )/255.f );
2711   stopColors.PushBack( Vector4( 214.f, 37.f, 139.f, 191.f )/255.f );
2712   stopColors.PushBack( Vector4( 129.f, 198.f, 193.f, 150.f )/255.f );
2713   stopColors.PushBack( Color::YELLOW );
2714   propertyMap.Insert( GradientVisual::Property::STOP_COLOR, stopColors );
2715   propertyMap.Insert( GradientVisual::Property::CENTER, Vector2( 0.5f, 0.5f ) );
2716   propertyMap.Insert( GradientVisual::Property::RADIUS, 1.414f );
2717   Visual::Base visual = factory.CreateVisual( propertyMap );
2718   TestTransform( application, visual );
2719   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::GREEN );
2720
2721   END_TEST;
2722 }
2723
2724 int UtcDaliVisualSetTransform3(void)
2725 {
2726   ToolkitTestApplication application;
2727   tet_infoline( "UtcDaliVisualSetTransform: BorderVisual" );
2728
2729   VisualFactory factory = VisualFactory::Get();
2730   Property::Map propertyMap;
2731   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::BORDER );
2732   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::MAGENTA );
2733   propertyMap.Insert( BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f) );
2734   propertyMap.Insert( BorderVisual::Property::SIZE, 3.0f );
2735   Visual::Base visual = factory.CreateVisual( propertyMap );
2736   TestTransform( application, visual );
2737   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::MAGENTA );
2738
2739   END_TEST;
2740 }
2741
2742 int UtcDaliVisualSetTransform4(void)
2743 {
2744   ToolkitTestApplication application;
2745   tet_infoline( "UtcDaliVisualSetTransform: MeshVisual" );
2746
2747   VisualFactory factory = VisualFactory::Get();
2748   Property::Map propertyMap;
2749   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
2750   propertyMap.Insert( Visual::Property::MIX_COLOR, Color::CYAN );
2751
2752   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
2753   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
2754   propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
2755   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
2756   propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
2757   Visual::Base visual = factory.CreateVisual( propertyMap );
2758   TestTransform( application, visual );
2759   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::CYAN );
2760
2761   END_TEST;
2762 }
2763
2764 int UtcDaliVisualSetTransform5(void)
2765 {
2766   ToolkitTestApplication application;
2767   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual from Image" );
2768
2769   VisualFactory factory = VisualFactory::Get();
2770   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
2771   Visual::Base visual = factory.CreateVisual(image);
2772   TestTransform( application, visual );
2773   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2774
2775   END_TEST;
2776 }
2777
2778 int UtcDaliVisualSetTransform6(void)
2779 {
2780   ToolkitTestApplication application;
2781   tet_infoline( "UtcDaliVisualSetTransform: ImageVisual for URL " );
2782
2783   VisualFactory factory = VisualFactory::Get();
2784   Property::Map propertyMap;
2785   propertyMap[Toolkit::Visual::Property::TYPE] = Toolkit::Visual::IMAGE;
2786   propertyMap[Visual::Property::MIX_COLOR] = Color::YELLOW;
2787   propertyMap[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2788   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH] = 100.0f;
2789   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 100.0f;
2790   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE] = FittingMode::SCALE_TO_FILL;
2791   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE] = SamplingMode::BOX_THEN_LINEAR;
2792   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
2793   Visual::Base visual = factory.CreateVisual(propertyMap);
2794   TestTransform( application, visual );
2795   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::YELLOW );
2796
2797   END_TEST;
2798 }
2799
2800 int UtcDaliVisualSetTransform7(void)
2801 {
2802   ToolkitTestApplication application;
2803   tet_infoline( "UtcDaliVisualSetTransform: NPatch visual" );
2804
2805   VisualFactory factory = VisualFactory::Get();
2806   Image image = ResourceImage::New(TEST_NPATCH_FILE_NAME, ImageDimensions(100, 200));
2807   Visual::Base visual = factory.CreateVisual(image);
2808   TestTransform( application, visual );
2809   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::WHITE );
2810
2811   END_TEST;
2812 }
2813
2814 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
2815 {
2816   ToolkitTestApplication application;
2817   tet_infoline( "UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings" );
2818
2819   VisualFactory factory = VisualFactory::Get();
2820   Property::Map propertyMap;
2821   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2822   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2823   Visual::Base visual = factory.CreateVisual( propertyMap );
2824
2825   Property::Map transform;
2826   transform[ "offsetPolicy" ] = Property::Array().Add( "ABSOLUTE" )
2827                                                  .Add( "RELATIVE" );
2828   transform[ "sizePolicy"   ] = Property::Array().Add( "RELATIVE" )
2829                                                  .Add( "ABSOLUTE" );
2830   visual.SetTransformAndSize( transform, Vector2(100, 100) );
2831
2832   Dali::Property::Map visualMap;
2833   visual.CreatePropertyMap( visualMap );
2834   Property::Value* value = visualMap.Find( Dali::Toolkit::Visual::Property::TRANSFORM );
2835   Dali::Property::Map* map = value->GetMap();
2836   DALI_TEST_CHECK( map );
2837
2838   {
2839     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::OFFSET_POLICY );
2840     DALI_TEST_CHECK( typeValue );
2841     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE ), TEST_LOCATION );
2842   }
2843   {
2844     Property::Value* typeValue = map->Find( Toolkit::Visual::Transform::Property::SIZE_POLICY );
2845     DALI_TEST_CHECK( typeValue );
2846     DALI_TEST_EQUALS( typeValue->Get< Vector2 >(), Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE ), TEST_LOCATION );
2847   }
2848
2849   END_TEST;
2850 }
2851
2852 int UtcDaliNPatchVisualCustomShader(void)
2853 {
2854   ToolkitTestApplication application;
2855   tet_infoline( "NPatchVisual with custom shader" );
2856
2857   VisualFactory factory = VisualFactory::Get();
2858   Property::Map properties;
2859   Property::Map shader;
2860   const std::string vertexShader = "Foobar";
2861   const std::string fragmentShader = "Foobar";
2862   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2863   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
2864
2865   Property::Map transformMap;
2866   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
2867   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
2868   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
2869   transformMap["anchorPoint"] = Align::CENTER;
2870   transformMap["origin"] = Align::CENTER;
2871   properties[Visual::Property::TRANSFORM] = transformMap;
2872
2873   properties[Visual::Property::TYPE] = Visual::IMAGE;
2874   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
2875   properties[Visual::Property::SHADER]=shader;
2876   properties[ImageVisual::Property::URL] = TEST_NPATCH_FILE_NAME;
2877
2878   Visual::Base visual = factory.CreateVisual( properties );
2879   TestMixColor( visual, Visual::Property::MIX_COLOR, Color::BLUE );
2880
2881   // trigger creation through setting on stage
2882   DummyControl dummy = DummyControl::New(true);
2883   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
2884   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2885   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
2886   dummy.SetSize(2000, 2000);
2887   dummy.SetParentOrigin(ParentOrigin::CENTER);
2888   Stage::GetCurrent().Add(dummy);
2889   application.SendNotification();
2890
2891   Renderer renderer = dummy.GetRendererAt( 0 );
2892   Shader shader2 = renderer.GetShader();
2893   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
2894   Property::Map* map = value.GetMap();
2895   DALI_TEST_CHECK( map );
2896
2897   Property::Index index = renderer.GetPropertyIndex("size");
2898   DALI_TEST_EQUALS( renderer.GetProperty( index ), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION );
2899
2900   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
2901   DALI_TEST_EQUALS( fragmentShader, fragment->Get<std::string>(), TEST_LOCATION );
2902
2903   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
2904   DALI_TEST_EQUALS( vertexShader, vertex->Get<std::string>(), TEST_LOCATION );
2905
2906   END_TEST;
2907 }
2908
2909 int UtcDaliGradientVisualBlendMode(void)
2910 {
2911   ToolkitTestApplication application;
2912   VisualFactory factory = VisualFactory::Get();
2913
2914   Visual::Base opaqueGradientVisual = factory.CreateVisual(
2915       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
2916                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
2917                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
2918                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
2919                                                                                   .Add( Color::GREEN ) ) );
2920
2921   Visual::Base alphaGradientVisual = factory.CreateVisual(
2922       Property::Map().Add( Toolkit::Visual::Property::TYPE, Visual::GRADIENT )
2923                      .Add( GradientVisual::Property::START_POSITION, Vector2( -0.5f, -0.5f ) )
2924                      .Add( GradientVisual::Property::END_POSITION, Vector2( 0.5f, 0.5f ) )
2925                      .Add( GradientVisual::Property::STOP_COLOR, Property::Array().Add( Color::RED )
2926                                                                                   .Add( Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ) ) );
2927
2928   DummyControl control = DummyControl::New(true);
2929   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
2930   Stage::GetCurrent().Add( control );
2931
2932   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>( control.GetImplementation() );
2933   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL,  opaqueGradientVisual );
2934   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, alphaGradientVisual );
2935
2936   application.SendNotification();
2937   application.Render();
2938
2939   // 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
2940   DALI_TEST_EQUALS( 2u, control.GetRendererCount(), TEST_LOCATION );
2941   DALI_TEST_EQUALS( control.GetRendererAt( 0 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION );
2942   DALI_TEST_EQUALS( control.GetRendererAt( 1 ).GetProperty( Renderer::Property::BLEND_MODE ).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
2943
2944   END_TEST;
2945 }
2946
2947 int UtcDaliVisualRendererRemovalAndReAddition(void)
2948 {
2949   ToolkitTestApplication application;
2950   tet_infoline( "UtcDaliVisualRendererRemoval" );
2951
2952   VisualFactory factory = VisualFactory::Get();
2953   Property::Map propertyMap;
2954   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
2955   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
2956   Visual::Base visual = factory.CreateVisual( propertyMap );
2957
2958   visual.SetDepthIndex( 1 );
2959
2960   DummyControl dummyControl = DummyControl::New(true);
2961   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
2962   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2963   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2964
2965   dummyControl.SetSize(200.f, 200.f);
2966   tet_infoline( "Add control with visual to stage and check renderer count is 1" );
2967
2968   Stage::GetCurrent().Add( dummyControl );
2969
2970   application.SendNotification();
2971   application.Render();
2972
2973   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2974
2975   tet_infoline( "Remove control with visual from stage and check renderer count is 0" );
2976   Stage::GetCurrent().Remove( dummyControl );
2977   application.SendNotification();
2978   application.Render();
2979
2980   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
2981
2982   tet_infoline( "Re-add control with visual to stage and check renderer count is still 1" );
2983
2984   Stage::GetCurrent().Add( dummyControl );
2985
2986   application.SendNotification();
2987   application.Render();
2988
2989   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
2990
2991   END_TEST;
2992 }
2993
2994
2995
2996 int UtcDaliVisualTextVisualRender(void)
2997 {
2998   ToolkitTestApplication application;
2999   tet_infoline( "UtcDaliVisualTextVisualRender" );
3000
3001   VisualFactory factory = VisualFactory::Get();
3002   Property::Map propertyMap;
3003   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3004   propertyMap.Insert( "mixColor", Color::WHITE );
3005   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3006   propertyMap.Insert( "enableMarkup", false );
3007   propertyMap.Insert( "text", "Hello world" );
3008   propertyMap.Insert( "fontFamily", "TizenSans" );
3009
3010   Property::Map fontStyleMapSet;
3011   fontStyleMapSet.Insert( "weight", "bold" );
3012   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3013
3014   propertyMap.Insert( "pointSize", 12.f );
3015   propertyMap.Insert( "multiLine", true );
3016   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3017   propertyMap.Insert( "verticalAlignment", "CENTER" );
3018   propertyMap.Insert( "textColor", Color::RED );
3019   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3020   textVisual.SetDepthIndex( 1 );
3021
3022   DummyControl dummyControl = DummyControl::New(true);
3023   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3024   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3025   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3026
3027   dummyControl.SetSize(200.f, 200.f);
3028   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3029
3030   Stage::GetCurrent().Add( dummyControl );
3031   application.SendNotification();
3032   application.Render();
3033
3034
3035   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3036   propertyMap.Clear();
3037   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3038   propertyMap.Insert( TextVisual::Property::ENABLE_MARKUP, true );
3039   propertyMap.Insert( TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>" );
3040   propertyMap.Insert( TextVisual::Property::MULTI_LINE, true );
3041
3042   Property::Map transformMap;
3043   transformMap.Insert( "size", Vector2( 0.5f, 0.5f ) );
3044   propertyMap.Insert( Visual::Property::TRANSFORM, transformMap );
3045
3046   textVisual = factory.CreateVisual( propertyMap );
3047   textVisual.SetDepthIndex( 1 );
3048
3049   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3050   dummyControl.SetSize( 720.f, 640.f );
3051
3052   application.SendNotification(); // force process events to ensure text visual
3053   // adds renderer to the dummy control in OnRelayout
3054   application.Render();
3055
3056   Renderer renderer = dummyControl.GetRendererAt(0u);
3057   Property::Index index = renderer.GetPropertyIndex("size");
3058
3059   tet_infoline( "Test that the TextVisual has NOT overridden what was set by developer" );
3060   DALI_TEST_EQUALS( renderer.GetProperty<Vector2>(index), Vector2( 0.5f, 0.5f ), 0.001f, TEST_LOCATION );
3061
3062   END_TEST;
3063 }
3064
3065 int UtcDaliVisualTextVisualDisableEnable(void)
3066 {
3067   ToolkitTestApplication application;
3068   tet_infoline( "UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled" );
3069
3070   VisualFactory factory = VisualFactory::Get();
3071   Property::Map propertyMap;
3072   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::TEXT );
3073   propertyMap.Insert( "mixColor", Color::WHITE );
3074   propertyMap.Insert( "renderingBackend", static_cast<int>( Toolkit::Text::DEFAULT_RENDERING_BACKEND ) );
3075   propertyMap.Insert( "enableMarkup", false );
3076   propertyMap.Insert( "text", "Hello world" );
3077   propertyMap.Insert( "fontFamily", "TizenSans" );
3078
3079   Property::Map fontStyleMapSet;
3080   fontStyleMapSet.Insert( "weight", "bold" );
3081   propertyMap.Insert( "fontStyle", fontStyleMapSet );
3082
3083   propertyMap.Insert( "pointSize", 12.f );
3084   propertyMap.Insert( "multiLine", true );
3085   propertyMap.Insert( "horizontalAlignment", "CENTER" );
3086   propertyMap.Insert( "verticalAlignment", "CENTER" );
3087   propertyMap.Insert( "textColor", Color::RED );
3088   Visual::Base textVisual = factory.CreateVisual( propertyMap );
3089   textVisual.SetDepthIndex( 1 );
3090
3091   DummyControl dummyControl = DummyControl::New(true);
3092   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3093   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, textVisual );
3094   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3095
3096   dummyControl.SetSize(200.f, 200.f);
3097   dummyControl.SetParentOrigin( ParentOrigin::CENTER );
3098
3099   Stage::GetCurrent().Add( dummyControl );
3100   application.SendNotification();
3101   application.Render();
3102
3103   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3104
3105   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
3106
3107   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 0, TEST_LOCATION );
3108
3109   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
3110
3111   DALI_TEST_EQUALS( dummyControl.GetRendererCount(), 1, TEST_LOCATION );
3112
3113   END_TEST;
3114 }
3115
3116 int UtcDaliVisualPremultipliedAlpha(void)
3117 {
3118   ToolkitTestApplication application;
3119   tet_infoline( "UtcDaliVisualPremultipliedAlpha" );
3120
3121   VisualFactory factory = VisualFactory::Get();
3122
3123   // image visual, test default value ( false )
3124   {
3125     Visual::Base imageVisual = factory.CreateVisual(
3126           Property::Map()
3127           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3128           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME ) );
3129
3130     Dali::Property::Map visualMap;
3131     imageVisual.CreatePropertyMap( visualMap );
3132     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3133
3134     // test values
3135     DALI_TEST_CHECK( value );
3136     DALI_TEST_EQUALS( value->Get<bool>(), false, TEST_LOCATION );
3137   }
3138
3139   // image visual, override premultiplied
3140   {
3141     Visual::Base imageVisual = factory.CreateVisual(
3142           Property::Map()
3143           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3144           .Add( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME )
3145           .Add( Visual::Property::PREMULTIPLIED_ALPHA, true ) );
3146
3147     Dali::Property::Map visualMap;
3148     imageVisual.CreatePropertyMap( visualMap );
3149     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3150
3151     // test values
3152     DALI_TEST_CHECK( value );
3153     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION);
3154   }
3155
3156   // svg visual ( premultiplied alpha by default is true )
3157   {
3158     Visual::Base imageVisual = factory.CreateVisual(
3159           Property::Map()
3160           .Add( Toolkit::Visual::Property::TYPE, Visual::IMAGE )
3161           .Add( ImageVisual::Property::URL, TEST_SVG_FILE_NAME ) );
3162
3163     Dali::Property::Map visualMap;
3164     imageVisual.CreatePropertyMap( visualMap );
3165     Property::Value* value = visualMap.Find( Visual::Property::PREMULTIPLIED_ALPHA );
3166
3167     // test values
3168     DALI_TEST_CHECK( value );
3169     DALI_TEST_EQUALS( value->Get<bool>(), true, TEST_LOCATION );
3170   }
3171
3172   END_TEST;
3173 }
3174
3175 int UtcDaliRegisterVisualOrder(void)
3176 {
3177   ToolkitTestApplication application;
3178   tet_infoline( "Register Visual Order" );
3179
3180   DummyControl dummyControl = DummyControl::New(true);
3181   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3182
3183   VisualFactory factory = VisualFactory::Get();
3184   Property::Map propertyMap;
3185   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3186   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3187
3188   tet_infoline( "Register visual, should have depth index of 0.0f" );
3189   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3190   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual );
3191   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 0, TEST_LOCATION );
3192
3193   tet_infoline( "Register more visuals, each added one should have a depth index greater than previous" );
3194
3195   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3196   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3197   DALI_TEST_CHECK( testVisual2.GetDepthIndex() > testVisual.GetDepthIndex() );
3198
3199   Visual::Base foregroundVisual = factory.CreateVisual( propertyMap );
3200   dummyImpl.RegisterVisual( DummyControl::Property::FOREGROUND_VISUAL, foregroundVisual );
3201   DALI_TEST_CHECK( foregroundVisual.GetDepthIndex() > testVisual2.GetDepthIndex() );
3202
3203   Visual::Base focusVisual = factory.CreateVisual( propertyMap );
3204   dummyImpl.RegisterVisual( DummyControl::Property::FOCUS_VISUAL, focusVisual );
3205   DALI_TEST_CHECK( focusVisual.GetDepthIndex() > foregroundVisual.GetDepthIndex() );
3206
3207   tet_infoline( "Set depth index on a new visual before registering, the depth index should not have been changed" );
3208   Visual::Base labelVisual = factory.CreateVisual( propertyMap );
3209   labelVisual.SetDepthIndex( -2000 );
3210   dummyImpl.RegisterVisual( DummyControl::Property::LABEL_VISUAL, labelVisual );
3211   DALI_TEST_EQUALS( labelVisual.GetDepthIndex(), -2000, TEST_LOCATION );
3212
3213   tet_infoline( "Replace visual, the depth index should be the same as what was previously set" );
3214   const int testVisual2DepthIndex = testVisual2.GetDepthIndex();
3215   Visual::Base testVisual2Replacement = factory.CreateVisual( propertyMap );
3216   DALI_TEST_CHECK( testVisual2Replacement.GetDepthIndex() != testVisual2DepthIndex );
3217   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2Replacement );
3218   DALI_TEST_EQUALS( testVisual2Replacement.GetDepthIndex(), testVisual2DepthIndex, TEST_LOCATION );
3219
3220   tet_infoline( "Replace visual and set a depth index on the replacement, the depth index of the replacement should be honoured" );
3221   Visual::Base anotherTestVisual2Replacement = factory.CreateVisual( propertyMap );
3222   anotherTestVisual2Replacement.SetDepthIndex( 2000 );
3223   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, anotherTestVisual2Replacement );
3224   DALI_TEST_EQUALS( anotherTestVisual2Replacement.GetDepthIndex(), 2000, TEST_LOCATION );
3225
3226   dummyControl.SetSize(200.f, 200.f);
3227   Stage::GetCurrent().Add( dummyControl );
3228
3229   END_TEST;
3230 }
3231
3232 int UtcDaliRegisterVisualOrder02(void)
3233 {
3234   ToolkitTestApplication application;
3235   tet_infoline( "Register Visual Order with Background Set" );
3236
3237   DummyControl dummyControl = DummyControl::New(true);
3238   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3239
3240   const int backgroundDepthIndex = Toolkit::DepthIndex::BACKGROUND;
3241
3242   VisualFactory factory = VisualFactory::Get();
3243   Property::Map propertyMap;
3244   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3245   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3246
3247   tet_printf( "Register a control background visual, should have depth index of %d\n", backgroundDepthIndex );
3248
3249   dummyControl.SetProperty( Control::Property::BACKGROUND, propertyMap );
3250
3251   const int TEST_VISUAL_1_DEPTH_INDEX = 0;
3252   tet_printf( "Register visual, should have depth index of %d\n", TEST_VISUAL_1_DEPTH_INDEX );
3253   Visual::Base testVisual1 = factory.CreateVisual( propertyMap );
3254   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, testVisual1 );
3255   DALI_TEST_EQUALS( testVisual1.GetDepthIndex(), TEST_VISUAL_1_DEPTH_INDEX , TEST_LOCATION );
3256
3257   tet_printf( "Register another visual, should have a depth index greater than previous(%d)\n", TEST_VISUAL_1_DEPTH_INDEX );
3258   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3259   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, testVisual2 );
3260   DALI_TEST_CHECK( testVisual2.GetDepthIndex() >  testVisual1.GetDepthIndex() );
3261
3262   dummyControl.SetSize(200.f, 200.f);
3263   Stage::GetCurrent().Add( dummyControl );
3264
3265   END_TEST;
3266 }
3267
3268 int UtcDaliRegisterVisualWithDepthIndex(void)
3269 {
3270   ToolkitTestApplication application;
3271   tet_infoline( "Register a Visual With Depth Index" );
3272
3273   DummyControl dummyControl = DummyControl::New(true);
3274   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3275
3276   VisualFactory factory = VisualFactory::Get();
3277   Property::Map propertyMap;
3278   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
3279   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  Color::BLUE);
3280
3281   tet_infoline( "Register a visual with a depth index, it should be enabled by default too" );
3282   Visual::Base testVisual = factory.CreateVisual( propertyMap );
3283   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL, testVisual, 203 );
3284   DALI_TEST_EQUALS( testVisual.GetDepthIndex(), 203, TEST_LOCATION );
3285   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL ), true, TEST_LOCATION );
3286
3287   tet_infoline( "Register another visual with a depth index and it disabled" );
3288   Visual::Base testVisual2 = factory.CreateVisual( propertyMap );
3289   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual2, false, 450 );
3290   DALI_TEST_EQUALS( testVisual2.GetDepthIndex(), 450, TEST_LOCATION );
3291   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), false, TEST_LOCATION );
3292
3293   tet_infoline( "Register another visual with a depth index and it enabled using the enabled API" );
3294   Visual::Base testVisual3 = factory.CreateVisual( propertyMap );
3295   DevelControl::RegisterVisual( dummyImpl, DummyControl::Property::TEST_VISUAL2, testVisual3, true, 300 );
3296   DALI_TEST_EQUALS( testVisual3.GetDepthIndex(), 300, TEST_LOCATION );
3297   DALI_TEST_EQUALS( DevelControl::IsVisualEnabled( dummyImpl, DummyControl::Property::TEST_VISUAL2 ), true, TEST_LOCATION );
3298
3299   dummyControl.SetSize(200.f, 200.f);
3300   Stage::GetCurrent().Add( dummyControl );
3301
3302   END_TEST;
3303 }