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

   1 /*
   2  * Copyright (c) 2021 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 <vector>
  20 #include <dali-toolkit-test-suite-utils.h>
  21 #include <toolkit-timer.h>
  22 #include <toolkit-event-thread-callback.h>
  23 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
  24 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  25 #include <dali-toolkit/devel-api/controls/control-devel.h>
  26 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  27 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  28 #include <dali-toolkit/public-api/image-loader/image.h>
  29 #include <dali-toolkit/public-api/image-loader/image-url.h>
  30 #include <dali-toolkit/dali-toolkit.h>
  31
  32 #include <test-encoded-image-buffer.h>
  33 #include "dummy-control.h"
  34 #include "test-native-image-source.h"
  35
  36 using namespace Dali;
  37 using namespace Dali::Toolkit;
  38
  39 void dali_image_visual_startup(void)
  40 {
  41   test_return_value = TET_UNDEF;
  42 }
  43
  44 void dali_image_visual_cleanup(void)
  45 {
  46   test_return_value = TET_PASS;
  47 }
  48
  49 namespace
  50 {
  51 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR  "/gallery-small-1.jpg";
  52 const char* TEST_BROKEN_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR  "/a-random-nonimage.jpg";
  53 const char* TEST_LARGE_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/tbcol.png";
  54 const char* TEST_SMALL_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/icon-edit.png";
  55 const char* TEST_REMOTE_IMAGE_FILE_NAME = "https://www.tizen.org/sites/all/themes/tizen_theme/logo.png";
  56 const char* TEST_INVALID_FILE_NAME =  TEST_RESOURCE_DIR  "/invalid.jpg";
  57 const char* TEST_REMOTE_INVALID_FILE_NAME = "https://www.tizen.org/invalid.png";
  58 const char* TEST_MASK_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR "/mask.png";
  59 const char* TEST_ROTATED_IMAGE =  TEST_RESOURCE_DIR  "/keyboard-Landscape.jpg";
  60
  61
  62 bool gResourceReadySignalFired = false;
  63 std::vector<int> gReadyIds = {};
  64 void ResourceReadySignal( Control control )
  65 {
  66   gResourceReadySignalFired = true;
  67   gReadyIds.push_back(control.GetProperty< int >( Actor::Property::ID ));
  68 }
  69 void ClearReadyIds()
  70 {
  71   gReadyIds.clear();
  72 }
  73
  74 Actor CreateActorWithImageVisual(const Property::Map& map)
  75 {
  76   VisualFactory factory = VisualFactory::Get();
  77   DummyControl actor = DummyControl::New();
  78   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
  79   Visual::Base visual = factory.CreateVisual( map );
  80   DALI_TEST_CHECK( visual );
  81   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
  82   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
  83   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
  84   return actor;
  85 }
  86
  87
  88 Visual::Base CreateVisualWithPolicy( const char* url, Property::Index key, const Property::Value& value )
  89 {
  90   VisualFactory factory = VisualFactory::Get();
  91
  92   Property::Map propertyMap;
  93   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
  94   propertyMap.Insert( ImageVisual::Property::URL,  url );
  95   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
  96   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
  97   propertyMap.Insert( key , value );
  98
  99   return factory.CreateVisual( propertyMap );
 100 }
 101
 102 } // namespace
 103
 104 void TestVisualRender( ToolkitTestApplication& application,
 105                        DummyControl& actor,
 106                        Visual::Base& visual,
 107                        std::size_t expectedSamplers = 0,
 108                        ImageDimensions imageDimensions = ImageDimensions(),
 109                        Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
 110 {
 111   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 112   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 113
 114   if( resourcePtr )
 115   {
 116     // set the image size, for test case, this needs to be set before loading started
 117     application.GetPlatform().SetClosestImageSize(  Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()) );
 118   }
 119
 120   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 121   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 122
 123   application.GetScene().Add( actor );
 124
 125   application.SendNotification(); // Send messages to update
 126   application.Render();           // process update and render
 127   application.SendNotification(); // process any signals to event
 128
 129   if( resourcePtr )
 130   {
 131     DALI_TEST_EQUALS( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceSynchronouslyFunc ), true, TEST_LOCATION);
 132   }
 133
 134   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 135 }
 136
 137 static void TestMixColor( Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor )
 138 {
 139   Property::Map map;
 140   visual.CreatePropertyMap(map);
 141   Property::Value* value = map.Find( mixColorIndex );
 142   DALI_TEST_CHECK( value );
 143   Vector3 mixColor1;
 144   DALI_TEST_CHECK( value->Get( mixColor1 ) );
 145   DALI_TEST_EQUALS( mixColor1, Vector3(testColor), 0.001, TEST_LOCATION );
 146
 147   value = map.Find( Visual::Property::MIX_COLOR );
 148   DALI_TEST_CHECK( value );
 149   Vector4 mixColor2;
 150   DALI_TEST_CHECK( value->Get( mixColor2 ) );
 151   DALI_TEST_EQUALS( mixColor2, testColor, 0.001, TEST_LOCATION );
 152
 153   value = map.Find( Visual::Property::OPACITY );
 154   DALI_TEST_CHECK( value );
 155   float opacity;
 156   DALI_TEST_CHECK( value->Get( opacity ) );
 157   DALI_TEST_EQUALS( opacity, testColor.a, 0.001, TEST_LOCATION );
 158 }
 159
 160
 161
 162 int UtcDaliImageVisualPropertyMap(void)
 163 {
 164   ToolkitTestApplication application;
 165   tet_infoline( "Request image visual with a Property::Map" );
 166
 167   VisualFactory factory = VisualFactory::Get();
 168   DALI_TEST_CHECK( factory );
 169   factory.SetPreMultiplyOnLoad( true );
 170
 171   Property::Map propertyMap;
 172   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 173   propertyMap.Insert( ImageVisual::Property::URL,  TEST_LARGE_IMAGE_FILE_NAME );
 174
 175   Visual::Base visual = factory.CreateVisual( propertyMap );
 176   DALI_TEST_CHECK( visual );
 177
 178   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 179   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 180
 181   TestGlAbstraction& gl = application.GetGlAbstraction();
 182   TraceCallStack& textureTrace = gl.GetTextureTrace();
 183   textureTrace.Enable(true);
 184
 185   DummyControl actor = DummyControl::New();
 186   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 187   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 188
 189   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 190   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 191
 192   application.GetScene().Add( actor );
 193   application.SendNotification();
 194   application.Render();
 195
 196   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 197
 198   application.SendNotification();
 199   application.Render();
 200
 201   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 202   auto renderer = actor.GetRendererAt(0);
 203   auto preMultipliedIndex = renderer.GetPropertyIndex( "preMultipliedAlpha" );
 204   DALI_TEST_CHECK( preMultipliedIndex != Property::INVALID_INDEX );
 205   auto preMultipliedAlpha = renderer.GetProperty<float>( preMultipliedIndex );
 206   auto preMultipliedAlpha2 = renderer.GetProperty<bool>( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
 207   DALI_TEST_EQUALS( preMultipliedAlpha, 1.0f, TEST_LOCATION );
 208   DALI_TEST_EQUALS( preMultipliedAlpha2, true, TEST_LOCATION );
 209   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 210
 211   application.GetScene().Remove( actor );
 212   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 213
 214   END_TEST;
 215 }
 216
 217
 218 int UtcDaliImageVisualNoPremultipliedAlpha01(void)
 219 {
 220   ToolkitTestApplication application;
 221   tet_infoline( "Request image visual without pre-multiplied alpha" );
 222
 223   VisualFactory factory = VisualFactory::Get();
 224   DALI_TEST_CHECK( factory );
 225   factory.SetPreMultiplyOnLoad( false );
 226
 227   Property::Map propertyMap;
 228   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 229   propertyMap.Insert( ImageVisual::Property::URL,  TEST_LARGE_IMAGE_FILE_NAME );
 230
 231   Visual::Base visual = factory.CreateVisual( propertyMap );
 232   DALI_TEST_CHECK( visual );
 233
 234   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 235   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 236
 237   TestGlAbstraction& gl = application.GetGlAbstraction();
 238   TraceCallStack& textureTrace = gl.GetTextureTrace();
 239   textureTrace.Enable(true);
 240
 241   DummyControl actor = DummyControl::New();
 242   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 243   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 244
 245   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 246   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 247
 248   application.GetScene().Add( actor );
 249   application.SendNotification();
 250   application.Render();
 251
 252   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 253
 254   application.SendNotification();
 255   application.Render();
 256
 257   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 258   auto renderer = actor.GetRendererAt(0);
 259   auto preMultipliedIndex = renderer.GetPropertyIndex( "preMultipliedAlpha" );
 260   DALI_TEST_CHECK( preMultipliedIndex != Property::INVALID_INDEX );
 261   auto preMultipliedAlpha = renderer.GetProperty<bool>( preMultipliedIndex );
 262   auto preMultipliedAlpha2 = renderer.GetProperty<bool>( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
 263
 264   DALI_TEST_EQUALS( preMultipliedAlpha, false, TEST_LOCATION );
 265   DALI_TEST_EQUALS( preMultipliedAlpha2, false, TEST_LOCATION );
 266
 267   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 268
 269   application.GetScene().Remove( actor );
 270   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 271
 272   END_TEST;
 273 }
 274
 275
 276 int UtcDaliImageVisualNoPremultipliedAlpha02(void)
 277 {
 278   ToolkitTestApplication application;
 279   tet_infoline( "Request image visual with no alpha channel" );
 280
 281   VisualFactory factory = VisualFactory::Get();
 282   DALI_TEST_CHECK( factory );
 283
 284   Property::Map propertyMap;
 285   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 286   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
 287
 288   Visual::Base visual = factory.CreateVisual( propertyMap );
 289   DALI_TEST_CHECK( visual );
 290
 291   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 292   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 293
 294   TestGlAbstraction& gl = application.GetGlAbstraction();
 295   TraceCallStack& textureTrace = gl.GetTextureTrace();
 296   textureTrace.Enable(true);
 297
 298   DummyControl actor = DummyControl::New();
 299   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 300   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 301
 302   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 303   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 304
 305   application.GetScene().Add( actor );
 306   application.SendNotification();
 307   application.Render();
 308
 309   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 310
 311   application.SendNotification();
 312   application.Render();
 313
 314   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 315   auto renderer = actor.GetRendererAt(0);
 316   auto preMultipliedIndex = renderer.GetPropertyIndex( "preMultipliedAlpha" );
 317   DALI_TEST_CHECK( preMultipliedIndex != Property::INVALID_INDEX );
 318   auto preMultipliedAlpha = renderer.GetProperty<bool>( preMultipliedIndex );
 319   auto preMultipliedAlpha2 = renderer.GetProperty<bool>( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
 320
 321   DALI_TEST_EQUALS( preMultipliedAlpha, false, TEST_LOCATION );
 322   DALI_TEST_EQUALS( preMultipliedAlpha2, false, TEST_LOCATION );
 323
 324   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 325
 326   int srcFactorRgb    = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
 327   int destFactorRgb   = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
 328   int srcFactorAlpha  = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
 329   int destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
 330   DALI_TEST_CHECK( srcFactorRgb == BlendFactor::SRC_ALPHA );
 331   DALI_TEST_CHECK( destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA );
 332   DALI_TEST_CHECK( srcFactorAlpha == BlendFactor::ONE );
 333   DALI_TEST_CHECK( destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA );
 334
 335   textureTrace.Reset();
 336
 337   // Make a new visual with the same image
 338   Visual::Base newVisual = factory.CreateVisual( propertyMap );
 339   DALI_TEST_CHECK( newVisual );
 340
 341   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 342   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 343
 344   DummyControl newActor = DummyControl::New();
 345   DummyControlImpl& newDummyImpl = static_cast< DummyControlImpl& >( newActor.GetImplementation() );
 346   newDummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, newVisual );
 347
 348   newActor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 349   DALI_TEST_EQUALS( newActor.GetRendererCount(), 0u, TEST_LOCATION );
 350
 351   application.GetScene().Add( newActor );
 352
 353   application.SendNotification();
 354   application.Render();
 355
 356   DALI_TEST_EQUALS( newActor.GetRendererCount(), 1u, TEST_LOCATION );
 357   auto newRenderer = newActor.GetRendererAt( 0 );
 358   preMultipliedIndex = newRenderer.GetPropertyIndex( "preMultipliedAlpha" );
 359   DALI_TEST_CHECK( preMultipliedIndex != Property::INVALID_INDEX );
 360   preMultipliedAlpha = newRenderer.GetProperty< bool >( preMultipliedIndex );
 361   preMultipliedAlpha2 = newRenderer.GetProperty< bool >( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
 362
 363   DALI_TEST_EQUALS( preMultipliedAlpha, false, TEST_LOCATION );
 364   DALI_TEST_EQUALS( preMultipliedAlpha2, false, TEST_LOCATION );
 365
 366   srcFactorRgb    = newRenderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
 367   destFactorRgb   = newRenderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
 368   srcFactorAlpha  = newRenderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
 369   destFactorAlpha = newRenderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
 370   DALI_TEST_CHECK( srcFactorRgb == BlendFactor::SRC_ALPHA );
 371   DALI_TEST_CHECK( destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA );
 372   DALI_TEST_CHECK( srcFactorAlpha == BlendFactor::ONE );
 373   DALI_TEST_CHECK( destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA );
 374
 375   application.GetScene().Remove( actor );
 376   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 377
 378   END_TEST;
 379 }
 380
 381
 382 int UtcDaliImageVisualRemoteImageLoad(void)
 383 {
 384   ToolkitTestApplication application;
 385   tet_infoline( "Request remote image visual with a Property::Map" );
 386
 387   VisualFactory factory = VisualFactory::Get();
 388   DALI_TEST_CHECK( factory );
 389
 390   Property::Map propertyMap;
 391   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 392   propertyMap.Insert( ImageVisual::Property::URL,  TEST_REMOTE_IMAGE_FILE_NAME );
 393
 394   Visual::Base visual = factory.CreateVisual( propertyMap );
 395   DALI_TEST_CHECK( visual );
 396
 397   TestGlAbstraction& gl = application.GetGlAbstraction();
 398   TraceCallStack& textureTrace = gl.GetTextureTrace();
 399   textureTrace.Enable(true);
 400
 401   DummyControl actor = DummyControl::New();
 402   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 403   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 404
 405   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 406   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 407
 408   application.GetScene().Add( actor );
 409   application.SendNotification();
 410
 411   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 412
 413   application.SendNotification();
 414   application.Render();
 415
 416   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 417   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 418
 419   application.GetScene().Remove( actor );
 420   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 421
 422   END_TEST;
 423 }
 424
 425
 426 int UtcDaliImageVisualWithNativeImage(void)
 427 {
 428   ToolkitTestApplication application;
 429   tet_infoline( "Use Native Image as url" );
 430
 431   NativeImageSourcePtr nativeImageSource = NativeImageSource::New(500, 500, NativeImageSource::COLOR_DEPTH_DEFAULT);
 432   ImageUrl imageUrl = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
 433   std::string url = imageUrl.GetUrl();
 434
 435   VisualFactory factory = VisualFactory::Get();
 436   DALI_TEST_CHECK( factory );
 437
 438   Property::Map propertyMap;
 439   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 440   propertyMap.Insert( ImageVisual::Property::URL,  url );
 441
 442   Visual::Base visual = factory.CreateVisual( propertyMap );
 443   DALI_TEST_CHECK( visual );
 444
 445   DummyControl actor = DummyControl::New();
 446   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 447   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 448
 449   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 450
 451   application.GetScene().Add( actor );
 452
 453   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 454
 455   Renderer renderer = actor.GetRendererAt(0);
 456   Shader shader = renderer.GetShader();
 457
 458   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 459   DALI_TEST_CHECK(value.GetType() == Property::MAP);
 460   const Property::Map* outMap = value.GetMap();
 461   std::string fragmentShader = (*outMap)["fragment"].Get<std::string>();
 462
 463   const char* fragmentPrefix = Dali::NativeImageSourceTest::GetCustomFragmentPrefix();
 464   size_t pos = fragmentShader.find(fragmentPrefix);
 465
 466   DALI_TEST_EQUALS( pos != std::string::npos, true, TEST_LOCATION );
 467
 468   END_TEST;
 469 }
 470
 471 int UtcDaliImageVisualWithNativeImageRemoved(void)
 472 {
 473   ToolkitTestApplication application;
 474   tet_infoline( "Use Native Image as url" );
 475
 476   TestGlAbstraction& gl = application.GetGlAbstraction();
 477   TraceCallStack& textureTrace = gl.GetTextureTrace();
 478   textureTrace.Enable(true);
 479
 480   NativeImageSourcePtr nativeImageSource = NativeImageSource::New(500, 500, NativeImageSource::COLOR_DEPTH_DEFAULT);
 481   ImageUrl imageUrl = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
 482   std::string url = imageUrl.GetUrl();
 483
 484   VisualFactory factory = VisualFactory::Get();
 485   DALI_TEST_CHECK( factory );
 486
 487   Property::Map propertyMap;
 488   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 489   propertyMap.Insert( ImageVisual::Property::URL,  url );
 490
 491   Visual::Base visual = factory.CreateVisual( propertyMap );
 492   DALI_TEST_CHECK( visual );
 493
 494   DummyControl actor = DummyControl::New();
 495   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 496   dummyImpl.RegisterVisual(  DummyControl::Property::TEST_VISUAL, visual );
 497
 498   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 499
 500   application.GetScene().Add( actor );
 501   application.SendNotification();
 502   application.Render();
 503
 504   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 505   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
 506
 507   tet_infoline( "No delete texture because reference count is not zero" );
 508   imageUrl.Reset();
 509   application.GetScene().Remove( actor );
 510   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
 511   application.SendNotification();
 512   application.Render();
 513
 514   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 515   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
 516
 517   tet_infoline( "Delete texture because reference count is zero" );
 518   visual.Reset();
 519   application.SendNotification();
 520   application.Render();
 521
 522   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
 523
 524   END_TEST;
 525 }
 526
 527 int UtcDaliImageVisualWithEncodedImageBuffer(void)
 528 {
 529   ToolkitTestApplication application;
 530   tet_infoline( "Use Encoded Image Buffer as url" );
 531
 532   EncodedImageBuffer rawBuffer = ConvertFileToEncodedImageBuffer(TEST_LARGE_IMAGE_FILE_NAME);
 533   ImageUrl url = Dali::Toolkit::Image::GenerateUrl(rawBuffer);
 534
 535   VisualFactory factory = VisualFactory::Get();
 536   DALI_TEST_CHECK( factory );
 537
 538   Property::Map propertyMap;
 539   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::IMAGE );
 540   propertyMap.Insert( ImageVisual::Property::URL, url.GetUrl() );
 541
 542   Visual::Base visual = factory.CreateVisual( propertyMap );
 543   DALI_TEST_CHECK( visual );
 544
 545   TestGlAbstraction& gl = application.GetGlAbstraction();
 546   TraceCallStack& textureTrace = gl.GetTextureTrace();
 547   textureTrace.Enable(true);
 548
 549   DummyControl actor = DummyControl::New();
 550   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 551   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 552
 553   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 554   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 555
 556   application.GetScene().Add( actor );
 557   application.SendNotification();
 558
 559   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 560
 561   application.SendNotification();
 562   application.Render();
 563
 564   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 565   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 566
 567   application.GetScene().Remove( actor );
 568   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 569
 570   END_TEST;
 571 }
 572
 573 int UtcDaliImageVisualWithEncodedImageBufferRemoved(void)
 574 {
 575   ToolkitTestApplication application;
 576   tet_infoline( "Use Encoded Image Buffer as url" );
 577
 578   TestGlAbstraction& gl = application.GetGlAbstraction();
 579   TraceCallStack& textureTrace = gl.GetTextureTrace();
 580   textureTrace.Enable(true);
 581
 582   EncodedImageBuffer rawBuffer = ConvertFileToEncodedImageBuffer(TEST_LARGE_IMAGE_FILE_NAME);
 583   ImageUrl imageUrl = Dali::Toolkit::Image::GenerateUrl(rawBuffer);
 584   std::string url = imageUrl.GetUrl();
 585
 586   VisualFactory factory = VisualFactory::Get();
 587   DALI_TEST_CHECK( factory );
 588
 589   Property::Map propertyMap;
 590   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 591   propertyMap.Insert( ImageVisual::Property::URL,  url );
 592
 593   Visual::Base visual = factory.CreateVisual( propertyMap );
 594   DALI_TEST_CHECK( visual );
 595
 596   DummyControl actor = DummyControl::New();
 597   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 598   dummyImpl.RegisterVisual(  DummyControl::Property::TEST_VISUAL, visual );
 599
 600   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 601
 602   application.GetScene().Add( actor );
 603   application.SendNotification();
 604
 605   // Wait for decode buffer and make texture.
 606   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 607
 608   application.SendNotification();
 609   application.Render();
 610
 611   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 612   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
 613
 614   tet_infoline( "Delete texture because there is no actor to use decoded texture" );
 615   imageUrl.Reset();
 616   application.GetScene().Remove( actor );
 617   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
 618   application.SendNotification();
 619   application.Render();
 620
 621   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
 622   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
 623
 624   END_TEST;
 625 }
 626
 627 int UtcDaliImageVisualTextureReuse1(void)
 628 {
 629   ToolkitTestApplication application;
 630   tet_infoline( "Request remote image visual with a Property::Map; request a second visual with the same property map - should reuse texture" );
 631
 632   Property::Map propertyMap;
 633   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 634   propertyMap.Insert( ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME );
 635   propertyMap.Insert( ImageVisual::Property::RELEASE_POLICY,  ImageVisual::ReleasePolicy::DETACHED );
 636
 637   TestGlAbstraction& gl = application.GetGlAbstraction();
 638   TraceCallStack& textureTrace = gl.GetTextureTrace();
 639   textureTrace.Enable(true);
 640   TraceCallStack& drawTrace = gl.GetDrawTrace();
 641   drawTrace.Enable(true);
 642
 643   Actor actor = CreateActorWithImageVisual( propertyMap );
 644   application.GetScene().Add( actor );
 645   application.SendNotification();
 646
 647   // Wait for image to load
 648   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 649
 650   application.SendNotification();
 651   application.Render();
 652
 653   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 654   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
 655   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 656   DALI_TEST_EQUALS( drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION );
 657   textureTrace.Reset();
 658   drawTrace.Reset();
 659
 660   Actor actor2 = CreateActorWithImageVisual( propertyMap );
 661   application.GetScene().Add(actor2);
 662
 663   application.SendNotification(); // Send messages to update
 664   application.Render();           // process update and render
 665   application.SendNotification(); // process any signals to event
 666
 667   DALI_TEST_EQUALS( actor2.GetRendererCount(), 1u, TEST_LOCATION );
 668
 669   tet_infoline("Test that 2 draw calls occur with no new texture gens/binds, i.e. both\n"
 670                "draw calls use the same texture as the previous draw call\n" );
 671
 672   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
 673   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION );
 674   // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
 675 //  DALI_TEST_EQUALS( textureTrace.CountMethod("BindTexture"), 0, TEST_LOCATION );
 676
 677   tet_infoline("Test that removing 1 actor doesn't delete the texture\n");
 678
 679   application.GetScene().Remove( actor );
 680   application.SendNotification();
 681   application.Render();
 682
 683   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 684   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
 685
 686   tet_infoline("Test that removing last actor does delete the texture\n");
 687
 688   application.GetScene().Remove( actor2 ); // Detaches remaining ImageVisual
 689   application.SendNotification();
 690   application.Render();
 691
 692   DALI_TEST_CHECK( actor2.GetRendererCount() == 0u );
 693   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
 694
 695   END_TEST;
 696 }
 697
 698
 699 int UtcDaliImageVisualTextureReuse2(void)
 700 {
 701   ToolkitTestApplication application;
 702   tet_infoline( "Request remote image visual with a Property::Map; request a second visual with the same url but different property map - should create new texture" );
 703
 704   Property::Map propertyMap;
 705   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 706   propertyMap.Insert( ImageVisual::Property::URL, TEST_REMOTE_IMAGE_FILE_NAME );
 707
 708   TestGlAbstraction& gl = application.GetGlAbstraction();
 709   TraceCallStack& textureTrace = gl.GetTextureTrace();
 710   textureTrace.Enable(true);
 711   TraceCallStack& drawTrace = gl.GetDrawTrace();
 712   drawTrace.Enable(true);
 713
 714   Actor actor = CreateActorWithImageVisual( propertyMap );
 715   application.GetScene().Add( actor );
 716   application.SendNotification();
 717
 718   // Wait for image to load
 719   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 720
 721   application.SendNotification();
 722   application.Render();
 723
 724   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 725   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
 726   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 727   DALI_TEST_EQUALS( drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION );
 728   textureTrace.Reset();
 729   drawTrace.Reset();
 730
 731   propertyMap.Insert( ImageVisual::Property::SAMPLING_MODE, Dali::SamplingMode::NEAREST );
 732   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, 100 );
 733   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, 100 );
 734   Actor actor2 = CreateActorWithImageVisual( propertyMap );
 735   application.GetScene().Add(actor2);
 736
 737   application.SendNotification();
 738
 739   // Wait for image to load
 740   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 741
 742   application.SendNotification();
 743   application.Render();
 744
 745   DALI_TEST_EQUALS( actor2.GetRendererCount(), 1u, TEST_LOCATION );
 746
 747   tet_infoline("Test that 2 draw calls occur with 1 new texture gen/bind, i.e. both "
 748                "renderers are using different textures\n" );
 749
 750   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
 751   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION );
 752   TraceCallStack::NamedParams tex1;
 753   tex1["texture"] << 1;
 754   TraceCallStack::NamedParams tex2;
 755   tex2["texture"] << 2;
 756   DALI_TEST_EQUALS( textureTrace.FindMethodAndParams("BindTexture", tex1), true, TEST_LOCATION );
 757   DALI_TEST_EQUALS( textureTrace.FindMethodAndParams("BindTexture", tex2), true, TEST_LOCATION );
 758
 759   tet_infoline("Test that removing 1 actor deletes it's texture\n");
 760
 761   application.GetScene().Remove( actor );
 762   application.SendNotification();
 763   application.Render();
 764
 765   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 766   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
 767
 768   tet_infoline("Test that removing last actor deletes it's texture\n");
 769
 770   application.GetScene().Remove( actor2 );
 771   application.SendNotification();
 772   application.Render();
 773
 774   DALI_TEST_CHECK( actor2.GetRendererCount() == 0u );
 775   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 2, TEST_LOCATION );
 776
 777   END_TEST;
 778 }
 779
 780
 781 int UtcDaliImageVisualCustomWrapModePixelArea(void)
 782 {
 783   ToolkitTestApplication application;
 784   tet_infoline( "Request image visual with a Property::Map, test custom wrap mode and pixel area with atlasing" );
 785
 786   static std::vector<UniformData> customUniforms =
 787   {
 788     UniformData("pixelArea", Property::Type::VECTOR4),
 789     UniformData("wrapMode", Property::Type::VECTOR2),
 790   };
 791
 792   TestGraphicsController& graphics = application.GetGraphicsController();
 793   graphics.AddCustomUniforms(customUniforms);
 794
 795   VisualFactory factory = VisualFactory::Get();
 796   DALI_TEST_CHECK( factory );
 797
 798   // Test wrap mode with atlasing. Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 799   const int width=34;
 800   const int height=34;
 801   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
 802
 803   Property::Map propertyMap;
 804   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 805   propertyMap.Insert( ImageVisual::Property::URL, TEST_SMALL_IMAGE_FILE_NAME );
 806   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, width );
 807   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, height );
 808   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
 809   propertyMap.Insert( ImageVisual::Property::PIXEL_AREA, pixelArea );
 810   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT );
 811   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT );
 812   propertyMap.Insert( ImageVisual::Property::ATLASING, true );
 813
 814   Visual::Base visual = factory.CreateVisual( propertyMap );
 815   DALI_TEST_CHECK( visual );
 816
 817   TestGlAbstraction& gl = application.GetGlAbstraction();
 818   TraceCallStack& textureTrace = gl.GetTextureTrace();
 819   textureTrace.Enable(true);
 820   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
 821   texParameterTrace.Enable( true );
 822
 823   DummyControl actor = DummyControl::New();
 824   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 825   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 826   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
 827   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
 828   application.GetScene().Add( actor );
 829
 830   // loading started
 831   application.SendNotification();
 832   application.Render();
 833
 834   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 835
 836   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 837
 838   // WITH atlasing, the wrapping is handled manually in shader, so the following gl function should not be called
 839   std::stringstream out;
 840   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
 841   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
 842   out.str("");
 843   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
 844   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
 845
 846   // test the uniforms which used to handle the wrap mode
 847   Renderer renderer = actor.GetRendererAt( 0u );
 848   DALI_TEST_CHECK( renderer );
 849
 850   Property::Value pixelAreaValue = renderer.GetProperty( renderer.GetPropertyIndex( "pixelArea" ) );
 851   DALI_TEST_EQUALS( pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION );
 852   Vector4 pixelAreaUniform;
 853   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "pixelArea", pixelAreaUniform ) );
 854   DALI_TEST_EQUALS( pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 855
 856   Property::Value wrapModeValue = renderer.GetProperty( renderer.GetPropertyIndex( "wrapMode" ) );
 857   Vector2 wrapMode( WrapMode::MIRRORED_REPEAT-1, WrapMode::REPEAT-1 );
 858   DALI_TEST_EQUALS( wrapModeValue.Get<Vector2>(), wrapMode, TEST_LOCATION );
 859   Vector2 wrapModeUniform;
 860   DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "wrapMode", wrapModeUniform ) );
 861   DALI_TEST_EQUALS( wrapMode, wrapModeUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 862
 863   actor.Unparent( );
 864   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 865
 866   END_TEST;
 867 }
 868
 869 int UtcDaliImageVisualCustomWrapModeNoAtlas(void)
 870 {
 871   ToolkitTestApplication application;
 872   tet_infoline( "Request image visual with a Property::Map, test custom wrap mode and pixel area without atlasing" );
 873
 874   static std::vector<UniformData> customUniforms =
 875   {
 876     UniformData("pixelArea", Property::Type::VECTOR4),
 877   };
 878
 879   TestGraphicsController& graphics = application.GetGraphicsController();
 880   graphics.AddCustomUniforms(customUniforms);
 881
 882   VisualFactory factory = VisualFactory::Get();
 883   DALI_TEST_CHECK( factory );
 884
 885   // Test wrap mode without atlasing. Image with a size bigger than 512*512 will NOT be uploaded as a part of the atlas.
 886   const int width=600;
 887   const int height=600;
 888   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
 889
 890   Property::Map propertyMap;
 891   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
 892   propertyMap.Insert( ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME );
 893   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH, width );
 894   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT, height );
 895   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
 896   propertyMap.Insert( ImageVisual::Property::PIXEL_AREA, pixelArea );
 897   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT );
 898   propertyMap.Insert( ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT );
 899
 900   Visual::Base visual = factory.CreateVisual( propertyMap );
 901   DALI_TEST_CHECK( visual );
 902
 903   TestGlAbstraction& gl = application.GetGlAbstraction();
 904   TraceCallStack& textureTrace = gl.GetTextureTrace();
 905   textureTrace.Enable(true);
 906   textureTrace.EnableLogging(true);
 907   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
 908   texParameterTrace.Enable( true );
 909   texParameterTrace.EnableLogging( true );
 910
 911   DummyControl actor = DummyControl::New();
 912   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 913   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 914   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
 915   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
 916   application.GetScene().Add( actor );
 917
 918   // loading started
 919   application.SendNotification();
 920   application.Render();
 921   application.SendNotification();
 922
 923   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 924
 925   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 926
 927   // WITHOUT atlasing, the wrapping is handled by setting gl texture parameters
 928   std::stringstream out;
 929   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
 930   DALI_TEST_CHECK( texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
 931   out.str("");
 932   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
 933   DALI_TEST_CHECK( texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
 934
 935   // test the uniforms which used to handle the wrap mode
 936   Renderer renderer = actor.GetRendererAt( 0u );
 937   DALI_TEST_CHECK( renderer );
 938
 939   Property::Value pixelAreaValue = renderer.GetProperty( renderer.GetPropertyIndex( "pixelArea" ) );
 940   DALI_TEST_EQUALS( pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION );
 941   Vector4 pixelAreaUniform;
 942   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "pixelArea", pixelAreaUniform ) );
 943   DALI_TEST_EQUALS( pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 944
 945   Property::Index wrapModeIndex = renderer.GetPropertyIndex( "wrapMode" );
 946   DALI_TEST_CHECK(wrapModeIndex == Property::INVALID_INDEX);
 947
 948   actor.Unparent();
 949   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 950
 951   END_TEST;
 952 }
 953
 954 int UtcDaliImageVisualAnimateMixColor(void)
 955 {
 956   ToolkitTestApplication application;
 957   tet_infoline( "Animate mix color" );
 958
 959   static std::vector<UniformData> customUniforms =
 960   {
 961     UniformData("mixColor", Property::Type::VECTOR3),
 962   };
 963
 964   TestGraphicsController& graphics = application.GetGraphicsController();
 965   graphics.AddCustomUniforms(customUniforms);
 966
 967   application.GetPlatform().SetClosestImageSize( Vector2(100, 100) );
 968
 969   VisualFactory factory = VisualFactory::Get();
 970   Property::Map propertyMap;
 971   propertyMap.Insert(Visual::Property::TYPE,  Visual::IMAGE);
 972   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
 973   propertyMap.Insert("mixColor", Color::BLUE);
 974   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
 975   Visual::Base visual = factory.CreateVisual( propertyMap );
 976
 977   DummyControl actor = DummyControl::New(true);
 978   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
 979   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 980
 981   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
 982   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
 983   actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
 984   application.GetScene().Add(actor);
 985
 986   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
 987
 988   Renderer renderer = actor.GetRendererAt(0);
 989   Property::Index index = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
 990   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
 991   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
 992
 993   tet_infoline("Test that the renderer has the mixColor property");
 994   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
 995
 996   const Vector4 TARGET_MIX_COLOR( 1.0f, 0.0f, 0.0f, 0.5f );
 997
 998   Property::Map map;
 999   map["target"] = "testVisual";
1000   map["property"] = "mixColor";
1001   map["initialValue"] = Color::MAGENTA;
1002   map["targetValue"] = TARGET_MIX_COLOR;
1003   map["animator"] = Property::Map()
1004     .Add("alphaFunction", "LINEAR")
1005     .Add("timePeriod", Property::Map()
1006          .Add("delay", 0.0f)
1007          .Add("duration", 4.0f));
1008
1009   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1010
1011   Animation animation = dummyImpl.CreateTransition( transition );
1012
1013   animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1014   animation.Play();
1015
1016   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1017   glAbstraction.EnableEnableDisableCallTrace( true );
1018   TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1019   std::ostringstream blendStr;
1020   blendStr << std::hex << GL_BLEND;
1021
1022   application.SendNotification();
1023   application.Render(0); // Ensure animation starts
1024   application.Render(2000u); // Halfway point
1025   Vector3 testColor( 1.0f, 0.0f, 0.5f );
1026
1027   // uColor.a should be actor's alpha * mixColor.a.
1028   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "uColor", Vector4( 0.5f, 0.5f, 0.5f, 0.75f ) ), true, TEST_LOCATION );
1029   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>( "mixColor", testColor ), true, TEST_LOCATION );
1030
1031   DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
1032
1033   glEnableStack.Reset();
1034
1035   application.Render(2000u); // Halfway point between blue and white
1036
1037   DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
1038   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>( "uColor", Vector4( 1.0f, 1.0f, 1.0f, 0.5f ) ), true, TEST_LOCATION );
1039   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector3>( "mixColor", Vector3( TARGET_MIX_COLOR ) ), true, TEST_LOCATION );
1040
1041   // GL_BLEND should not be changed: Keep enabled
1042   // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
1043 //  DALI_TEST_CHECK( !glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
1044   DALI_TEST_CHECK( !glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
1045
1046   TestMixColor( visual, Visual::Property::MIX_COLOR, TARGET_MIX_COLOR );
1047
1048   END_TEST;
1049 }
1050
1051 int UtcDaliImageVisualAnimateOpacity(void)
1052 {
1053   ToolkitTestApplication application;
1054   tet_infoline( "Animate image visual opacity" );
1055
1056   application.GetPlatform().SetClosestImageSize( Vector2(100, 100) );
1057
1058   VisualFactory factory = VisualFactory::Get();
1059   Property::Map propertyMap;
1060   propertyMap.Insert(Visual::Property::TYPE,  Visual::IMAGE);
1061   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
1062   propertyMap.Insert("opacity", 0.5f);
1063   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1064   Visual::Base visual = factory.CreateVisual( propertyMap );
1065
1066   DummyControl actor = DummyControl::New(true);
1067   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1068   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1069
1070   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
1071   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1072   actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
1073   application.GetScene().Add(actor);
1074
1075   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1076
1077   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1078   glAbstraction.EnableEnableDisableCallTrace( true );
1079   TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1080   std::ostringstream blendStr;
1081   blendStr << std::hex << GL_BLEND;
1082
1083   application.SendNotification();
1084   application.Render();
1085
1086   DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str()) );
1087
1088   {
1089     tet_infoline( "Test that the opacity can be increased to full via animation, and that the blend mode is set appropriately at the start and end of the animation." );
1090
1091     Property::Map map;
1092     map["target"] = "testVisual";
1093     map["property"] = "opacity";
1094     map["targetValue"] = 1.0f;
1095     map["animator"] = Property::Map()
1096       .Add("alphaFunction", "LINEAR")
1097       .Add("timePeriod", Property::Map()
1098            .Add("delay", 0.0f)
1099            .Add("duration", 4.0f));
1100
1101     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1102     Animation animation = dummyImpl.CreateTransition( transition );
1103     animation.Play();
1104
1105     glEnableStack.Reset();
1106
1107     application.SendNotification();
1108     application.Render(0);     // Ensure animation starts
1109     application.Render(2000u); // Halfway point through animation
1110     application.SendNotification(); // Handle any signals
1111
1112     Vector4 color;
1113     DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1114     DALI_TEST_EQUALS( color.a, 0.75f, TEST_LOCATION );
1115
1116     application.Render(2001u); // end
1117     application.SendNotification(); // ensure animation finished signal is sent
1118
1119     DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1120     DALI_TEST_EQUALS( color.a, 1.0f, TEST_LOCATION );
1121
1122     // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
1123 //    DALI_TEST_CHECK( !glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
1124     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
1125   }
1126
1127
1128   {
1129     tet_infoline( "Test that the opacity can be reduced via animation, and that the blend mode is set appropriately at the start and end of the animation." );
1130
1131     Property::Map map;
1132     map["target"] = "testVisual";
1133     map["property"] = Visual::Property::OPACITY;
1134     map["targetValue"] = 0.1f;
1135     map["animator"] = Property::Map()
1136       .Add("alphaFunction", "LINEAR")
1137       .Add("timePeriod", Property::Map()
1138            .Add("delay", 0.0f)
1139            .Add("duration", 4.0f));
1140
1141     Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1142     Animation animation = dummyImpl.CreateTransition( transition );
1143     animation.Play();
1144
1145     glEnableStack.Reset();
1146
1147     application.SendNotification();
1148     application.Render(0);     // Ensure animation starts
1149     application.Render(2000u); // Halfway point
1150     application.SendNotification();
1151
1152     Vector4 color;
1153     DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1154     DALI_TEST_EQUALS( color.a, 0.55f, TEST_LOCATION );
1155
1156     DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
1157
1158     glEnableStack.Reset();
1159
1160     application.Render(2016u); // end
1161     application.SendNotification();
1162
1163     DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1164     DALI_TEST_EQUALS( color.a, 0.1f, TEST_LOCATION );
1165
1166     // GL_BLEND should not be changed: Keep enabled
1167 // @todo
1168 // TODO: Temporarily commented out the line below when caching is disabled. Will need to add it back.
1169 //    DALI_TEST_CHECK( !glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
1170     DALI_TEST_CHECK( !glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
1171   }
1172
1173   END_TEST;
1174 }
1175
1176
1177
1178 int UtcDaliImageVisualAnimateOpacity02(void)
1179 {
1180   ToolkitTestApplication application;
1181   tet_infoline( "Animate image visual opacity" );
1182
1183   application.GetPlatform().SetClosestImageSize( Vector2(100, 100) );
1184
1185   VisualFactory factory = VisualFactory::Get();
1186   Property::Map propertyMap;
1187   propertyMap.Insert(Visual::Property::TYPE,  Visual::IMAGE);
1188   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
1189   propertyMap.Insert("opacity", 0.5f);
1190   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1191   Visual::Base visual = factory.CreateVisual( propertyMap );
1192
1193   DummyControl actor = DummyControl::New(true);
1194   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1195   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1196
1197   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
1198   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1199   actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
1200
1201   tet_infoline( "Test that the opacity doesn't animate when actor not staged" );
1202
1203   Property::Array array;
1204
1205   Property::Map map;
1206   map["target"] = "testVisual";
1207   map["property"] = "opacity";
1208   map["initialValue"] = 0.0f;
1209   map["targetValue"] = 1.0f;
1210   map["animator"] = Property::Map()
1211     .Add("alphaFunction", "LINEAR")
1212     .Add("timePeriod", Property::Map()
1213          .Add("delay", 0.0f)
1214          .Add("duration", 4.0f));
1215
1216   Property::Map map2;
1217   map2["target"] = "testVisual";
1218   map2["property"] = "size";
1219   map2["targetValue"] = Vector2(1.0f, 1.0f);
1220
1221   array.Add( map ).Add(map2);
1222
1223   Dali::Toolkit::TransitionData transition = TransitionData::New( array );
1224   Animation animation = dummyImpl.CreateTransition( transition );
1225
1226   application.GetScene().Add(actor);
1227   application.SendNotification();
1228   application.Render(0);     // Ensure animation starts
1229
1230   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1231
1232   Renderer renderer = actor.GetRendererAt(0);
1233   Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
1234   DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
1235
1236   animation = dummyImpl.CreateTransition( transition );
1237   animation.Play();
1238
1239   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1240   glAbstraction.EnableEnableDisableCallTrace( true );
1241   TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1242   std::ostringstream blendStr;
1243   blendStr << std::hex << GL_BLEND;
1244
1245   application.SendNotification();
1246   application.Render(0);     // Ensure animation starts
1247   application.Render(2000u); // Halfway point through animation
1248   application.SendNotification(); // Handle any signals
1249
1250   DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
1251
1252   Vector4 color;
1253   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1254   DALI_TEST_EQUALS( color.a, 0.5f, TEST_LOCATION );
1255
1256   glEnableStack.Reset();
1257
1258   application.Render(2001u); // end
1259   application.SendNotification(); // ensure animation finished signal is sent
1260
1261   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue< Vector4 >( "uColor", color ) );
1262   DALI_TEST_EQUALS( color.a, 1.0f, TEST_LOCATION );
1263
1264   DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Disable", blendStr.str() ) );
1265
1266   END_TEST;
1267 }
1268
1269
1270
1271 int UtcDaliImageVisualAnimatePixelArea(void)
1272 {
1273   ToolkitTestApplication application;
1274   tet_infoline( "ImageVisual animate pixel area" );
1275
1276   static std::vector<UniformData> customUniforms =
1277   {
1278     UniformData("pixelArea", Property::Type::VECTOR4),
1279   };
1280
1281   TestGraphicsController& graphics = application.GetGraphicsController();
1282   graphics.AddCustomUniforms(customUniforms);
1283
1284   application.GetPlatform().SetClosestImageSize( Vector2(100, 100) );
1285
1286   VisualFactory factory = VisualFactory::Get();
1287   Property::Map propertyMap;
1288   propertyMap.Insert(Visual::Property::TYPE,  Visual::IMAGE);
1289   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
1290   propertyMap.Insert("mixColor", Color::BLUE);
1291   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1292   Visual::Base visual = factory.CreateVisual( propertyMap );
1293
1294   DummyControl actor = DummyControl::New(true);
1295   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1296   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1297
1298   actor.SetProperty( Actor::Property::SIZE, Vector2(2000, 2000) );
1299   actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1300   actor.SetProperty( Actor::Property::COLOR,Color::BLACK);
1301   application.GetScene().Add(actor);
1302
1303   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
1304
1305   Renderer renderer = actor.GetRendererAt(0);
1306   Property::Index index = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1307
1308   tet_infoline("Test that the renderer has the mixColor property");
1309   DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1310
1311   // TransitionData only takes string keys
1312   Property::Map map;
1313   map["target"] = "testVisual";
1314   map["property"] = "pixelArea";
1315   map["initialValue"] = Vector4( 0,0,0,1 );
1316   map["targetValue"] = Vector4( 0,0,1,1 ); // Animate width from zero to full
1317   map["animator"] = Property::Map()
1318     .Add("alphaFunction", "LINEAR")
1319     .Add("timePeriod", Property::Map()
1320          .Add("delay", 0.0f)
1321          .Add("duration", 4.0f));
1322
1323   Dali::Toolkit::TransitionData transition = TransitionData::New( map );
1324
1325   Animation animation = dummyImpl.CreateTransition( transition );
1326   animation.AnimateTo( Property(actor, Actor::Property::COLOR), Color::WHITE );
1327   animation.Play();
1328
1329   application.SendNotification();
1330   application.Render(0);     // Ensure animation starts
1331   application.Render(2000u); // Halfway point
1332
1333   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", Vector4(0.0f, 0.0f, 0.5f, 1.0f )), true, TEST_LOCATION );
1334
1335   application.Render(2000u); // End of animation
1336
1337   DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", Vector4( 0.0f, 0.0f, 1.0f, 1.0f )), true, TEST_LOCATION );
1338
1339   END_TEST;
1340 }
1341
1342 int UtcDaliImageVisualTextureCancelRemoteLoad(void)
1343 {
1344   ToolkitTestApplication application;
1345   tet_infoline( "Request remote image visual, then destroy visual to cancel load" );
1346
1347   Property::Map propertyMap;
1348   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1349   propertyMap.Insert( ImageVisual::Property::URL, TEST_REMOTE_IMAGE_FILE_NAME );
1350
1351   TestGlAbstraction& gl = application.GetGlAbstraction();
1352   TraceCallStack& textureTrace = gl.GetTextureTrace();
1353   textureTrace.Enable(true);
1354   TraceCallStack& drawTrace = gl.GetDrawTrace();
1355   drawTrace.Enable(true);
1356
1357   Actor actor = CreateActorWithImageVisual( propertyMap );
1358   application.GetScene().Add( actor );
1359   application.SendNotification();
1360
1361   application.GetScene().Remove( actor );
1362   application.SendNotification();
1363
1364   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1365   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
1366   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), false, TEST_LOCATION );
1367   DALI_TEST_EQUALS( drawTrace.FindMethod("DrawArrays"), false, TEST_LOCATION );
1368
1369   END_TEST;
1370 }
1371
1372 int UtcDaliImageVisualTextureCancelAsyncLoad(void)
1373 {
1374   ToolkitTestApplication application;
1375   tet_infoline( "Load image asynchronously, cancel loading, then load again" );
1376
1377   VisualFactory factory = VisualFactory::Get();
1378   DALI_TEST_CHECK( factory );
1379
1380   Property::Map propertyMap;
1381   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1382   propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
1383
1384   Visual::Base visual = factory.CreateVisual( propertyMap );
1385   DALI_TEST_CHECK( visual );
1386
1387   TestGlAbstraction& gl = application.GetGlAbstraction();
1388   TraceCallStack& textureTrace = gl.GetTextureTrace();
1389   textureTrace.Enable( true );
1390   TraceCallStack& drawTrace = gl.GetDrawTrace();
1391   drawTrace.Enable( true );
1392
1393   DummyControl actor = DummyControl::New();
1394   DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
1395   dummyImpl.RegisterVisual( Control::Property::BACKGROUND, visual );
1396
1397   application.GetScene().Add( actor );
1398
1399   // Cancel loading
1400   application.GetScene().Remove( actor );
1401
1402   application.GetScene().Add( actor );
1403
1404   // Create another visual with the same image
1405   visual = factory.CreateVisual( propertyMap );
1406   DALI_TEST_CHECK( visual );
1407
1408   dummyImpl.RegisterVisual( Control::Property::BACKGROUND, visual );
1409
1410   application.SendNotification();
1411   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1412
1413   application.SendNotification();
1414   application.Render();
1415
1416   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1417   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
1418   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1419   DALI_TEST_EQUALS( drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION );
1420
1421   END_TEST;
1422 }
1423
1424 int UtcDaliImageVisualSetInvalidAsyncImage(void)
1425 {
1426   ToolkitTestApplication application;
1427   tet_infoline( "Request image visual with invalid images - should draw broken.png" );
1428
1429   VisualFactory factory = VisualFactory::Get();
1430   DALI_TEST_CHECK( factory );
1431
1432   Property::Map propertyMap;
1433   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::IMAGE );
1434   propertyMap.Insert( ImageVisual::Property::URL, TEST_INVALID_FILE_NAME );
1435
1436   Visual::Base visual = factory.CreateVisual( propertyMap );
1437   DALI_TEST_CHECK( visual );
1438
1439   TestGlAbstraction& gl = application.GetGlAbstraction();
1440   TraceCallStack& textureTrace = gl.GetTextureTrace();
1441   textureTrace.Enable(true);
1442
1443   DummyControl actor = DummyControl::New();
1444   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1445   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1446
1447   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1448   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1449
1450   application.GetScene().Add( actor );
1451
1452   application.SendNotification();
1453   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1454
1455   application.SendNotification();
1456   application.Render();
1457
1458   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1459   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1460
1461   application.GetScene().Remove( actor );
1462   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1463
1464   END_TEST;
1465 }
1466
1467 int UtcDaliImageVisualSetInvalidSyncImage(void)
1468 {
1469   ToolkitTestApplication application;
1470   tet_infoline( "Request image visual with invalid images - should draw broken.png" );
1471
1472   VisualFactory factory = VisualFactory::Get();
1473   DALI_TEST_CHECK( factory );
1474
1475   Property::Map propertyMap;
1476   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::IMAGE );
1477   propertyMap.Insert( ImageVisual::Property::URL, TEST_INVALID_FILE_NAME );
1478   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
1479
1480   Visual::Base visual = factory.CreateVisual( propertyMap );
1481   DALI_TEST_CHECK( visual );
1482
1483   TestGlAbstraction& gl = application.GetGlAbstraction();
1484   TraceCallStack& textureTrace = gl.GetTextureTrace();
1485   textureTrace.Enable(true);
1486
1487   DummyControl actor = DummyControl::New();
1488   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1489   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1490
1491   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1492   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1493
1494   application.GetScene().Add( actor );
1495
1496   application.SendNotification();
1497   application.Render();
1498
1499   // Check resource status
1500   Visual::ResourceStatus status = actor.GetVisualResourceStatus(Control::CONTROL_PROPERTY_END_INDEX + 1);
1501   DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
1502
1503   // The broken image should be shown.
1504   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1505   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1506
1507   application.GetScene().Remove( actor );
1508   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1509
1510   END_TEST;
1511 }
1512
1513 int UtcDaliImageVisualSetInvalidRemoteImage(void)
1514 {
1515   ToolkitTestApplication application;
1516   tet_infoline( "Request image visual with invalid images - should draw broken.png" );
1517
1518   VisualFactory factory = VisualFactory::Get();
1519   DALI_TEST_CHECK( factory );
1520
1521   // Local invalid file, asynchronous loading
1522   Property::Map propertyMap;
1523   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::IMAGE );
1524   propertyMap.Insert( ImageVisual::Property::URL, TEST_REMOTE_INVALID_FILE_NAME );
1525
1526   Visual::Base visual = factory.CreateVisual( propertyMap );
1527   DALI_TEST_CHECK( visual );
1528
1529   TestGlAbstraction& gl = application.GetGlAbstraction();
1530   TraceCallStack& textureTrace = gl.GetTextureTrace();
1531   textureTrace.Enable(true);
1532
1533   DummyControl actor = DummyControl::New();
1534   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1535   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1536
1537   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1538   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1539
1540   application.GetScene().Add( actor );
1541
1542   application.SendNotification();
1543   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1544
1545   application.SendNotification();
1546   application.Render();
1547
1548   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1549   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1550
1551   application.GetScene().Remove( actor );
1552   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1553
1554   END_TEST;
1555 }
1556
1557 int UtcDaliImageVisualAlphaMask(void)
1558 {
1559   ToolkitTestApplication application;
1560   tet_infoline( "Request image visual with a Property::Map containing an Alpha mask" );
1561
1562   VisualFactory factory = VisualFactory::Get();
1563   DALI_TEST_CHECK( factory );
1564
1565   Property::Map propertyMap;
1566   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1567   propertyMap.Insert( ImageVisual::Property::URL,  TEST_LARGE_IMAGE_FILE_NAME );
1568   propertyMap.Insert( ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME );
1569
1570   Visual::Base visual = factory.CreateVisual( propertyMap );
1571   DALI_TEST_CHECK( visual );
1572
1573   Property::Map testMap;
1574   visual.CreatePropertyMap(testMap);
1575   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL),Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION );
1576
1577   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1578   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1579
1580   TestGlAbstraction& gl = application.GetGlAbstraction();
1581   TraceCallStack& textureTrace = gl.GetTextureTrace();
1582   textureTrace.Enable(true);
1583
1584   DummyControl actor = DummyControl::New();
1585   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1586   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1587
1588   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1589   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1590   DALI_TEST_EQUALS( actor.IsResourceReady(), false, TEST_LOCATION );
1591
1592   application.GetScene().Add( actor );
1593   application.SendNotification();
1594   application.Render();
1595
1596   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
1597
1598   application.SendNotification();
1599   application.Render();
1600
1601   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1602   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1603   DALI_TEST_EQUALS( actor.IsResourceReady(), true, TEST_LOCATION );
1604
1605   dummyImpl.UnregisterVisual(  Control::CONTROL_PROPERTY_END_INDEX + 1 );
1606   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1607
1608   END_TEST;
1609 }
1610
1611 int UtcDaliImageVisualSynchronousLoadAlphaMask(void)
1612 {
1613   ToolkitTestApplication application;
1614   tet_infoline( "Request image visual with a Property::Map containing an Alpha mask with synchronous loading" );
1615
1616   VisualFactory factory = VisualFactory::Get();
1617   DALI_TEST_CHECK( factory );
1618
1619   Property::Map propertyMap;
1620   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1621   propertyMap.Insert( ImageVisual::Property::URL,  TEST_LARGE_IMAGE_FILE_NAME );
1622   propertyMap.Insert( ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME );
1623   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
1624
1625   Visual::Base visual = factory.CreateVisual( propertyMap );
1626   DALI_TEST_CHECK( visual );
1627
1628   Property::Map testMap;
1629   visual.CreatePropertyMap(testMap);
1630   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL),Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION );
1631
1632   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1633   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1634
1635   TestGlAbstraction& gl = application.GetGlAbstraction();
1636   TraceCallStack& textureTrace = gl.GetTextureTrace();
1637   textureTrace.Enable(true);
1638
1639   DummyControl actor = DummyControl::New();
1640   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1641   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1642
1643   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1644   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1645   DALI_TEST_EQUALS( actor.IsResourceReady(), false, TEST_LOCATION );
1646
1647   application.GetScene().Add( actor );
1648
1649   // Do not wait for any EventThreadTrigger in synchronous alpha mask.
1650
1651   application.SendNotification();
1652   application.Render();
1653
1654   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1655   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1656   DALI_TEST_EQUALS( actor.IsResourceReady(), true, TEST_LOCATION );
1657
1658   dummyImpl.UnregisterVisual(  Control::CONTROL_PROPERTY_END_INDEX + 1 );
1659   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1660
1661   END_TEST;
1662 }
1663
1664 int UtcDaliImageVisualRemoteAlphaMask(void)
1665 {
1666   ToolkitTestApplication application;
1667   tet_infoline( "Request image visual with a Property::Map containing an Alpha mask" );
1668
1669   VisualFactory factory = VisualFactory::Get();
1670   DALI_TEST_CHECK( factory );
1671
1672   const std::string MASK_IMAGE = TEST_REMOTE_IMAGE_FILE_NAME;
1673
1674   Property::Map propertyMap;
1675   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1676   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
1677   propertyMap.Insert( ImageVisual::Property::ALPHA_MASK_URL, MASK_IMAGE );
1678
1679   Visual::Base visual = factory.CreateVisual( propertyMap );
1680   DALI_TEST_CHECK( visual );
1681
1682   Property::Map testMap;
1683   visual.CreatePropertyMap(testMap);
1684
1685   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL),Property::Value(MASK_IMAGE), TEST_LOCATION );
1686
1687   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1688   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1689
1690   TestGlAbstraction& gl = application.GetGlAbstraction();
1691   TraceCallStack& textureTrace = gl.GetTextureTrace();
1692   textureTrace.Enable(true);
1693
1694   DummyControl actor = DummyControl::New();
1695   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1696   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1697
1698   DALI_TEST_EQUALS( actor.IsResourceReady(), false, TEST_LOCATION );
1699
1700   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1701   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1702
1703   application.GetScene().Add( actor );
1704   application.SendNotification();
1705   application.Render();
1706
1707   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
1708
1709   application.SendNotification();
1710   application.Render();
1711
1712   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1713   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1714   DALI_TEST_EQUALS( actor.IsResourceReady(), true, TEST_LOCATION );
1715
1716   END_TEST;
1717 }
1718
1719 int UtcDaliImageVisualAlphaMaskCrop(void)
1720 {
1721   ToolkitTestApplication application;
1722   tet_infoline( "Request image visual with an Alpha mask and scale/cropping" );
1723
1724   VisualFactory factory = VisualFactory::Get();
1725   DALI_TEST_CHECK( factory );
1726
1727   Property::Map propertyMap;
1728   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::IMAGE );
1729   propertyMap.Insert( ImageVisual::Property::URL,  TEST_LARGE_IMAGE_FILE_NAME );
1730   propertyMap.Insert( ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME );
1731   propertyMap.Insert( ImageVisual::Property::MASK_CONTENT_SCALE, 1.6f );
1732   propertyMap.Insert( ImageVisual::Property::CROP_TO_MASK, true );
1733
1734   Visual::Base visual = factory.CreateVisual( propertyMap );
1735   DALI_TEST_CHECK( visual );
1736
1737   Property::Map testMap;
1738   visual.CreatePropertyMap(testMap);
1739   DALI_TEST_EQUALS( *testMap.Find(ImageVisual::Property::ALPHA_MASK_URL),Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION );
1740   DALI_TEST_EQUALS( *testMap.Find(ImageVisual::Property::MASK_CONTENT_SCALE), Property::Value(1.6f), TEST_LOCATION );
1741   DALI_TEST_EQUALS( *testMap.Find(ImageVisual::Property::CROP_TO_MASK),Property::Value(true), TEST_LOCATION );
1742
1743   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1744   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1745
1746   TestGlAbstraction& gl = application.GetGlAbstraction();
1747   TraceCallStack& textureTrace = gl.GetTextureTrace();
1748   textureTrace.Enable(true);
1749
1750   DummyControl actor = DummyControl::New();
1751   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1752   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
1753
1754   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1755   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1756   DALI_TEST_EQUALS( actor.IsResourceReady(), false, TEST_LOCATION );
1757
1758   application.GetScene().Add( actor );
1759   application.SendNotification();
1760   application.Render();
1761
1762   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
1763
1764   application.SendNotification();
1765   application.Render();
1766
1767   Vector2 size;
1768   visual.GetNaturalSize(size);
1769
1770   DALI_TEST_EQUALS( size, Vector2( 100.0f, 100.0f ), 0.001f, TEST_LOCATION );
1771   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1772   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1773   DALI_TEST_EQUALS( actor.IsResourceReady(), true, TEST_LOCATION );
1774
1775   END_TEST;
1776 }
1777
1778 int UtcDaliImageVisualReleasePolicy01(void)
1779 {
1780   ToolkitTestApplication application;
1781   tet_infoline( "UtcDaliImageVisualReleasePolicy01 Detached Policy, disabling visual with this policy deletes texture" );
1782
1783   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DETACHED );
1784   DALI_TEST_CHECK( imageVisual );
1785
1786   // Set up debug trace
1787   TestGlAbstraction& gl = application.GetGlAbstraction();
1788   TraceCallStack& textureTrace = gl.GetTextureTrace();
1789   textureTrace.Enable(true);
1790
1791   tet_infoline( "Register visual with control and ensure it has the only handle" );
1792   DummyControl actor = DummyControl::New(true);
1793   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1794   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
1795   imageVisual.Reset();
1796
1797   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
1798
1799   application.SendNotification();
1800   application.Render(0);
1801   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1802   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
1803
1804   application.GetScene().Add( actor );
1805
1806   // Wait for image to load
1807   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1808
1809   application.SendNotification();
1810   application.Render(0);
1811   // Test renderer and texture created
1812   tet_infoline( "Confirm texture created" );
1813   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1814   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
1815
1816   tet_infoline( "Disable visual causing the texture to be deleted" );
1817   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
1818
1819   application.SendNotification();
1820   application.Render(0);
1821   // Test renderer and textures removed.
1822   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1823   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
1824
1825   END_TEST;
1826 }
1827
1828 int UtcDaliImageVisualReleasePolicy02(void)
1829 {
1830   ToolkitTestApplication application;
1831   tet_infoline( "UtcDaliImageVisualReleasePolicy02 Destroyed Policy, Texture should be deleted when visual destroyed" );
1832
1833   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED );
1834   DALI_TEST_CHECK( imageVisual );
1835
1836   // Setup debug trace
1837   TestGlAbstraction& gl = application.GetGlAbstraction();
1838   TraceCallStack& textureTrace = gl.GetTextureTrace();
1839   textureTrace.Enable(true);
1840
1841   tet_infoline( "Register visual with control and ensure it has the only handle" );
1842   DummyControl actor = DummyControl::New(true);
1843   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1844   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
1845   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
1846
1847   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
1848
1849   application.SendNotification();
1850   application.Render(0);
1851   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1852   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
1853
1854   application.GetScene().Add( actor );
1855
1856   // Wait for image to load
1857   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1858
1859   application.SendNotification();
1860   application.Render(0);
1861   // Test renderer and texture created
1862   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1863   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
1864
1865
1866   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1867   tet_infoline( "Destroy visual by UnRegistering visual with control, check renderer is destroyed" );
1868   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
1869   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1870   application.SendNotification();
1871   application.Render();
1872
1873   // Test texture removed after visual destroyed.
1874   tet_infoline( "Ensure texture is deleted after visual destroyed" );
1875   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
1876
1877   END_TEST;
1878 }
1879
1880 int UtcDaliImageVisualReleasePolicy03(void)
1881 {
1882   ToolkitTestApplication application;
1883   tet_infoline( "UtcDaliImageVisualReleasePolicy03 Never Policy, texture should not be deleted after visual destroyed" );
1884
1885   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER );
1886   DALI_TEST_CHECK( imageVisual );
1887
1888   TestGlAbstraction& gl = application.GetGlAbstraction();
1889   TraceCallStack& textureTrace = gl.GetTextureTrace();
1890   textureTrace.Enable(true);
1891
1892   tet_infoline( "Register visual with control and ensure it has the only handle" );
1893   DummyControl actor = DummyControl::New(true);
1894   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1895   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
1896   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
1897
1898   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
1899
1900   application.SendNotification();
1901   application.Render(0);
1902   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1903   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
1904
1905   application.GetScene().Add( actor );
1906
1907   // Wait for image to load
1908   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1909
1910   application.SendNotification();
1911   application.Render(0);
1912   // Test renderer and texture created
1913   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1914   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
1915
1916   tet_infoline( "Destroy visual by UnRegistering visual with control, check renderer is destroyed" );
1917   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1918   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
1919   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1920   application.SendNotification();
1921   application.Render();
1922
1923   tet_infoline( "Ensure texture is not deleted as policy is set to NEVER" );
1924   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
1925
1926   END_TEST;
1927 }
1928
1929 int UtcDaliImageVisualReleasePolicy04(void)
1930 {
1931   ToolkitTestApplication application;
1932   tet_infoline( "UtcDaliImageVisualReleasePolicy04 Two visuals with different policies sharing a texture" );
1933
1934   tet_infoline( "Create first visual with Never release policy" );
1935   Visual::Base imageVisualNever = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER );
1936
1937   tet_infoline( "Create second visual with Destroyed release policy");
1938     Visual::Base imageVisualDestroyed = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED );
1939
1940   // Set up trace debug
1941   TestGlAbstraction& gl = application.GetGlAbstraction();
1942   TraceCallStack& textureTrace = gl.GetTextureTrace();
1943   textureTrace.Enable(true);
1944
1945   tet_infoline( "Register visuals with control and ensure it has the only handles" );
1946   DummyControl actor = DummyControl::New(true);
1947   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1948   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisualNever );
1949   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, imageVisualDestroyed );
1950   imageVisualNever.Reset(); // reduce ref count so only the control keeps the visual alive.
1951   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
1952
1953   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
1954
1955   // Test initially zero renderers
1956   application.SendNotification();
1957   application.Render(0);
1958   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1959   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
1960
1961   application.GetScene().Add( actor );
1962
1963   // Wait for image to load
1964   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1965
1966   application.SendNotification();
1967   application.Render(0);
1968   tet_infoline( "Ensure a texture is created, shared amongst both visuals.  Each visual has its own renderer" );
1969   DALI_TEST_EQUALS( actor.GetRendererCount(), 2u, TEST_LOCATION );
1970   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
1971
1972   // Test renderer removed when visual destroyed
1973   DALI_TEST_CHECK( actor.GetRendererCount() == 2u );
1974   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL2 );  // TEST_VISUAL2 no longer requires the texture as release policy DESTROYED
1975   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1976   application.SendNotification();
1977   application.Render();
1978
1979   // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
1980   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
1981
1982   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
1983   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1984   application.SendNotification();
1985   application.Render();
1986
1987   tet_infoline( "Ensure a texture is not deleted as second visual used the NEVER release policy" );
1988   // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
1989   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
1990
1991   END_TEST;
1992 }
1993
1994 int UtcDaliImageVisualReleasePolicy05(void)
1995 {
1996   ToolkitTestApplication application;
1997   tet_infoline( "UtcDaliImageVisualReleasePolicy05 Testing settung by string currents correct enum" );
1998
1999   VisualFactory factory = VisualFactory::Get();
2000
2001   Property::Map propertyMapNeverReleasePolicy;
2002   propertyMapNeverReleasePolicy.Insert( Visual::Property::TYPE,  Visual::IMAGE );
2003   propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
2004   propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
2005   propertyMapNeverReleasePolicy.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
2006   propertyMapNeverReleasePolicy.Insert( "releasePolicy" , "never" );
2007
2008   Visual::Base imageVisualNever = factory.CreateVisual( propertyMapNeverReleasePolicy );
2009
2010   Property::Map resultMap;
2011   imageVisualNever.CreatePropertyMap( resultMap );
2012   DALI_TEST_CHECK( ! resultMap.Empty() );
2013
2014   DALI_TEST_EQUALS( ( resultMap.Find( ImageVisual::Property::RELEASE_POLICY ) )->Get<int>(), (int)ImageVisual::ReleasePolicy::NEVER, TEST_LOCATION );
2015
2016   END_TEST;
2017 }
2018
2019 int UtcDaliImageVisualReleasePolicy06(void)
2020 {
2021   ToolkitTestApplication application;
2022   tet_infoline( "UtcDaliImageVisualReleasePolicy06 Never Policy, texture should not be affected by Disabling and Enabling visual" );
2023
2024   Visual::Base imageVisual= CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER );
2025   DALI_TEST_CHECK( imageVisual );
2026
2027   TestGlAbstraction& gl = application.GetGlAbstraction();
2028   TraceCallStack& textureTrace = gl.GetTextureTrace();
2029   textureTrace.Enable(true);
2030
2031   tet_infoline( "Register visual with control and ensure it has the only handle" );
2032   DummyControl actor = DummyControl::New(true);
2033   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2034   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2035   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2036
2037   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2038
2039   application.SendNotification();
2040   application.Render(0);
2041   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2042   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2043
2044   application.GetScene().Add( actor );
2045
2046   // Wait for image to load
2047   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2048
2049   application.SendNotification();
2050   application.Render(0);
2051   // Test renderer and texture created
2052   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
2053   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2054   textureTrace.Reset();
2055
2056   tet_infoline( "Disable Visual and check texture not affected" );
2057   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
2058   application.SendNotification();
2059   application.Render(0);
2060   tet_infoline( "Check renderer is destroyed when visual off stage" );
2061   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2062   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
2063   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2064   textureTrace.Reset();
2065
2066   tet_infoline( "Re-enable Visual and check texture not affected" );
2067   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, true );
2068   application.SendNotification();
2069   application.Render(0);
2070   tet_infoline( "Check texture not affected and renderer is destroyed when visual off stage" );
2071   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2072   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
2073   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2074
2075   END_TEST;
2076 }
2077
2078 int UtcDaliImageVisualReleasePolicy07(void)
2079 {
2080   ToolkitTestApplication application;
2081   tet_infoline( "UtcDaliImageVisualReleasePolicy07 Two visuals with different policies sharing a texture DETACHED and DESTROYED" );
2082
2083   tet_infoline( "Create first visual with DESTROYED release policy" );
2084   Visual::Base imageVisualDestroyed = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED );
2085
2086
2087   tet_infoline( "Create second visual with DETACHED release policy");
2088   Visual::Base imageVisualDetached = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DETACHED );
2089
2090   // Set up trace debug
2091   TestGlAbstraction& gl = application.GetGlAbstraction();
2092   TraceCallStack& textureTrace = gl.GetTextureTrace();
2093   textureTrace.Enable(true);
2094
2095   tet_infoline( "Register visuals with control and ensure it has the only handles" );
2096   DummyControl actor = DummyControl::New(true);
2097   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2098   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisualDestroyed );
2099   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL2, imageVisualDetached );
2100   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
2101   imageVisualDetached.Reset(); // reduce ref count so only the control keeps the visual alive.
2102
2103   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2104
2105   // Test initially zero renderers
2106   application.SendNotification();
2107   application.Render(0);
2108   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2109   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2110
2111   application.GetScene().Add( actor );
2112
2113   // Wait for image to load
2114   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2115
2116   application.SendNotification();
2117   application.Render(0);
2118   tet_infoline( "Ensure a texture is created, shared amongst both visuals.  Each visual has its own renderer" );
2119   DALI_TEST_EQUALS( actor.GetRendererCount(), 2u, TEST_LOCATION );
2120   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2121
2122   // Test renderer removed when visual destroyed
2123   DALI_TEST_CHECK( actor.GetRendererCount() == 2u );
2124   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL2, false );  // TEST_VISUAL2 no longer requires the texture as release policy DETACHED
2125   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2126   application.SendNotification();
2127   application.Render();
2128
2129   // Test texture was not deleted as TEST_VISUAL release policy is DESTROYED and is still required.
2130   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
2131
2132   dummyImpl.EnableVisual( DummyControl::Property::TEST_VISUAL, false );
2133   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2134   application.SendNotification();
2135   application.Render();
2136
2137   tet_infoline( "Ensure a texture is not deleted as second visual used the DESTROYED release policy" );
2138   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
2139
2140   END_TEST;
2141 }
2142
2143 int UtcDaliImageVisualReleasePolicy08(void)
2144 {
2145   ToolkitTestApplication application;
2146   tet_infoline( "UtcDaliImageVisualReleasePolicy08 Ensure TextureSet is same after detach/attach on stage when texture used the DESTROYED release policy" );
2147
2148   tet_infoline( "Create first visual with DESTROYED release policy" );
2149   Visual::Base imageVisualDestroyed = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED );
2150
2151   // Set up trace debug
2152   TestGlAbstraction& gl = application.GetGlAbstraction();
2153   TraceCallStack& textureTrace = gl.GetTextureTrace();
2154   textureTrace.Enable(true);
2155
2156   tet_infoline( "Register visuals with control and ensure it has the only handles" );
2157   DummyControl actor = DummyControl::New(true);
2158   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2159   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisualDestroyed );
2160   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
2161
2162   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2163
2164   // Test initially zero renderers
2165   application.SendNotification();
2166   application.Render(0);
2167   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2168   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2169   textureTrace.Reset();
2170
2171   application.GetScene().Add( actor );
2172
2173   // Wait for image to load
2174   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2175
2176   application.SendNotification();
2177   application.Render(0);
2178   tet_infoline( "Ensure a texture is created" );
2179   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
2180   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2181   textureTrace.Reset();
2182
2183   // Ensure TextureSet is same after detach/attach on stage when texture used the DESTROYED release policy
2184   // 1. Get TextureSet
2185   TextureSet textureSetBefore = actor.GetRendererAt( 0u ).GetTextures();
2186
2187   // 2.Remove actor from stage. In this case, renderer also is deleted.
2188   tet_infoline( "Remove actor from stage" );
2189   application.GetScene().Remove( actor );
2190   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2191   application.SendNotification();
2192   application.Render();
2193
2194   tet_infoline( "Ensure a texture is not deleted as visual used the DESTROYED release policy" );
2195   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION );
2196   textureTrace.Reset();
2197
2198   // 3.Add actor in stage. In this case, renderer is created.
2199   tet_infoline( "Add actor in stage" );
2200   application.GetScene().Add( actor );
2201   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2202   application.SendNotification();
2203   application.Render();
2204   tet_infoline( "Ensure a texture is not created again" );
2205   DALI_TEST_EQUALS( textureTrace.CountMethod("GenTextures"), 0, TEST_LOCATION );
2206   textureTrace.Reset();
2207
2208   // 4.Compare Texture with before and after. textureSet need to be same because release policy is the DESTROYED.
2209   tet_infoline( "Ensure a textureSet is not deleted because it is used the DESTROYED release policy" );
2210   TextureSet textureSetAfter = actor.GetRendererAt( 0u ).GetTextures();
2211   DALI_TEST_CHECK( textureSetBefore == textureSetAfter );
2212   textureSetBefore.Reset();
2213   textureSetAfter.Reset();
2214
2215   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
2216   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2217   application.SendNotification();
2218   application.Render();
2219   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
2220
2221   END_TEST;
2222 }
2223
2224 int UtcDaliImageVisualLoadPolicy01(void)
2225 {
2226   ToolkitTestApplication application;
2227   tet_infoline( "UtcDaliImageVisualLoadPolicy01 Load a visual image before attaching to stage" );
2228
2229   // Set up trace debug
2230   TestGlAbstraction& gl = application.GetGlAbstraction();
2231   TraceCallStack& textureTrace = gl.GetTextureTrace();
2232   textureTrace.Enable(true);
2233
2234   tet_infoline( "Create visual with IMMEDIATE load policy" );
2235   VisualFactory factory = VisualFactory::Get();
2236
2237   Property::Map propertyMap;
2238   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
2239   propertyMap.Insert( ImageVisual::Property::URL,  TEST_IMAGE_FILE_NAME );
2240   propertyMap.Insert( ImageVisual::Property::DESIRED_WIDTH,   20 );
2241   propertyMap.Insert( ImageVisual::Property::DESIRED_HEIGHT,   30 );
2242   propertyMap.Insert( "loadPolicy" , ImageVisual::LoadPolicy::IMMEDIATE );
2243
2244   Visual::Base imageVisual = factory.CreateVisual( propertyMap );
2245
2246   Property::Map resultMap;
2247   imageVisual.CreatePropertyMap( resultMap );
2248   DALI_TEST_CHECK( ! resultMap.Empty() );
2249   DALI_TEST_EQUALS( ( resultMap.Find( ImageVisual::Property::LOAD_POLICY ) )->Get<int>(), (int)ImageVisual::LoadPolicy::IMMEDIATE, TEST_LOCATION );
2250
2251   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2252
2253   // Ensure texture has been uploaded
2254   application.SendNotification();
2255   application.Render();
2256
2257   tet_infoline( "Ensure texture loading starts after visual created" );
2258   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2259   textureTrace.Reset();
2260
2261   tet_infoline( "Register visuals with control and ensure it has the only handles" );
2262   DummyControl actor = DummyControl::New(true);
2263   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2264   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2265   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2266
2267   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2268   application.GetScene().Add( actor );
2269   tet_infoline( "Ensure nothing triggers another load as texure already loaded" );
2270   const unsigned int TIME_OUT_3_SECONDS = 3;
2271   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1, TIME_OUT_3_SECONDS ), false, TEST_LOCATION );
2272
2273   application.SendNotification();
2274   application.Render();
2275
2276   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
2277   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2278
2279   // Ensure texture is deleted when no longer needed (ref count was correct )
2280   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
2281
2282   application.SendNotification();
2283   application.Render();
2284
2285   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
2286   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
2287
2288   END_TEST;
2289 }
2290
2291 int UtcDaliImageVisualLoadPolicy02(void)
2292 {
2293   ToolkitTestApplication application;
2294   tet_infoline( "UtcDaliImageVisualLoadPolicy01 Load a visual image only after attached to stage" );
2295
2296   // Set up trace debug
2297   TestGlAbstraction& gl = application.GetGlAbstraction();
2298   TraceCallStack& textureTrace = gl.GetTextureTrace();
2299   textureTrace.Enable(true);
2300
2301   tet_infoline( "Create visual with IMMEDIATE load policy" );
2302   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED );
2303
2304   const unsigned int TIME_OUT_3_SECONDS = 3;
2305   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1, TIME_OUT_3_SECONDS ), false, TEST_LOCATION );
2306
2307   // Act on meeage queue even although nothing expected to load
2308   application.SendNotification();
2309   application.Render();
2310
2311   tet_infoline( "Ensure texture is not generated yet" );
2312   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION );
2313   textureTrace.Reset();
2314
2315   tet_infoline( "Register visuals with control and ensure it has the only handles" );
2316   DummyControl actor = DummyControl::New(true);
2317   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2318   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2319   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2320
2321   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2322   application.GetScene().Add( actor );
2323   tet_infoline( "Allow image time to load" );
2324   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2325
2326   application.SendNotification();
2327   application.Render();
2328
2329   tet_infoline( "Ensure texture generated and renderer created" );
2330   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
2331   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2332
2333   // Ensure texture is delete when no longer needed
2334   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
2335
2336   application.SendNotification();
2337   application.Render();
2338
2339   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
2340   DALI_TEST_EQUALS( textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION );
2341
2342   END_TEST;
2343 }
2344
2345 int UtcDaliImageVisualLoadPolicy03(void)
2346 {
2347   ToolkitTestApplication application;
2348   tet_infoline( "UtcDaliImageVisualLoadPolicy03 Load a visual image and receive ResourceReady Signal when loaded" );
2349
2350   const bool VISUAL_NOT_ENABLED( false ); // Instead of just passing 'false' into an API.
2351
2352   // Set up trace debug
2353   TestGlAbstraction& gl = application.GetGlAbstraction();
2354   TraceCallStack& textureTrace = gl.GetTextureTrace();
2355   textureTrace.Enable(true);
2356
2357   tet_infoline( "Create a control and connect to resource ready signal without adding to stage" );
2358   DummyControl actor = DummyControl::New(true);
2359   actor.ResourceReadySignal().Connect( &ResourceReadySignal);
2360   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2361   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2362
2363   tet_infoline( "Create visual with IMMEDIATE load policy" );
2364   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE );
2365
2366   tet_infoline( "Registering visual allows control to get a signal once loaded even if visual not enabled( not staged )" );
2367   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual, VISUAL_NOT_ENABLED );
2368   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2369
2370   tet_infoline( "Allow image time to load resource" );
2371   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2372   application.SendNotification();
2373   application.Render();
2374
2375   // Ensure texture has been uploaded
2376   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2377   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2378
2379   END_TEST;
2380 }
2381
2382 int UtcDaliImageVisualLoadPolicy04(void)
2383 {
2384   ToolkitTestApplication application;
2385   tet_infoline( "UtcDaliImageVisualLoadPolicy04 First part  Load a visual image before attaching to stage");
2386   tet_infoline( "Second part, Reuse the same image in aonther control and check resource ready signal fired" );
2387
2388   const bool VISUAL_NOT_ENABLED( false ); // Instead of just passing false into an API.
2389
2390   // Set up trace debug
2391   TestGlAbstraction& gl = application.GetGlAbstraction();
2392   TraceCallStack& textureTrace = gl.GetTextureTrace();
2393   textureTrace.Enable(true);
2394
2395   tet_infoline( "Create a control and connect to resource ready signal" );
2396   DummyControl actor = DummyControl::New(true);
2397   actor.ResourceReadySignal().Connect( &ResourceReadySignal);
2398   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2399   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2400
2401   tet_infoline( "Create visual with IMMEDIATE load policy" );
2402   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE );
2403
2404   tet_infoline( "Registering visual allows control to get a signal once loaded even if visual not enabled( staged )" );
2405   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual, VISUAL_NOT_ENABLED );
2406   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2407
2408   tet_infoline( "Allow image time to load" );
2409   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2410   application.SendNotification();
2411   application.Render();
2412
2413   tet_infoline( "Testing texture is loaded and resource ready signal fired" );
2414   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2415   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2416
2417   tet_infoline( "Original control correctly signalled, now testing for signal with new Control reusing the image" );
2418
2419   gResourceReadySignalFired = false; // Reset signal check ready for testing next Control
2420   Visual::Base imageVisual2 = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE );
2421   DummyControl actor2 = DummyControl::New(true);
2422   Impl::DummyControl& dummyImpl2 = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2423   actor2.ResourceReadySignal().Connect( &ResourceReadySignal);
2424
2425   tet_infoline( "Registering visual this should trigger the loading signal as is already image loaded for previous control" );
2426   dummyImpl2.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual2 );
2427   imageVisual2.Reset(); // reduce ref count so only the control keeps the visual alive.
2428   actor2.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2429   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 0 ), true, TEST_LOCATION ); // Not expecting any further loading as texture is being reused.
2430   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2431
2432   END_TEST;
2433 }
2434
2435 int UtcDaliImageVisualLoadPolicy05(void)
2436 {
2437   ToolkitTestApplication application;
2438   tet_infoline( "UtcDaliImageVisualLoadPolicy05 LoadPolicy::ATTACHED (default) First part  Load a visual image before attaching to stage");
2439   tet_infoline( "Second part, Reuse the same image in aonther control and check resource ready signal fired" );
2440   // Set up trace debug
2441   TestGlAbstraction& gl = application.GetGlAbstraction();
2442   TraceCallStack& textureTrace = gl.GetTextureTrace();
2443   textureTrace.Enable(true);
2444
2445   tet_infoline( "Create a control and connect to resource ready signal" );
2446   DummyControl actor = DummyControl::New(true);
2447   actor.ResourceReadySignal().Connect( &ResourceReadySignal);
2448   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2449   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2450   application.GetScene().Add( actor );
2451
2452   tet_infoline( "Create visual with ATTACHED load policy" );
2453   Visual::Base imageVisual = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED );
2454
2455   tet_infoline( "Registering visual allows control to get a signal once loaded" );
2456   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2457   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2458
2459   tet_infoline( "Allow image time to load" );
2460   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2461   application.SendNotification();
2462   application.Render();
2463
2464   tet_infoline( "Testing texture is loaded and resource ready signal fired" );
2465   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2466   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2467
2468   tet_infoline( "Original control correctly signalled, now testing for signal with new Control reusing the image" );
2469
2470   gResourceReadySignalFired = false; // Reset signal check ready for testing next Control
2471   Visual::Base imageVisual2 = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED );
2472   DummyControl actor2 = DummyControl::New(true);
2473   Impl::DummyControl& dummyImpl2 = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2474   actor2.ResourceReadySignal().Connect( &ResourceReadySignal);
2475
2476   tet_infoline( "Registering visual this should trigger the loading signal as is already image loaded for previous control" );
2477   dummyImpl2.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual2 );
2478   imageVisual2.Reset(); // reduce ref count so only the control keeps the visual alive.
2479   actor2.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2480   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 0 ), true, TEST_LOCATION ); // Not expecting any further loading as texture is being reused.
2481   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2482
2483   END_TEST;
2484 }
2485
2486
2487 int UtcDaliImageVisualOrientationCorrection(void)
2488 {
2489   ToolkitTestApplication application;
2490   tet_infoline( "UtcDaliImageVisualOrientationCorrection Enabling OrientationCorrection should rotate an image with exif (90deg) orientation data with requested" );
2491
2492   VisualFactory factory = VisualFactory::Get();
2493   tet_infoline( "Create visual with Orientation correction set OFF" );
2494   Property::Map propertyMap;
2495   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
2496   propertyMap.Insert( ImageVisual::Property::URL, TEST_ROTATED_IMAGE );
2497   propertyMap.Insert( "orientationCorrection", false );
2498   Visual::Base imageVisual = factory.CreateVisual( propertyMap );
2499
2500   tet_infoline( "Create control for visual, need to loaded it" );
2501   DummyControl actor = DummyControl::New(true);
2502   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2503   application.GetScene().Add( actor );
2504
2505   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2506   // Wait for image to load
2507   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2508
2509   Vector2 originalImageSize;
2510   tet_infoline( "Get size of original visual to compare later with rotated image" );
2511   imageVisual.GetNaturalSize( originalImageSize );
2512   DALI_TEST_GREATER( originalImageSize.width, originalImageSize.height, TEST_LOCATION ); // Width and Height must be different for this test.
2513   imageVisual.Reset();  // remove handle so can unregister it and remove from cache
2514   dummyImpl.UnregisterVisual( DummyControl::Property::TEST_VISUAL );
2515   application.SendNotification();
2516   application.Render();
2517
2518   tet_infoline( "Create visual with Orientation correction set ON " );
2519   propertyMap.Clear();
2520   propertyMap.Insert( Visual::Property::TYPE,  Visual::IMAGE );
2521   propertyMap.Insert( ImageVisual::Property::URL, TEST_ROTATED_IMAGE );
2522   propertyMap.Insert( ImageVisual::Property::ORIENTATION_CORRECTION, true );
2523   imageVisual = factory.CreateVisual( propertyMap );
2524
2525   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual );
2526   // Wait for image to load
2527   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2528
2529   Vector2 rotatedImageSize;
2530   imageVisual.GetNaturalSize( rotatedImageSize );
2531   tet_infoline( "Confirm that visual has rotated" );
2532   DALI_TEST_EQUALS( originalImageSize.width, rotatedImageSize.height , TEST_LOCATION );
2533   DALI_TEST_EQUALS( originalImageSize.height, rotatedImageSize.width , TEST_LOCATION );
2534
2535   Property::Map resultMap;
2536   imageVisual.CreatePropertyMap( resultMap );
2537
2538   // check the Property::ORIENTATION_CORRECTION value from the returned map
2539   Property::Value* typeValue = resultMap.Find( ImageVisual::Property::ORIENTATION_CORRECTION,  Property::BOOLEAN );
2540   DALI_TEST_EQUALS( typeValue->Get<bool>(), true, TEST_LOCATION );
2541
2542   END_TEST;
2543 }
2544
2545 int UtcDaliImageVisualCustomShader(void)
2546 {
2547   ToolkitTestApplication application;
2548   tet_infoline( "UtcDaliImageVisualCustomShader Test custom shader" );
2549
2550   VisualFactory factory = VisualFactory::Get();
2551   Property::Map properties;
2552   Property::Map shader;
2553   const std::string vertexShader = "Foobar";
2554   const std::string fragmentShader = "Foobar";
2555   shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2556   shader[Visual::Shader::Property::VERTEX_SHADER] = vertexShader;
2557
2558   properties[Visual::Property::TYPE] = Visual::IMAGE;
2559   properties[Visual::Property::SHADER] = shader;
2560   properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2561
2562   Visual::Base visual = factory.CreateVisual( properties );
2563
2564   // trigger creation through setting on stage
2565   DummyControl dummy = DummyControl::New( true );
2566   Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummy.GetImplementation() );
2567   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2568
2569   dummy.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
2570   dummy.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
2571   application.GetScene().Add( dummy );
2572
2573   application.SendNotification();
2574   application.Render();
2575
2576   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2577
2578   Renderer renderer = dummy.GetRendererAt( 0 );
2579   Shader shader2 = renderer.GetShader();
2580   Property::Value value = shader2.GetProperty( Shader::Property::PROGRAM );
2581   Property::Map* map = value.GetMap();
2582   DALI_TEST_CHECK( map );
2583
2584   Property::Value* fragment = map->Find( "fragment" ); // fragment key name from shader-impl.cpp
2585   DALI_TEST_EQUALS( fragmentShader, fragment->Get< std::string >(), TEST_LOCATION );
2586
2587   Property::Value* vertex = map->Find( "vertex" ); // vertex key name from shader-impl.cpp
2588   DALI_TEST_EQUALS( vertexShader, vertex->Get< std::string >(), TEST_LOCATION );
2589
2590   shader.Clear();
2591
2592   shader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
2593   properties[Visual::Property::SHADER] = shader;
2594
2595   Visual::Base visual1 = factory.CreateVisual( properties );
2596
2597   // trigger creation through setting on stage
2598   DummyControl dummy1 = DummyControl::New( true );
2599   Impl::DummyControl& dummyImpl1 = static_cast< Impl::DummyControl& >( dummy1.GetImplementation() );
2600   dummyImpl1.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual1 );
2601   dummy1.SetProperty( Actor::Property::SIZE, Vector2( 200, 200 ) );
2602   dummy1.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
2603   application.GetScene().Add( dummy1 );
2604
2605   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2606   glAbstraction.EnableEnableDisableCallTrace( true );
2607
2608   application.SendNotification();
2609   application.Render();
2610
2611   TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
2612   std::ostringstream blendStr;
2613   blendStr << std::hex << GL_BLEND;
2614   DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str() ) );
2615
2616   END_TEST;
2617 }
2618
2619
2620 void ResourceReadyLoadNext( Control control )
2621 {
2622   static int callNumber = 0;
2623
2624   gResourceReadySignalFired = true;
2625   gReadyIds.push_back(control.GetProperty< int >( Actor::Property::ID ));
2626
2627   if( callNumber == 0 )
2628   {
2629     DALI_TEST_EQUALS( control.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL), Toolkit::Visual::ResourceStatus::FAILED, TEST_LOCATION );
2630
2631     tet_infoline( "Create visual with loaded image from within the signal handler" );
2632     VisualFactory factory = VisualFactory::Get();
2633     Visual::Base imageVisual = factory.CreateVisual( TEST_IMAGE_FILE_NAME, ImageDimensions{20,30} );
2634
2635     Impl::DummyControl& controlImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
2636     controlImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual ); // This should trigger another signal.
2637     callNumber = 1;
2638   }
2639   else
2640   {
2641     tet_infoline( "3rd signal called" );
2642     DALI_TEST_CHECK(true);
2643   }
2644 }
2645
2646 int UtcDaliImageVisualLoadReady01(void)
2647 {
2648   ToolkitTestApplication application;
2649   tet_infoline( "UtcDaliImageVisualLoadReady01");
2650   tet_infoline( "First part:  Load an image visual for one resource, then another image visual for a second resource.");
2651   tet_infoline( "Second part, In the ready signal for the second image visual, add a 3rd visual with the first URL" );
2652   tet_infoline( "Should get a ready signal for all three visuals");
2653
2654   ClearReadyIds();
2655
2656   tet_infoline( "Create a control and connect to resource ready signal" );
2657   DummyControl actor = DummyControl::New(true);
2658   int actor1Id = actor.GetProperty< int >( Actor::Property::ID );
2659   actor.ResourceReadySignal().Connect( &ResourceReadySignal);
2660   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2661   actor.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2662   application.GetScene().Add(actor);
2663
2664   tet_infoline( "Create visual with IMMEDIATE load policy" );
2665   Visual::Base imageVisual1 = CreateVisualWithPolicy( TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE );
2666
2667   tet_infoline( "Registering visual allows control to get a signal once loaded even if visual not enabled( staged )" );
2668   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual1 );
2669
2670
2671   tet_infoline( "Allow image time to load" );
2672   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2673   application.SendNotification();
2674   application.Render();
2675
2676   tet_infoline( "Testing texture is loaded and resource ready signal fired" );
2677   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2678   DALI_TEST_EQUALS( gReadyIds[0], actor1Id, TEST_LOCATION );
2679
2680
2681   tet_infoline( "Original control correctly signalled, now testing failing image" );
2682
2683   gResourceReadySignalFired = false; // Reset signal check ready for testing next Control
2684   ClearReadyIds();
2685
2686   Visual::Base imageVisual2 = CreateVisualWithPolicy( TEST_BROKEN_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE );
2687
2688   DummyControl actor2 = DummyControl::New(true);
2689   int actor2Id = actor2.GetProperty< int >( Actor::Property::ID );
2690   Impl::DummyControl& dummyImpl2 = static_cast<Impl::DummyControl&>(actor2.GetImplementation());
2691   actor2.ResourceReadySignal().Connect( &ResourceReadyLoadNext);
2692
2693   tet_infoline( "Registering visual this should trigger the ready signal when the image fails to load" );
2694   dummyImpl2.RegisterVisual( DummyControl::Property::TEST_VISUAL, imageVisual2 );
2695
2696   actor2.SetProperty( Actor::Property::SIZE, Vector2(200.f, 200.f) );
2697   application.GetScene().Add(actor2);
2698
2699   tet_infoline( "Wait for loading thread to finish");
2700   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2701   DALI_TEST_EQUALS( gResourceReadySignalFired, true, TEST_LOCATION );
2702
2703   DALI_TEST_EQUALS( gReadyIds[0], actor2Id, TEST_LOCATION);
2704
2705   tet_infoline( "Check for 3rd signal");
2706   application.SendNotification();
2707   DALI_TEST_EQUALS( gReadyIds.size(), 2, TEST_LOCATION );
2708   DALI_TEST_EQUALS( gReadyIds[1], actor2Id, TEST_LOCATION);
2709
2710   END_TEST;
2711 }