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

   1 /*
   2  * Copyright (c) 2024 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
  18 #include <unistd.h>
  19 #include <sstream>
  20
  21 // Need to override adaptor classes for toolkit test harness, so include
  22 // test harness headers before dali headers.
  23
  24 #include <dali-toolkit-test-suite-utils.h>
  25 #include <toolkit-event-thread-callback.h>
  26 #include <toolkit-vector-image-renderer.h>
  27 #include "dummy-control.h"
  28
  29 #include <test-encoded-image-buffer.h>
  30 #include <test-native-image.h>
  31
  32 #include <dali-toolkit/dali-toolkit.h>
  33 #include <dali-toolkit/devel-api/controls/control-devel.h>
  34 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
  35 #include <dali-toolkit/devel-api/styling/style-manager-devel.h>
  36 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
  37 #include <dali-toolkit/devel-api/visuals/animated-image-visual-actions-devel.h>
  38 #include <dali-toolkit/devel-api/visuals/image-visual-actions-devel.h>
  39 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  40 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  41 #include <dali-toolkit/public-api/image-loader/image-url.h>
  42 #include <dali-toolkit/public-api/image-loader/image.h>
  43 #include <dali/devel-api/scripting/scripting.h>
  44
  45 using namespace Dali;
  46 using namespace Toolkit;
  47
  48 void utc_dali_toolkit_image_view_startup(void)
  49 {
  50   test_return_value = TET_UNDEF;
  51 }
  52
  53 void utc_dali_toolkit_image_view_cleanup(void)
  54 {
  55   test_return_value = TET_PASS;
  56 }
  57
  58 namespace
  59 {
  60 const char* TEST_IMAGE_FILE_NAME  = "gallery_image_01.jpg";
  61 const char* TEST_IMAGE_FILE_NAME2 = "gallery_image_02.jpg";
  62
  63 // resolution: 1024*1024
  64 const char* TEST_IMAGE_1 = TEST_RESOURCE_DIR "/TB-gloss.png";
  65 const char* TEST_IMAGE_2 = TEST_RESOURCE_DIR "/tb-norm.png";
  66
  67 const char* TEST_BROKEN_IMAGE_DEFAULT = TEST_RESOURCE_DIR "/broken.png";
  68 const char* TEST_BROKEN_IMAGE_S       = TEST_RESOURCE_DIR "/broken_s.9.png";
  69 const char* TEST_BROKEN_IMAGE_M       = TEST_RESOURCE_DIR "/broken_m.9.png";
  70 const char* TEST_BROKEN_IMAGE_L       = TEST_RESOURCE_DIR "/broken_l.9.png";
  71 const char* TEST_BROKEN_IMAGE_01      = TEST_RESOURCE_DIR "/button-up.9.png";
  72 const char* TEST_BROKEN_IMAGE_02      = TEST_RESOURCE_DIR "/heartsframe.9.png";
  73
  74 const char* TEST_INVALID_NPATCH_FILE_NAME_01 = "invalid1.9.png";
  75
  76 // resolution: 34*34, pixel format: RGBA8888
  77 static const char* gImage_34_RGBA = TEST_RESOURCE_DIR "/icon-edit.png";
  78 // resolution: 600*600, pixel format: RGB888
  79 static const char* gImage_600_RGB = TEST_RESOURCE_DIR "/test-image-600.jpg";
  80
  81 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
  82 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  83
  84 const char* TEST_SVG_FILE_NAME                   = TEST_RESOURCE_DIR "/svg1.svg";
  85 const char* TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
  86 const char* TEST_WEBP_FILE_NAME                  = TEST_RESOURCE_DIR "/dali-logo.webp";
  87
  88 const char* TEST_OVERWRITABLE_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/overwritable-image.jpg";
  89
  90 void TestUrl(ImageView imageView, const std::string url)
  91 {
  92   Property::Value value = imageView.GetProperty(imageView.GetPropertyIndex("image"));
  93
  94   std::string urlActual;
  95   DALI_TEST_CHECK(value.Get(urlActual));
  96   DALI_TEST_EQUALS(urlActual, url, TEST_LOCATION);
  97 }
  98
  99 void OverwriteImage(const char* sourceFilename)
 100 {
 101   FILE* fpOut = fopen(TEST_OVERWRITABLE_IMAGE_FILE_NAME, "wb");
 102   DALI_TEST_CHECK(fpOut);
 103   if(fpOut)
 104   {
 105     FILE* fpIn = fopen(sourceFilename, "rb");
 106     if(fpIn)
 107     {
 108       fseek(fpIn, 0, SEEK_END);
 109       size_t size = ftell(fpIn);
 110
 111       tet_printf("Open %s success! file size : %zu byte\n", sourceFilename, size);
 112       Dali::Vector<uint8_t> data;
 113       data.Resize(size);
 114       fseek(fpIn, 0, SEEK_SET);
 115       size_t realSize = fread(data.Begin(), sizeof(uint8_t), size, fpIn);
 116       fclose(fpIn);
 117       data.Resize(realSize);
 118
 119       // Overwrite
 120       fwrite(data.Begin(), sizeof(uint8_t), size, fpOut);
 121     }
 122     else
 123     {
 124       tet_printf("Open %s failed! write invalid\n", sourceFilename);
 125       fprintf(fpOut, "invalid\n");
 126     }
 127     fclose(fpOut);
 128   }
 129 }
 130
 131 } // namespace
 132
 133 int UtcDaliImageViewNewP(void)
 134 {
 135   ToolkitTestApplication application;
 136
 137   ImageView imageView = ImageView::New();
 138
 139   DALI_TEST_CHECK(imageView);
 140
 141   END_TEST;
 142 }
 143
 144 int UtcDaliImageViewNewUrlP(void)
 145 {
 146   ToolkitTestApplication application;
 147
 148   ImageView imageView = ImageView::New(TEST_IMAGE_FILE_NAME);
 149   DALI_TEST_CHECK(imageView);
 150
 151   TestUrl(imageView, TEST_IMAGE_FILE_NAME);
 152
 153   END_TEST;
 154 }
 155
 156 int UtcDaliImageViewConstructorP(void)
 157 {
 158   ToolkitTestApplication application;
 159
 160   ImageView imageView;
 161
 162   DALI_TEST_CHECK(!imageView);
 163
 164   END_TEST;
 165 }
 166
 167 int UtcDaliImageViewCopyConstructorP(void)
 168 {
 169   ToolkitTestApplication application;
 170
 171   // Initialize an object, ref count == 1
 172   ImageView imageView = ImageView::New();
 173
 174   ImageView copy(imageView);
 175   DALI_TEST_CHECK(copy);
 176
 177   END_TEST;
 178 }
 179
 180 int UtcDaliImageViewMoveConstructor(void)
 181 {
 182   ToolkitTestApplication application;
 183
 184   ImageView imageView = ImageView::New();
 185   DALI_TEST_EQUALS(1, imageView.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 186   imageView.SetProperty(Actor::Property::SENSITIVE, false);
 187   DALI_TEST_CHECK(false == imageView.GetProperty<bool>(Actor::Property::SENSITIVE));
 188
 189   ImageView moved = std::move(imageView);
 190   DALI_TEST_CHECK(moved);
 191   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 192   DALI_TEST_CHECK(false == moved.GetProperty<bool>(Actor::Property::SENSITIVE));
 193   DALI_TEST_CHECK(!imageView);
 194
 195   END_TEST;
 196 }
 197
 198 int UtcDaliImageViewAssignmentOperatorP(void)
 199 {
 200   ToolkitTestApplication application;
 201
 202   ImageView imageView = ImageView::New();
 203
 204   ImageView copy(imageView);
 205   DALI_TEST_CHECK(copy);
 206   DALI_TEST_EQUALS(imageView, copy, TEST_LOCATION);
 207
 208   END_TEST;
 209 }
 210
 211 int UtcDaliImageViewMoveAssignment(void)
 212 {
 213   ToolkitTestApplication application;
 214
 215   ImageView imageView = ImageView::New();
 216   DALI_TEST_EQUALS(1, imageView.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 217   imageView.SetProperty(Actor::Property::SENSITIVE, false);
 218   DALI_TEST_CHECK(false == imageView.GetProperty<bool>(Actor::Property::SENSITIVE));
 219
 220   ImageView moved;
 221   moved = std::move(imageView);
 222   DALI_TEST_CHECK(moved);
 223   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 224   DALI_TEST_CHECK(false == moved.GetProperty<bool>(Actor::Property::SENSITIVE));
 225   DALI_TEST_CHECK(!imageView);
 226
 227   END_TEST;
 228 }
 229
 230 int UtcDaliImageViewDownCastP(void)
 231 {
 232   ToolkitTestApplication application;
 233
 234   ImageView imageView = ImageView::New();
 235
 236   BaseHandle object(imageView);
 237
 238   ImageView imageView2 = ImageView::DownCast(object);
 239   DALI_TEST_CHECK(imageView2);
 240
 241   ImageView imageView3 = DownCast<ImageView>(object);
 242   DALI_TEST_CHECK(imageView3);
 243
 244   END_TEST;
 245 }
 246
 247 int UtcDaliImageViewDownCastN(void)
 248 {
 249   ToolkitTestApplication application;
 250
 251   BaseHandle unInitializedObject;
 252
 253   ImageView imageView1 = ImageView::DownCast(unInitializedObject);
 254   DALI_TEST_CHECK(!imageView1);
 255
 256   ImageView imageView2 = DownCast<ImageView>(unInitializedObject);
 257   DALI_TEST_CHECK(!imageView2);
 258
 259   END_TEST;
 260 }
 261
 262 int UtcDaliImageViewTypeRegistry(void)
 263 {
 264   ToolkitTestApplication application;
 265
 266   TypeRegistry typeRegistry = TypeRegistry::Get();
 267   DALI_TEST_CHECK(typeRegistry);
 268
 269   TypeInfo typeInfo = typeRegistry.GetTypeInfo("ImageView");
 270   DALI_TEST_CHECK(typeInfo);
 271
 272   BaseHandle handle = typeInfo.CreateInstance();
 273   DALI_TEST_CHECK(handle);
 274
 275   ImageView imageView = ImageView::DownCast(handle);
 276   DALI_TEST_CHECK(imageView);
 277
 278   END_TEST;
 279 }
 280
 281 int UtcDaliImageViewSetGetProperty01(void)
 282 {
 283   ToolkitTestApplication application;
 284
 285   ImageView imageView = ImageView::New();
 286
 287   Property::Index idx = imageView.GetPropertyIndex("image");
 288   DALI_TEST_EQUALS(idx, (Property::Index)ImageView::Property::IMAGE, TEST_LOCATION);
 289
 290   imageView.SetProperty(idx, TEST_IMAGE_FILE_NAME);
 291   TestUrl(imageView, TEST_IMAGE_FILE_NAME);
 292
 293   END_TEST;
 294 }
 295
 296 int UtcDaliImageViewPreMultipliedAlphaPng(void)
 297 {
 298   ToolkitTestApplication application;
 299
 300   // Set up trace debug
 301   TestGlAbstraction& gl           = application.GetGlAbstraction();
 302   TraceCallStack&    textureTrace = gl.GetTextureTrace();
 303   textureTrace.Enable(true);
 304
 305   Property::Map imageMap;
 306   imageMap[ImageVisual::Property::URL]            = gImage_34_RGBA;
 307   imageMap[ImageVisual::Property::RELEASE_POLICY] = ImageVisual::ReleasePolicy::NEVER; // To keep the texture cache
 308
 309   ImageView imageView1 = ImageView::New();
 310   imageView1.SetProperty(ImageView::Property::IMAGE, imageMap);
 311
 312   application.GetScene().Add(imageView1);
 313
 314   Property::Value value = imageView1.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 315   bool            enable;
 316   DALI_TEST_CHECK(value.Get(enable));
 317   DALI_TEST_CHECK(enable); // Default value is true
 318
 319   // loading started, this waits for the loader thread for max 30 seconds
 320   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 321
 322   application.SendNotification();
 323   application.Render();
 324
 325   value = imageView1.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 326   DALI_TEST_CHECK(value.Get(enable));
 327   DALI_TEST_CHECK(enable); // Keep true
 328
 329   // conventional alpha blending
 330   Renderer renderer1 = imageView1.GetRendererAt(0);
 331   value              = renderer1.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
 332   DALI_TEST_CHECK(value.Get(enable));
 333   DALI_TEST_CHECK(enable);
 334
 335   int srcFactorRgb    = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
 336   int destFactorRgb   = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
 337   int srcFactorAlpha  = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
 338   int destFactorAlpha = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
 339   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::ONE);
 340   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
 341   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
 342   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
 343
 344   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION); // A new texture should be generated.
 345   textureTrace.Reset();
 346
 347   // Disable pre-multiplied alpha blending
 348   imageView1.SetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA, false);
 349
 350   // Reload the image
 351   Property::Map attributes;
 352   DevelControl::DoAction(imageView1, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
 353
 354   // loading started, this waits for the loader thread for max 30 seconds
 355   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 356
 357   application.SendNotification();
 358   application.Render();
 359
 360   value = imageView1.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 361   DALI_TEST_CHECK(value.Get(enable));
 362   DALI_TEST_CHECK(!enable);
 363
 364   // conventional alpha blending
 365   value = renderer1.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
 366   DALI_TEST_CHECK(value.Get(enable));
 367   DALI_TEST_CHECK(!enable);
 368
 369   srcFactorRgb    = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
 370   destFactorRgb   = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
 371   srcFactorAlpha  = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
 372   destFactorAlpha = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
 373   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::SRC_ALPHA);
 374   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
 375   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
 376   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
 377
 378   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION); // A new texture should be generated.
 379   textureTrace.Reset();
 380
 381   // Make a new ImageView using the same image
 382   ImageView imageView2 = ImageView::New();
 383   imageView2.SetProperty(ImageView::Property::IMAGE, imageMap);
 384
 385   application.GetScene().Add(imageView2);
 386
 387   application.SendNotification();
 388   application.Render();
 389
 390   Renderer renderer2 = imageView2.GetRendererAt(0);
 391   value              = renderer2.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
 392   DALI_TEST_CHECK(value.Get(enable));
 393   DALI_TEST_CHECK(enable);
 394
 395   srcFactorRgb    = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
 396   destFactorRgb   = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
 397   srcFactorAlpha  = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
 398   destFactorAlpha = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
 399   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::ONE);
 400   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
 401   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
 402   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
 403
 404   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION); // The cached texture should be used.
 405
 406   END_TEST;
 407 }
 408
 409 int UtcDaliImageViewPreMultipliedAlphaJpg(void)
 410 {
 411   ToolkitTestApplication application;
 412
 413   // Set up trace debug
 414   TestGlAbstraction& gl           = application.GetGlAbstraction();
 415   TraceCallStack&    textureTrace = gl.GetTextureTrace();
 416   textureTrace.Enable(true);
 417
 418   Property::Map imageMap;
 419   imageMap[ImageVisual::Property::URL]            = gImage_600_RGB;
 420   imageMap[ImageVisual::Property::RELEASE_POLICY] = ImageVisual::ReleasePolicy::NEVER; // To keep the texture cache
 421
 422   ImageView imageView1 = ImageView::New();
 423   imageView1.SetProperty(ImageView::Property::IMAGE, imageMap);
 424
 425   application.GetScene().Add(imageView1);
 426
 427   Property::Value value = imageView1.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 428   bool            enable;
 429   DALI_TEST_CHECK(value.Get(enable));
 430   DALI_TEST_CHECK(enable); // Default value is true
 431
 432   // loading started, this waits for the loader thread for max 30 seconds
 433   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 434
 435   application.SendNotification();
 436   application.Render();
 437
 438   value = imageView1.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 439   DALI_TEST_CHECK(value.Get(enable));
 440   DALI_TEST_CHECK(!enable); // Should be false after loading
 441
 442   // conventional alpha blending
 443   Renderer renderer1 = imageView1.GetRendererAt(0);
 444   value              = renderer1.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
 445   DALI_TEST_CHECK(value.Get(enable));
 446   DALI_TEST_CHECK(!enable);
 447
 448   int srcFactorRgb    = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
 449   int destFactorRgb   = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
 450   int srcFactorAlpha  = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
 451   int destFactorAlpha = renderer1.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
 452   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::SRC_ALPHA);
 453   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
 454   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
 455   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
 456
 457   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION); // A new texture should be generated.
 458   textureTrace.Reset();
 459
 460   ImageView imageView2 = ImageView::New();
 461   imageView2.SetProperty(ImageView::Property::IMAGE, imageMap);
 462
 463   // Disable pre-multiplied alpha blending
 464   imageView2.SetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA, false);
 465
 466   application.GetScene().Add(imageView2);
 467
 468   application.SendNotification();
 469   application.Render();
 470
 471   value = imageView2.GetProperty(ImageView::Property::PRE_MULTIPLIED_ALPHA);
 472   DALI_TEST_CHECK(value.Get(enable));
 473   DALI_TEST_CHECK(!enable);
 474
 475   // conventional alpha blending
 476   Renderer renderer2 = imageView2.GetRendererAt(0);
 477   value              = renderer2.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
 478   DALI_TEST_CHECK(value.Get(enable));
 479   DALI_TEST_CHECK(!enable);
 480
 481   srcFactorRgb    = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
 482   destFactorRgb   = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
 483   srcFactorAlpha  = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
 484   destFactorAlpha = renderer2.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
 485   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::SRC_ALPHA);
 486   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
 487   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
 488   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
 489
 490   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION); // The cached texture should be used.
 491
 492   END_TEST;
 493 }
 494
 495 int UtcDaliImageViewPixelArea(void)
 496 {
 497   // Test pixel area property
 498   ToolkitTestApplication application;
 499
 500   static std::vector<UniformData> customUniforms =
 501     {
 502       UniformData("pixelArea", Property::Type::VECTOR4),
 503     };
 504
 505   TestGraphicsController& graphics = application.GetGraphicsController();
 506   graphics.AddCustomUniforms(customUniforms);
 507
 508   // Gif image, use AnimatedImageVisual internally
 509   // Atlasing is applied to pack multiple frames, use custom wrap mode
 510   ImageView     gifView = ImageView::New();
 511   const Vector4 pixelAreaVisual(0.f, 0.f, 2.f, 2.f);
 512   gifView.SetProperty(ImageView::Property::IMAGE,
 513                       Property::Map().Add(ImageVisual::Property::URL, TEST_GIF_FILE_NAME).Add(ImageVisual::Property::PIXEL_AREA, pixelAreaVisual));
 514
 515   // Add to stage
 516   Integration::Scene stage = application.GetScene();
 517   stage.Add(gifView);
 518
 519   // loading started
 520   application.SendNotification();
 521   application.Render(16);
 522
 523   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 524
 525   application.SendNotification();
 526   application.Render();
 527   DALI_TEST_CHECK(gifView.GetRendererCount() == 1u);
 528
 529   const Vector4 fullTextureRect(0.f, 0.f, 1.f, 1.f);
 530   // test that the pixel area value defined in the visual property map is registered on renderer
 531   Renderer        renderer       = gifView.GetRendererAt(0);
 532   Property::Value pixelAreaValue = renderer.GetProperty(renderer.GetPropertyIndex("pixelArea"));
 533   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), pixelAreaVisual, TEST_LOCATION);
 534
 535   // test that the shader has the default pixel area value registered.
 536   Shader shader  = renderer.GetShader();
 537   pixelAreaValue = shader.GetProperty(shader.GetPropertyIndex("pixelArea"));
 538   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), fullTextureRect, TEST_LOCATION);
 539
 540   // test that the uniform uses the pixelArea property on the renderer.
 541   TestGlAbstraction& gl = application.GetGlAbstraction();
 542   Vector4            pixelAreaUniform;
 543   DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("pixelArea", pixelAreaUniform));
 544   DALI_TEST_EQUALS(pixelAreaVisual, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 545
 546   // set the pixelArea property on the control
 547   const Vector4 pixelAreaControl(-1.f, -1.f, 3.f, 3.f);
 548   gifView.SetProperty(ImageView::Property::PIXEL_AREA, pixelAreaControl);
 549   application.SendNotification();
 550   application.Render(16);
 551
 552   // check the pixelArea property on the control
 553   pixelAreaValue = gifView.GetProperty(gifView.GetPropertyIndex("pixelArea"));
 554   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), pixelAreaControl, TEST_LOCATION);
 555   // test that the uniform uses the pixelArea property on the control.
 556   DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("pixelArea", pixelAreaUniform));
 557   DALI_TEST_EQUALS(pixelAreaControl, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
 558
 559   END_TEST;
 560 }
 561
 562 int UtcDaliImageViewAsyncLoadingWithoutAltasing(void)
 563 {
 564   ToolkitTestApplication     application;
 565   TestGlAbstraction&         gl          = application.GetGlAbstraction();
 566   const std::vector<GLuint>& textures    = gl.GetBoundTextures();
 567   size_t                     numTextures = textures.size();
 568
 569   // Async loading, no atlasing for big size image
 570   ImageView imageView = ImageView::New(gImage_600_RGB);
 571
 572   // By default, Aysnc loading is used
 573   application.GetScene().Add(imageView);
 574   imageView.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
 575   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 576
 577   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 578
 579   application.SendNotification();
 580   application.Render(16);
 581   application.SendNotification();
 582
 583   const std::vector<GLuint>& textures2 = gl.GetBoundTextures();
 584   DALI_TEST_GREATER(textures2.size(), numTextures, TEST_LOCATION);
 585
 586   END_TEST;
 587 }
 588
 589 int UtcDaliImageViewAsyncLoadingWithAtlasing(void)
 590 {
 591   ToolkitTestApplication application;
 592
 593   //Async loading, automatic atlasing for small size image
 594   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 595   callStack.Reset();
 596   callStack.Enable(true);
 597
 598   Property::Map imageMap;
 599
 600   imageMap[ImageVisual::Property::URL]            = gImage_34_RGBA;
 601   imageMap[ImageVisual::Property::DESIRED_HEIGHT] = 34;
 602   imageMap[ImageVisual::Property::DESIRED_WIDTH]  = 34;
 603   imageMap[ImageVisual::Property::ATLASING]       = true;
 604
 605   ImageView imageView = ImageView::New();
 606   imageView.SetProperty(ImageView::Property::IMAGE, imageMap);
 607   imageView.SetProperty(Toolkit::Control::Property::PADDING, Extents(10u, 10u, 10u, 10u));
 608
 609   // By default, Aysnc loading is used
 610   // loading is not started if the actor is offScene
 611
 612   application.GetScene().Add(imageView);
 613
 614   imageView.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::RIGHT_TO_LEFT);
 615
 616   // loading started, this waits for the loader thread for max 30 seconds
 617   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 618
 619   application.SendNotification();
 620   application.Render(16);
 621
 622   callStack.Enable(false);
 623
 624   TraceCallStack::NamedParams params;
 625   params["width"] << 34;
 626   params["height"] << 34;
 627   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params), true, TEST_LOCATION);
 628
 629   END_TEST;
 630 }
 631
 632 int UtcDaliImageViewAsyncLoadingWithAtlasing02(void)
 633 {
 634   ToolkitTestApplication application;
 635
 636   //Async loading, automatic atlasing for small size image
 637   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 638   callStack.Reset();
 639   callStack.Enable(true);
 640
 641   Property::Map asyncLoadingMap;
 642   asyncLoadingMap["url"]                = gImage_34_RGBA;
 643   asyncLoadingMap["desiredHeight"]      = 34;
 644   asyncLoadingMap["desiredWidth"]       = 34;
 645   asyncLoadingMap["synchronousLoading"] = false;
 646   asyncLoadingMap["atlasing"]           = true;
 647
 648   ImageView imageView = ImageView::New();
 649   imageView.SetProperty(ImageView::Property::IMAGE, asyncLoadingMap);
 650
 651   application.GetScene().Add(imageView);
 652
 653   // loading started, this waits for the loader thread for max 30 seconds
 654   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 655
 656   application.SendNotification();
 657   application.Render(16);
 658
 659   callStack.Enable(false);
 660
 661   TraceCallStack::NamedParams params;
 662   params["width"] << 34;
 663   params["height"] << 34;
 664   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params), true, TEST_LOCATION);
 665
 666   END_TEST;
 667 }
 668
 669 int UtcDaliImageViewSyncLoading(void)
 670 {
 671   ToolkitTestApplication application;
 672
 673   tet_infoline("ImageView Testing sync loading and size using index key property map");
 674
 675   Property::Map syncLoadingMap;
 676   syncLoadingMap[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
 677   syncLoadingMap[ImageVisual::Property::ATLASING]            = true;
 678
 679   // Sync loading, no atlasing for big size image
 680   {
 681     ImageView imageView = ImageView::New();
 682
 683     // Sync loading is used
 684     syncLoadingMap[ImageVisual::Property::URL] = gImage_600_RGB;
 685     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
 686   }
 687
 688   // Sync loading, automatic atlasing for small size image
 689   {
 690     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 691     callStack.Reset();
 692     callStack.Enable(true);
 693
 694     ImageView imageView = ImageView::New();
 695
 696     // Sync loading is used
 697     syncLoadingMap[ImageVisual::Property::URL]            = gImage_34_RGBA;
 698     syncLoadingMap[ImageVisual::Property::DESIRED_HEIGHT] = 34;
 699     syncLoadingMap[ImageVisual::Property::DESIRED_WIDTH]  = 34;
 700     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
 701
 702     application.GetScene().Add(imageView);
 703     application.SendNotification();
 704     application.Render(16);
 705
 706     TraceCallStack::NamedParams params;
 707     params["width"] << 34;
 708     params["height"] << 34;
 709     DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params),
 710                      true,
 711                      TEST_LOCATION);
 712   }
 713   END_TEST;
 714 }
 715
 716 int UtcDaliImageViewSyncLoading02(void)
 717 {
 718   ToolkitTestApplication application;
 719
 720   tet_infoline("ImageView Testing sync loading and size using string key property map");
 721
 722   // Sync loading, automatic atlasing for small size image
 723   {
 724     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 725     callStack.Reset();
 726     callStack.Enable(true);
 727
 728     ImageView imageView = ImageView::New();
 729
 730     // Sync loading is used
 731     Property::Map syncLoadingMap;
 732     syncLoadingMap["url"]                = gImage_34_RGBA;
 733     syncLoadingMap["desiredHeight"]      = 34;
 734     syncLoadingMap["desiredWidth"]       = 34;
 735     syncLoadingMap["synchronousLoading"] = true;
 736     syncLoadingMap["atlasing"]           = true;
 737     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
 738
 739     application.GetScene().Add(imageView);
 740     application.SendNotification();
 741     application.Render(16);
 742
 743     TraceCallStack::NamedParams params;
 744     params["width"] << 34;
 745     params["height"] << 34;
 746     DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params),
 747                      true,
 748                      TEST_LOCATION);
 749   }
 750   END_TEST;
 751 }
 752
 753 int UtcDaliImageViewAsyncLoadingEncodedBuffer(void)
 754 {
 755   ToolkitTestApplication     application;
 756   TestGlAbstraction&         gl          = application.GetGlAbstraction();
 757   const std::vector<GLuint>& textures    = gl.GetBoundTextures();
 758   size_t                     numTextures = textures.size();
 759
 760   // Get encoded raw-buffer image and generate url
 761   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(gImage_600_RGB);
 762   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
 763
 764   // Async loading, no atlasing for big size image
 765   ImageView imageView = ImageView::New(url.GetUrl());
 766
 767   // By default, Aysnc loading is used
 768   application.GetScene().Add(imageView);
 769   imageView.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
 770   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 771
 772   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 773
 774   application.SendNotification();
 775   application.Render(16);
 776   application.SendNotification();
 777
 778   const std::vector<GLuint>& textures2 = gl.GetBoundTextures();
 779   DALI_TEST_GREATER(textures2.size(), numTextures, TEST_LOCATION);
 780
 781   END_TEST;
 782 }
 783
 784 int UtcDaliImageViewAsyncLoadingEncodedBufferWithAtlasing(void)
 785 {
 786   ToolkitTestApplication application;
 787
 788   // Get encoded raw-buffer image and generate url
 789   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(gImage_600_RGB);
 790   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
 791   ImageUrl           url2   = Toolkit::Image::GenerateUrl(buffer);
 792
 793   // Generate url is not equal to url2
 794   // NOTE : This behavior may changed when ImageUrl compare operator changed.
 795   DALI_TEST_CHECK(url != url2);
 796   // Generate url's string is equal to url2's string
 797   DALI_TEST_CHECK(url.GetUrl() == url2.GetUrl());
 798
 799   EncodedImageBuffer buffer2 = ConvertFileToEncodedImageBuffer(gImage_600_RGB);
 800   url2                       = Toolkit::Image::GenerateUrl(buffer2);
 801
 802   // Check whethere two url are not equal
 803   DALI_TEST_CHECK(url.GetUrl() != url2.GetUrl());
 804
 805   // Async loading, automatic atlasing for small size image
 806   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 807   callStack.Reset();
 808   callStack.Enable(true);
 809
 810   Property::Map imageMap;
 811
 812   imageMap[ImageVisual::Property::URL]            = url.GetUrl();
 813   imageMap[ImageVisual::Property::DESIRED_HEIGHT] = 600;
 814   imageMap[ImageVisual::Property::DESIRED_WIDTH]  = 600;
 815   imageMap[ImageVisual::Property::ATLASING]       = true;
 816
 817   // No atlasing with big image
 818   ImageView imageView_bigdesired = ImageView::New();
 819   imageView_bigdesired.SetProperty(ImageView::Property::IMAGE, imageMap);
 820   imageView_bigdesired.SetProperty(Toolkit::Control::Property::PADDING, Extents(10u, 10u, 10u, 10u));
 821
 822   imageMap[ImageVisual::Property::DESIRED_HEIGHT] = 0;
 823   imageMap[ImageVisual::Property::DESIRED_WIDTH]  = 0;
 824
 825   // No atlasing with zero desired size
 826   ImageView imageView_nodesired = ImageView::New();
 827   imageView_nodesired.SetProperty(ImageView::Property::IMAGE, imageMap);
 828   imageView_nodesired.SetProperty(Toolkit::Control::Property::PADDING, Extents(10u, 10u, 10u, 10u));
 829
 830   imageMap[ImageVisual::Property::DESIRED_HEIGHT] = 34;
 831   imageMap[ImageVisual::Property::DESIRED_WIDTH]  = 34;
 832
 833   ImageView imageView = ImageView::New();
 834   imageView.SetProperty(ImageView::Property::IMAGE, imageMap);
 835   imageView.SetProperty(Toolkit::Control::Property::PADDING, Extents(10u, 10u, 10u, 10u));
 836
 837   // By default, Aysnc loading is used
 838   // loading is not started if the actor is offScene
 839   application.GetScene().Add(imageView);
 840   application.GetScene().Add(imageView_bigdesired);
 841   application.GetScene().Add(imageView_nodesired);
 842   application.SendNotification();
 843   application.Render(16);
 844
 845   // loading started, this waits for the loader thread for max 30 seconds
 846   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 847
 848   application.Render(16);
 849   application.SendNotification();
 850
 851   // Change url to url2
 852   imageMap[ImageVisual::Property::URL] = url2.GetUrl();
 853   imageView.SetProperty(ImageView::Property::IMAGE, imageMap);
 854
 855   imageView.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::RIGHT_TO_LEFT);
 856
 857   // loading started, this waits for the loader thread for max 30 seconds
 858   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 859
 860   application.SendNotification();
 861   application.Render(16);
 862
 863   callStack.Enable(false);
 864
 865   TraceCallStack::NamedParams params;
 866   params["width"] << 34;
 867   params["height"] << 34;
 868   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params), true, TEST_LOCATION);
 869
 870   END_TEST;
 871 }
 872
 873 int UtcDaliImageViewSyncLoadingEncodedBuffer(void)
 874 {
 875   ToolkitTestApplication application;
 876
 877   tet_infoline("ImageView Testing sync loading from EncodedImageBuffer");
 878
 879   // Get encoded raw-buffer image and generate url
 880   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(gImage_34_RGBA);
 881   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
 882
 883   // Sync loading, automatic atlasing for small size image
 884   {
 885     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 886     callStack.Reset();
 887     callStack.Enable(true);
 888
 889     ImageView imageView = ImageView::New();
 890
 891     // Sync loading is used
 892     Property::Map syncLoadingMap;
 893     syncLoadingMap["url"]                = url.GetUrl();
 894     syncLoadingMap["alphaMaskUrl"]       = gImage_34_RGBA;
 895     syncLoadingMap["desiredHeight"]      = 34;
 896     syncLoadingMap["desiredWidth"]       = 34;
 897     syncLoadingMap["synchronousLoading"] = true;
 898     syncLoadingMap["atlasing"]           = true;
 899     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
 900
 901     application.GetScene().Add(imageView);
 902     application.SendNotification();
 903     application.Render(16);
 904
 905     TraceCallStack::NamedParams params;
 906     params["width"] << 34;
 907     params["height"] << 34;
 908     DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params),
 909                      true,
 910                      TEST_LOCATION);
 911   }
 912
 913   END_TEST;
 914 }
 915
 916 int UtcDaliImageViewEncodedBufferWithSvg(void)
 917 {
 918   ToolkitTestApplication     application;
 919   TestGlAbstraction&         gl          = application.GetGlAbstraction();
 920   const std::vector<GLuint>& textures    = gl.GetBoundTextures();
 921   size_t                     numTextures = textures.size();
 922
 923   // Get encoded raw-buffer svg image and generate url
 924   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(TEST_SVG_FILE_NAME, EncodedImageBuffer::ImageType::VECTOR_IMAGE);
 925   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
 926
 927   // Async loading, no atlasing for big size image
 928   ImageView imageView = ImageView::New(url.GetUrl());
 929
 930   // By default, Aysnc loading is used
 931   application.GetScene().Add(imageView);
 932   imageView.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
 933   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 934
 935   application.SendNotification();
 936   application.Render(16);
 937
 938   // Load svg image + rasterize.
 939   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
 940
 941   application.SendNotification();
 942   application.Render(16);
 943   application.SendNotification();
 944
 945   const std::vector<GLuint>& textures2 = gl.GetBoundTextures();
 946   DALI_TEST_GREATER(textures2.size(), numTextures, TEST_LOCATION);
 947
 948   // Remove visual, for line coverage.
 949   imageView.Unparent();
 950   application.SendNotification();
 951   application.Render(16);
 952
 953   END_TEST;
 954 }
 955
 956 int UtcDaliImageViewEncodedBufferWithAnimatedVectorImage(void)
 957 {
 958   ToolkitTestApplication     application;
 959   TestGlAbstraction&         gl          = application.GetGlAbstraction();
 960   const std::vector<GLuint>& textures    = gl.GetBoundTextures();
 961   size_t                     numTextures = textures.size();
 962
 963   // Get encoded raw-buffer lottie image and generate url
 964   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME, EncodedImageBuffer::ImageType::ANIMATED_VECTOR_IMAGE);
 965   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
 966
 967   // Async loading, no atlasing for big size image
 968   ImageView imageView = ImageView::New(url.GetUrl());
 969
 970   // By default, Aysnc loading is used
 971   application.GetScene().Add(imageView);
 972   imageView.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
 973   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 974
 975   application.SendNotification();
 976   application.Render(16);
 977
 978   // Load lottie image is sync. Only wait rasterize.
 979   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 980
 981   application.SendNotification();
 982   application.Render(16);
 983   application.SendNotification();
 984
 985   const std::vector<GLuint>& textures2 = gl.GetBoundTextures();
 986   DALI_TEST_GREATER(textures2.size(), numTextures, TEST_LOCATION);
 987
 988   // Remove visual, for line coverage.
 989   imageView.Unparent();
 990   application.SendNotification();
 991   application.Render(16);
 992
 993   END_TEST;
 994 }
 995
 996 int UtcDaliImageViewEncodedBufferWithInvalidImageType(void)
 997 {
 998   ToolkitTestApplication     application;
 999   TestGlAbstraction&         gl          = application.GetGlAbstraction();
1000   const std::vector<GLuint>& textures    = gl.GetBoundTextures();
1001   size_t                     numTextures = textures.size();
1002
1003   // Get encoded raw-buffer jpg image with invalid image type, and generate url
1004   EncodedImageBuffer buffer = ConvertFileToEncodedImageBuffer(gImage_34_RGBA, static_cast<EncodedImageBuffer::ImageType>(-1));
1005   ImageUrl           url    = Toolkit::Image::GenerateUrl(buffer);
1006
1007   // Async loading, no atlasing for big size image
1008   ImageView imageView = ImageView::New(url.GetUrl());
1009
1010   // By default, Aysnc loading is used
1011   application.GetScene().Add(imageView);
1012   imageView.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
1013   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1014
1015   application.SendNotification();
1016   application.Render(16);
1017
1018   // Load image
1019   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1020
1021   application.SendNotification();
1022   application.Render(16);
1023   application.SendNotification();
1024
1025   const std::vector<GLuint>& textures2 = gl.GetBoundTextures();
1026   DALI_TEST_GREATER(textures2.size(), numTextures, TEST_LOCATION);
1027
1028   // Remove visual, for line coverage.
1029   imageView.Unparent();
1030   application.SendNotification();
1031   application.Render(16);
1032
1033   END_TEST;
1034 }
1035
1036 int UtcDaliImageViewAddedTexture(void)
1037 {
1038   ToolkitTestApplication application;
1039
1040   tet_infoline("ImageView Testing image view with texture provided manager url");
1041
1042   ImageView imageView = ImageView::New();
1043
1044   // empty texture is ok, though pointless from app point of view
1045   TextureSet  empty;
1046   std::string url = TextureManager::AddTexture(empty);
1047   DALI_TEST_CHECK(url.size() > 0u);
1048
1049   Property::Map propertyMap;
1050   propertyMap[ImageVisual::Property::URL] = url;
1051   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1052
1053   application.GetScene().Add(imageView);
1054   application.SendNotification();
1055   application.Render();
1056
1057   END_TEST;
1058 }
1059
1060 int UtcDaliImageViewSizeWithBackground(void)
1061 {
1062   ToolkitTestApplication application;
1063
1064   int       width     = 100;
1065   int       height    = 200;
1066   ImageView imageView = ImageView::New();
1067
1068   imageView.SetProperty(Control::Property::BACKGROUND,
1069                         {
1070                           {Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
1071                           {Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/gallery-small-1.jpg"},
1072                           {ImageVisual::Property::DESIRED_WIDTH, width},
1073                           {ImageVisual::Property::DESIRED_HEIGHT, height},
1074                         });
1075
1076   application.GetScene().Add(imageView);
1077   application.SendNotification();
1078   application.Render();
1079
1080   DALI_TEST_EQUALS(imageView.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, (float)width, TEST_LOCATION);
1081   DALI_TEST_EQUALS(imageView.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, (float)height, TEST_LOCATION);
1082
1083   END_TEST;
1084 }
1085
1086 int UtcDaliImageViewSizeWithBackgroundAndImage(void)
1087 {
1088   ToolkitTestApplication application;
1089
1090   int widthBackground  = 100;
1091   int heightBackground = 200;
1092   int width            = 600;
1093   int height           = 600;
1094
1095   ImageView imageView = ImageView::New();
1096
1097   imageView.SetProperty(Control::Property::BACKGROUND,
1098                         {
1099                           {Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
1100                           {Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/gallery-small-1.jpg"},
1101                           {ImageVisual::Property::DESIRED_WIDTH, widthBackground},
1102                           {ImageVisual::Property::DESIRED_HEIGHT, heightBackground},
1103                         });
1104
1105   imageView.SetImage(gImage_600_RGB); // 1 to 1 ratio, 600x600 pixels
1106
1107   application.GetScene().Add(imageView);
1108   application.SendNotification();
1109   application.Render();
1110
1111   DALI_TEST_EQUALS(imageView.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, (float)width, TEST_LOCATION);
1112   DALI_TEST_EQUALS(imageView.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, (float)height, TEST_LOCATION);
1113
1114   END_TEST;
1115 }
1116
1117 int UtcDaliImageViewHeightForWidthBackground(void)
1118 {
1119   ToolkitTestApplication application;
1120
1121   int widthBackground  = 100;
1122   int heightBackground = 200;
1123
1124   ImageView imageView = ImageView::New();
1125
1126   imageView.SetProperty(Control::Property::BACKGROUND,
1127                         {{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
1128                          {Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/gallery-small-1.jpg"},
1129                          {ImageVisual::Property::DESIRED_WIDTH, widthBackground},
1130                          {ImageVisual::Property::DESIRED_HEIGHT, heightBackground}});
1131
1132   application.GetScene().Add(imageView);
1133   application.SendNotification();
1134   application.Render();
1135
1136   Control control = Control::DownCast(imageView);
1137   DALI_TEST_CHECK(control);
1138   DALI_TEST_EQUALS(imageView.GetHeightForWidth(123.f), control.GetHeightForWidth(123.f), TEST_LOCATION);
1139   DALI_TEST_EQUALS(imageView.GetWidthForHeight(321.f), control.GetWidthForHeight(321.f), TEST_LOCATION);
1140
1141   END_TEST;
1142 }
1143
1144 int UtcDaliImageViewHeightForWidthBackgroundAndImage(void)
1145 {
1146   ToolkitTestApplication application;
1147
1148   int widthBackground  = 100;
1149   int heightBackground = 200;
1150   int width            = 300;
1151   int height           = 300;
1152
1153   ImageView imageView = ImageView::New();
1154
1155   imageView.SetProperty(Control::Property::BACKGROUND,
1156                         {{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
1157                          {Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/gallery-small-1.jpg"},
1158                          {ImageVisual::Property::DESIRED_WIDTH, widthBackground},
1159                          {ImageVisual::Property::DESIRED_HEIGHT, heightBackground}}); // 1 to 2 ratio
1160
1161   imageView.SetImage(gImage_600_RGB); // 1 to 1 ratio
1162
1163   application.GetScene().Add(imageView);
1164   application.SendNotification();
1165   application.Render();
1166
1167   DALI_TEST_EQUALS(imageView.GetHeightForWidth(width), (float)height, TEST_LOCATION);
1168   DALI_TEST_EQUALS(imageView.GetWidthForHeight(height), (float)width, TEST_LOCATION);
1169
1170   END_TEST;
1171 }
1172
1173 int UtcDaliImageViewSetImageUrl(void)
1174 {
1175   ToolkitTestApplication application;
1176
1177   ImageView imageView = ImageView::New();
1178   imageView.SetImage(TEST_IMAGE_FILE_NAME);
1179   TestUrl(imageView, TEST_IMAGE_FILE_NAME);
1180
1181   imageView.SetImage(TEST_IMAGE_FILE_NAME2);
1182   TestUrl(imageView, TEST_IMAGE_FILE_NAME2);
1183
1184   END_TEST;
1185 }
1186
1187 bool    gResourceReadySignalFired = false;
1188 Vector3 gNaturalSize;
1189
1190 void ResourceReadySignal(Control control)
1191 {
1192   gResourceReadySignalFired = true;
1193 }
1194
1195 void OnResourceReadySignalSVG(Control control)
1196 {
1197   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1198   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(control);
1199   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1200   Property::Map               resultMap;
1201   imageVisual.CreatePropertyMap(resultMap);
1202
1203   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1204   DALI_TEST_CHECK(transformValue);
1205   Property::Map* retMap = transformValue->GetMap();
1206   DALI_TEST_CHECK(retMap);
1207
1208   // Fitting mode should not be applied at this point
1209   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::SIZE)->Get<Vector2>(), Vector2::ZERO, TEST_LOCATION);
1210 }
1211
1212 int UtcDaliImageViewCheckResourceReady(void)
1213 {
1214   ToolkitTestApplication application;
1215
1216   gResourceReadySignalFired = false;
1217
1218   // Check ImageView with background and main image, to ensure both visuals are marked as loaded
1219   ImageView imageView = ImageView::New(TEST_GIF_FILE_NAME);
1220
1221   imageView.SetProperty(Control::Property::BACKGROUND,
1222                         {{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE},
1223                          {Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/gallery-small-1.jpg"},
1224                          {ImageVisual::Property::DESIRED_WIDTH, 100},
1225                          {ImageVisual::Property::DESIRED_HEIGHT, 200}});
1226
1227   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
1228
1229   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1230
1231   application.GetScene().Add(imageView);
1232
1233   // loading started, this waits for the loader thread
1234   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1235
1236   application.SendNotification();
1237   application.Render(16);
1238
1239   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1240
1241   application.SendNotification();
1242   application.Render();
1243
1244   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
1245
1246   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1247
1248   END_TEST;
1249 }
1250
1251 int UtcDaliImageViewSetImageTypeChangesP(void)
1252 {
1253   ToolkitTestApplication application;
1254
1255   ImageView                   imageView   = ImageView::New();
1256   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1257
1258   application.GetScene().Add(imageView);
1259
1260   std::string           url;
1261   Property::Map         map;
1262   Toolkit::Visual::Base visual;
1263
1264   Property::Value value = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1265   visual                = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1266
1267   application.SendNotification();
1268   application.Render(16);
1269
1270   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1271   value.Get(map);
1272   DALI_TEST_CHECK(map.Empty()); // Value should be empty
1273   DALI_TEST_CHECK(!visual);     // Visual should be invalid
1274
1275   // Set a URL
1276   imageView.SetImage("TEST_URL");
1277
1278   application.SendNotification();
1279   application.Render(16);
1280
1281   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1282   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1283
1284   DALI_TEST_CHECK(value.Get(url));  // Value should NOT be empty
1285   DALI_TEST_CHECK(!value.Get(map)); // Value should be empty
1286   DALI_TEST_CHECK(visual);          // Visual should be valid
1287
1288   // Set an empty URL
1289   imageView.SetImage("");
1290
1291   application.SendNotification();
1292   application.Render(16);
1293
1294   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1295   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1296
1297   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1298   value.Get(map);
1299   DALI_TEST_CHECK(map.Empty()); // Value should be empty
1300   DALI_TEST_CHECK(!visual);     // Visual should be invalid
1301
1302   // Set a URL in property map
1303   Property::Map propertyMap;
1304   propertyMap[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
1305   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1306
1307   application.SendNotification();
1308   application.Render(16);
1309
1310   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1311   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1312
1313   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1314   DALI_TEST_CHECK(value.Get(map));  // Value should NOT be empty
1315   DALI_TEST_CHECK(visual);          // Visual should be valid
1316
1317   // Set a URL in property map again
1318   propertyMap[ImageVisual::Property::URL] = gImage_34_RGBA;
1319   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1320
1321   application.SendNotification();
1322   application.Render(16);
1323
1324   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1325   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1326
1327   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1328   DALI_TEST_CHECK(value.Get(map));  // Value should NOT be empty
1329   DALI_TEST_CHECK(visual);          // Visual should be valid
1330
1331   // Set an empty URL in property map
1332   propertyMap[ImageVisual::Property::URL] = std::string();
1333   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1334
1335   application.SendNotification();
1336   application.Render(16);
1337
1338   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1339   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1340
1341   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1342   DALI_TEST_CHECK(value.Get(map));  // Value should NOT be empty
1343   DALI_TEST_CHECK(!visual);         // Visual should be invalid
1344
1345   // Set a URL in property map again
1346   propertyMap[ImageVisual::Property::URL] = gImage_34_RGBA;
1347   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1348
1349   application.SendNotification();
1350   application.Render(16);
1351
1352   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1353   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1354
1355   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1356   DALI_TEST_CHECK(value.Get(map));  // Value should NOT be empty
1357   DALI_TEST_CHECK(visual);          // Visual should be valid
1358
1359   // Set an empty property map
1360   propertyMap.Clear();
1361   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1362
1363   application.SendNotification();
1364   application.Render(16);
1365
1366   value  = imageView.GetProperty(imageView.GetPropertyIndex("image"));
1367   visual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1368
1369   DALI_TEST_CHECK(!value.Get(url)); // Value should be empty
1370   DALI_TEST_CHECK(value.Get(map));  // Value should NOT be empty
1371   DALI_TEST_CHECK(map.Empty());     // But PropertyMap should be empty
1372   DALI_TEST_CHECK(!visual);         // Visual should be invalid
1373
1374   END_TEST;
1375 }
1376
1377 int UtcDaliImageViewResourceUrlP(void)
1378 {
1379   ToolkitTestApplication application;
1380
1381   ImageView imageView = ImageView::New();
1382   DALI_TEST_CHECK(imageView.GetProperty(ImageView::Property::IMAGE).Get<std::string>().empty());
1383
1384   imageView.SetProperty(ImageView::Property::IMAGE, "TestString");
1385   DALI_TEST_EQUALS(imageView.GetProperty(ImageView::Property::IMAGE).Get<std::string>(), "TestString", TEST_LOCATION);
1386
1387   END_TEST;
1388 }
1389
1390 int UtcDaliImageViewReplaceImage(void)
1391 {
1392   ToolkitTestApplication application;
1393
1394   gResourceReadySignalFired = false;
1395
1396   // Check ImageView with background and main image, to ensure both visuals are marked as loaded
1397   ImageView imageView = ImageView::New(TEST_IMAGE_1);
1398
1399   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
1400
1401   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1402
1403   application.GetScene().Add(imageView);
1404
1405   application.SendNotification();
1406   application.Render(16);
1407
1408   // loading started, this waits for the loader thread for max 30 seconds
1409   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1410
1411   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
1412
1413   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1414
1415   gResourceReadySignalFired = false;
1416
1417   imageView.SetImage(TEST_IMAGE_2);
1418
1419   application.SendNotification();
1420   application.Render(16);
1421
1422   // loading started, this waits for the loader thread for max 30 seconds
1423   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1424
1425   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
1426
1427   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
1428
1429   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1430
1431   END_TEST;
1432 }
1433
1434 int UtcDaliImageViewReloadAlphaMaskImage(void)
1435 {
1436   ToolkitTestApplication application;
1437
1438   gResourceReadySignalFired = false;
1439
1440   ImageView     dummy     = ImageView::New();
1441   ImageView     imageView = ImageView::New();
1442   Property::Map propertyMap;
1443
1444   // To keep alpha mask cached, scene on some dummy image.
1445   // Note : If we don't cache alpha mask image, the reference count of mask image become zero.
1446   // In this case, we might need to wait mask image loading, which is not neccesary & can be changed behavior.
1447   propertyMap[ImageVisual::Property::URL]            = gImage_600_RGB;
1448   propertyMap[ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
1449   dummy.SetProperty(ImageView::Property::IMAGE, propertyMap);
1450
1451   application.GetScene().Add(dummy);
1452
1453   application.SendNotification();
1454   application.Render(16);
1455
1456   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1457
1458   application.SendNotification();
1459   application.Render(16);
1460
1461   propertyMap.Clear();
1462   propertyMap[ImageVisual::Property::URL]            = gImage_34_RGBA;
1463   propertyMap[ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
1464   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
1465
1466   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
1467
1468   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1469
1470   application.GetScene().Add(imageView);
1471
1472   application.SendNotification();
1473   application.Render(16);
1474
1475   // Load image and use cached mask. Now we try to apply masking.
1476   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1477
1478   DALI_TEST_EQUALS(gResourceReadySignalFired, false, TEST_LOCATION);
1479
1480   // Cancel apply masking.
1481   imageView.Unparent();
1482
1483   application.SendNotification();
1484   application.Render(16);
1485
1486   // Reload same image again.
1487   application.GetScene().Add(imageView);
1488
1489   application.SendNotification();
1490   application.Render(16);
1491
1492   // Finish apply masking.
1493   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1494
1495   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
1496   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
1497   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1498
1499   END_TEST;
1500 }
1501
1502 void OnRelayoutOverride(Size size)
1503 {
1504   gNaturalSize = size; // Size Relayout is using
1505 }
1506
1507 int UtcDaliImageViewReplaceImageAndGetNaturalSize(void)
1508 {
1509   ToolkitTestApplication application;
1510
1511   // Check ImageView with background and main image, to ensure both visuals are marked as loaded
1512   ImageView imageView = ImageView::New(TEST_IMAGE_1);
1513   imageView.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
1514
1515   DummyControl        dummyControl = DummyControl::New(true);
1516   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
1517   dummyControl.SetResizePolicy(ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS);
1518
1519   dummyControl.Add(imageView);
1520   dummyImpl.SetRelayoutCallback(&OnRelayoutOverride);
1521   application.GetScene().Add(dummyControl);
1522
1523   application.SendNotification();
1524   application.Render();
1525
1526   // loading started, this waits for the loader thread for max 30 seconds
1527   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1528
1529   DALI_TEST_EQUALS(gNaturalSize.width, 1024.0f, TEST_LOCATION);
1530   DALI_TEST_EQUALS(gNaturalSize.height, 1024.0f, TEST_LOCATION);
1531
1532   gNaturalSize = Vector3::ZERO;
1533
1534   imageView.SetImage(gImage_600_RGB);
1535
1536   // Waiting for resourceReady so SendNotifcation not called here.
1537
1538   // loading started, this waits for the loader thread for max 30 seconds
1539   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1540
1541   // Trigger a potential relayout
1542   application.SendNotification();
1543   application.Render();
1544
1545   DALI_TEST_EQUALS(gNaturalSize.width, 600.0f, TEST_LOCATION);
1546   DALI_TEST_EQUALS(gNaturalSize.height, 600.0f, TEST_LOCATION);
1547
1548   END_TEST;
1549 }
1550
1551 int UtcDaliImageViewResourceReadySignalWithImmediateLoad(void)
1552 {
1553   tet_infoline("Test Setting Image with IMMEDIATE load and receving ResourceReadySignal before staged.");
1554
1555   ToolkitTestApplication application;
1556
1557   gResourceReadySignalFired = false;
1558
1559   Property::Map imageMap;
1560
1561   imageMap[ImageVisual::Property::URL]         = gImage_34_RGBA;
1562   imageMap[ImageVisual::Property::LOAD_POLICY] = ImageVisual::LoadPolicy::IMMEDIATE;
1563
1564   tet_infoline("Creating ImageView without URL so image does not start loading");
1565   ImageView imageView = ImageView::New();
1566   tet_infoline("Connect to image loaded signal before setting image");
1567   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1568   tet_infoline("Setting Image with IMMEDIATE load, signal already connected so will be triggered.");
1569   imageView.SetProperty(ImageView::Property::IMAGE, imageMap);
1570
1571   // loading started, this waits for the loader thread
1572   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1573
1574   application.SendNotification();
1575   application.Render(16);
1576
1577   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1578
1579   END_TEST;
1580 }
1581
1582 int UtcDaliImageViewResourceReadySignalWithReusedImage(void)
1583 {
1584   tet_infoline("Test Setting Image that was already loaded by another ImageView and still getting ResourceReadySignal.");
1585
1586   ToolkitTestApplication application;
1587
1588   gResourceReadySignalFired = false;
1589
1590   Property::Map imageMap;
1591
1592   imageMap[ImageVisual::Property::URL]         = gImage_34_RGBA;
1593   imageMap[ImageVisual::Property::LOAD_POLICY] = ImageVisual::LoadPolicy::IMMEDIATE;
1594
1595   ImageView imageView = ImageView::New();
1596   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1597   imageView.SetProperty(ImageView::Property::IMAGE, imageMap);
1598
1599   // loading started, this waits for the loader thread
1600   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1601
1602   application.SendNotification();
1603   application.Render(16);
1604
1605   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1606   gResourceReadySignalFired = false;
1607
1608   ImageView imageViewWithExistingImage = ImageView::New();
1609   imageViewWithExistingImage.ResourceReadySignal().Connect(&ResourceReadySignal);
1610   imageViewWithExistingImage.SetProperty(ImageView::Property::IMAGE, imageMap);
1611
1612   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1613
1614   END_TEST;
1615 }
1616
1617 int UtcDaliImageViewResourceReadySignalWithReusedImage02(void)
1618 {
1619   tet_infoline("Test Setting Image that was already loaded by another ImageView and still getting ResourceReadySignal when staged.");
1620
1621   ToolkitTestApplication application;
1622
1623   gResourceReadySignalFired = false;
1624
1625   Property::Map imageImmediateLoadingMap;
1626   imageImmediateLoadingMap[ImageVisual::Property::URL]         = gImage_34_RGBA;
1627   imageImmediateLoadingMap[ImageVisual::Property::LOAD_POLICY] = ImageVisual::LoadPolicy::IMMEDIATE;
1628
1629   tet_infoline("Immediate load an image");
1630   ImageView imageView = ImageView::New();
1631   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
1632   imageView.SetProperty(ImageView::Property::IMAGE, imageImmediateLoadingMap);
1633
1634   // loading started, this waits for the loader thread
1635   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1636
1637   application.SendNotification();
1638   application.Render(16);
1639
1640   tet_infoline("Check image loaded");
1641   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1642   gResourceReadySignalFired = false;
1643
1644   tet_infoline("Create another ImageView with the same URL");
1645   ImageView imageViewWithExistingImage = ImageView::New(gImage_34_RGBA);
1646   tet_infoline("Connect to ResourceReady signal for second ImageView, it should still fire as resource is ready");
1647   imageViewWithExistingImage.ResourceReadySignal().Connect(&ResourceReadySignal);
1648
1649   application.GetScene().Add(imageViewWithExistingImage);
1650
1651   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
1652
1653   END_TEST;
1654 }
1655
1656 int UtcDaliImageViewPaddingProperty(void)
1657 {
1658   ToolkitTestApplication application;
1659
1660   ImageView     imageView = ImageView::New();
1661   Property::Map imagePropertyMap;
1662   imagePropertyMap[Toolkit::Visual::Property::TYPE]       = Toolkit::Visual::IMAGE;
1663   imagePropertyMap[Toolkit::ImageVisual::Property::URL]   = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
1664   imagePropertyMap[ImageVisual::Property::DESIRED_WIDTH]  = 128;
1665   imagePropertyMap[ImageVisual::Property::DESIRED_HEIGHT] = 128;
1666   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imagePropertyMap);
1667   imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1668   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1669   imageView.SetProperty(Control::Property::PADDING, Extents(15, 10, 5, 10));
1670   application.GetScene().Add(imageView);
1671
1672   application.SendNotification();
1673   application.Render();
1674
1675   DALI_TEST_EQUALS(imageView.GetProperty<Extents>(Control::Property::PADDING), Extents(15, 10, 5, 10), TEST_LOCATION);
1676
1677   ImageView childImage = ImageView::New();
1678   childImage.SetBackgroundColor(Color::BLACK);
1679   childImage.SetProperty(Actor::Property::SIZE, Vector2(10.f, 10.f));
1680   imageView.Add(childImage);
1681
1682   application.SendNotification();
1683   application.Render();
1684
1685   // Child ImageView should be positioned dependinig on Parent ImageView's Padding value
1686   DALI_TEST_EQUALS(childImage.GetProperty<Vector3>(Dali::Actor::Property::POSITION), Vector3(15, 5, 0), TEST_LOCATION);
1687
1688   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1689   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1690   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1691   Property::Map               resultMap;
1692   imageVisual.CreatePropertyMap(resultMap);
1693
1694   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1695   DALI_TEST_CHECK(transformValue);
1696   Property::Map* retMap = transformValue->GetMap();
1697   DALI_TEST_CHECK(retMap);
1698
1699   // Image Visual should be positioned depending on ImageView's padding
1700   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET)->Get<Vector2>(), Vector2(15, 5), TEST_LOCATION);
1701
1702   END_TEST;
1703 }
1704
1705 int UtcDaliImageViewPaddingProperty02(void)
1706 {
1707   ToolkitTestApplication application;
1708
1709   ImageView     imageView = ImageView::New();
1710   Property::Map imagePropertyMap;
1711   imagePropertyMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
1712   imagePropertyMap[Toolkit::ImageVisual::Property::URL]        = TEST_RESOURCE_DIR "/Kid1.svg";
1713   imagePropertyMap[ImageVisual::Property::DESIRED_WIDTH]       = 128;
1714   imagePropertyMap[ImageVisual::Property::DESIRED_HEIGHT]      = 128;
1715   imagePropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
1716   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imagePropertyMap);
1717   imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1718   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1719   imageView.SetProperty(Control::Property::PADDING, Extents(15, 10, 5, 10));
1720   application.GetScene().Add(imageView);
1721
1722   application.SendNotification();
1723   application.Render();
1724
1725   DALI_TEST_EQUALS(imageView.GetProperty<Extents>(Control::Property::PADDING), Extents(15, 10, 5, 10), TEST_LOCATION);
1726
1727   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1728   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1729   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1730   Property::Map               resultMap;
1731   imageVisual.CreatePropertyMap(resultMap);
1732
1733   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1734   DALI_TEST_CHECK(transformValue);
1735   Property::Map* retMap = transformValue->GetMap();
1736   DALI_TEST_CHECK(retMap);
1737
1738   // Image Visual should be positioned depending on ImageView's padding
1739   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET)->Get<Vector2>(), Vector2(15, 5), TEST_LOCATION);
1740
1741   END_TEST;
1742 }
1743
1744 int UtcDaliImageViewPaddingProperty03(void)
1745 {
1746   tet_infoline("Test Setting Image Padding then removing it.");
1747
1748   ToolkitTestApplication application;
1749
1750   ImageView     imageView = ImageView::New();
1751   Property::Map imagePropertyMap;
1752   imagePropertyMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
1753   imagePropertyMap[Toolkit::ImageVisual::Property::URL]        = TEST_RESOURCE_DIR "/Kid1.svg";
1754   imagePropertyMap[ImageVisual::Property::DESIRED_WIDTH]       = 128;
1755   imagePropertyMap[ImageVisual::Property::DESIRED_HEIGHT]      = 128;
1756   imagePropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
1757   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imagePropertyMap);
1758   imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1759   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1760   imageView.SetProperty(Control::Property::PADDING, Extents(15, 10, 5, 10));
1761   application.GetScene().Add(imageView);
1762
1763   application.SendNotification();
1764   application.Render();
1765
1766   DALI_TEST_EQUALS(imageView.GetProperty<Extents>(Control::Property::PADDING), Extents(15, 10, 5, 10), TEST_LOCATION);
1767
1768   tet_infoline("Remove Padding and test Visual is position correctly");
1769
1770   imageView.SetProperty(Control::Property::PADDING, Extents(0, 0, 0, 0));
1771
1772   application.SendNotification();
1773   application.Render();
1774
1775   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1776   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1777   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1778   Property::Map               resultMap;
1779   imageVisual.CreatePropertyMap(resultMap);
1780
1781   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1782   DALI_TEST_CHECK(transformValue);
1783   Property::Map* retMap = transformValue->GetMap();
1784   DALI_TEST_CHECK(retMap);
1785
1786   // Image Visual should be positioned depending on ImageView's padding
1787   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET)->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
1788
1789   END_TEST;
1790 }
1791
1792 int UtcDaliImageViewPaddingProperty04(void)
1793 {
1794   tet_infoline("Test Setting Image Padding then removing it. Visual Fitting Mode as Fill");
1795
1796   ToolkitTestApplication application;
1797
1798   ImageView     imageView = ImageView::New();
1799   Property::Map imagePropertyMap;
1800   imagePropertyMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
1801   imagePropertyMap[Toolkit::ImageVisual::Property::URL]        = TEST_RESOURCE_DIR "/Kid1.svg";
1802   imagePropertyMap[ImageVisual::Property::DESIRED_WIDTH]       = 128;
1803   imagePropertyMap[ImageVisual::Property::DESIRED_HEIGHT]      = 128;
1804   imagePropertyMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FILL;
1805   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imagePropertyMap);
1806   imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1807   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1808   imageView.SetProperty(Control::Property::PADDING, Extents(15, 10, 5, 10));
1809   application.GetScene().Add(imageView);
1810
1811   application.SendNotification();
1812   application.Render();
1813
1814   DALI_TEST_EQUALS(imageView.GetProperty<Extents>(Control::Property::PADDING), Extents(15, 10, 5, 10), TEST_LOCATION);
1815
1816   tet_infoline("Remove Padding and test Visual is position correctly");
1817
1818   imageView.SetProperty(Control::Property::PADDING, Extents(0, 0, 0, 0));
1819
1820   application.SendNotification();
1821   application.Render();
1822
1823   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1824   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1825   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1826   Property::Map               resultMap;
1827   imageVisual.CreatePropertyMap(resultMap);
1828
1829   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1830   DALI_TEST_CHECK(transformValue);
1831   Property::Map* retMap = transformValue->GetMap();
1832   DALI_TEST_CHECK(retMap);
1833
1834   // Image Visual should be positioned depending on ImageView's padding
1835   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET)->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
1836
1837   END_TEST;
1838 }
1839
1840 int UtcDaliImageViewTransformTest01(void)
1841 {
1842   tet_infoline("Test Setting a offset transform on the ImageView");
1843
1844   ToolkitTestApplication application;
1845
1846   ImageView     imageView = ImageView::New();
1847   Property::Map imagePropertyMap;
1848   imagePropertyMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE)
1849     .Add(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/Kid1.svg")
1850     .Add(ImageVisual::Property::DESIRED_WIDTH, 120)
1851     .Add(ImageVisual::Property::DESIRED_HEIGHT, 120)
1852     .Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FILL)
1853     .Add(Visual::Property::TRANSFORM,
1854          Property::Map().Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY,
1855                              Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE))
1856            .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(8, 8)));
1857
1858   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imagePropertyMap);
1859   imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1860   imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1861   application.GetScene().Add(imageView);
1862
1863   application.SendNotification();
1864   application.Render();
1865
1866   // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
1867   Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
1868   Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
1869   Property::Map               resultMap;
1870   imageVisual.CreatePropertyMap(resultMap);
1871
1872   Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
1873   DALI_TEST_CHECK(transformValue);
1874   Property::Map* retMap = transformValue->GetMap();
1875   DALI_TEST_CHECK(retMap);
1876
1877   // Image Visual should be positioned depending on ImageView's padding
1878   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET)->Get<Vector2>(), Vector2(8, 8), TEST_LOCATION);
1879   DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::OFFSET_POLICY)->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
1880
1881   END_TEST;
1882 }
1883
1884 int UtcDaliImageViewUsingAtlasAndGetNaturalSize(void)
1885 {
1886   ToolkitTestApplication application;
1887
1888   // Check ImageView with background and main image, to ensure both visuals are marked as loaded
1889   ImageView     imageView = ImageView::New();
1890   Property::Map imageMap;
1891   imageMap[Toolkit::Visual::Property::TYPE]          = Toolkit::Visual::IMAGE;
1892   imageMap[Toolkit::ImageVisual::Property::URL]      = gImage_34_RGBA;
1893   imageMap[Toolkit::ImageVisual::Property::ATLASING] = true;
1894   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
1895   application.GetScene().Add(imageView);
1896
1897   // Trigger a potential relayout
1898   application.SendNotification();
1899   application.Render();
1900
1901   Vector3 naturalSize = imageView.GetNaturalSize();
1902
1903   DALI_TEST_EQUALS(naturalSize.width, 34.0f, TEST_LOCATION);
1904   DALI_TEST_EQUALS(naturalSize.height, 34.0f, TEST_LOCATION);
1905
1906   END_TEST;
1907 }
1908
1909 int UtcDaliImageViewFillMode(void)
1910 {
1911   ToolkitTestApplication application;
1912
1913   tet_infoline("Create an ImageVisual without padding and set the fill-mode to fill");
1914
1915   ImageView     imageView = ImageView::New();
1916   Property::Map imageMap;
1917   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
1918   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB);
1919   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, DevelVisual::FittingMode::FILL);
1920
1921   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
1922
1923   application.GetScene().Add(imageView);
1924
1925   // Trigger a potential relayout
1926   application.SendNotification();
1927   application.Render();
1928
1929   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
1930   Property::Map         returnedMap;
1931   visual.CreatePropertyMap(returnedMap);
1932
1933   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
1934   DALI_TEST_CHECK(value);
1935   Property::Map* map = value->GetMap();
1936   DALI_TEST_CHECK(map);
1937
1938   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
1939   DALI_TEST_CHECK(value);
1940   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2::ONE, TEST_LOCATION);
1941
1942   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
1943   DALI_TEST_CHECK(value);
1944   DALI_TEST_CHECK(value->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
1945
1946   END_TEST;
1947 }
1948
1949 int UtcDaliImageViewFittingModeFitKeepAspectRatio(void)
1950 {
1951   ToolkitTestApplication application;
1952
1953   tet_infoline("Create an ImageVisual using FitKeepAspectRatio ( image: [600,600], view: [600,700] )");
1954   tet_infoline("  There should be need to change the transform, offset is adjusted to fit inside");
1955
1956   ImageView     imageView = ImageView::New();
1957   Property::Map imageMap;
1958   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
1959   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
1960   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO);
1961
1962   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
1963   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 700));
1964
1965   application.GetScene().Add(imageView);
1966
1967   // Trigger a potential relayout
1968   application.SendNotification();
1969   application.Render();
1970
1971   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
1972   Property::Map         returnedMap;
1973   visual.CreatePropertyMap(returnedMap);
1974
1975   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
1976   DALI_TEST_CHECK(value);
1977   Property::Map* map = value->GetMap();
1978   DALI_TEST_CHECK(map);
1979
1980   // If there's
1981   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
1982   DALI_TEST_CHECK(value);
1983   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION);
1984
1985   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
1986   DALI_TEST_CHECK(value);
1987   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
1988
1989   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
1990   DALI_TEST_CHECK(value);
1991   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 50), TEST_LOCATION);
1992
1993   END_TEST;
1994 }
1995
1996 int UtcDaliImageViewFittingModesFill(void)
1997 {
1998   ToolkitTestApplication application;
1999
2000   tet_infoline("Create an ImageVisual using Fill ( image: [600,600], view: [600,700] )");
2001   tet_infoline("  There should be no need to change the transform, only size is changed to fit view");
2002
2003   ImageView     imageView = ImageView::New();
2004   Property::Map imageMap;
2005   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2006   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2007   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FILL);
2008
2009   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2010   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 700));
2011
2012   application.GetScene().Add(imageView);
2013
2014   // Trigger a potential relayout
2015   application.SendNotification();
2016   application.Render();
2017
2018   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2019   Property::Map         returnedMap;
2020   visual.CreatePropertyMap(returnedMap);
2021
2022   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2023   DALI_TEST_CHECK(value);
2024   Property::Map* map = value->GetMap();
2025   DALI_TEST_CHECK(map);
2026
2027   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2028   DALI_TEST_CHECK(value);
2029   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2::ONE, TEST_LOCATION); // Change the internal size according to the image view size
2030
2031   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2032   DALI_TEST_CHECK(value);
2033   DALI_TEST_CHECK(value->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
2034
2035   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2036   DALI_TEST_CHECK(value);
2037   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2038
2039   END_TEST;
2040 }
2041
2042 int UtcDaliImageViewFittingModesOverfitKeepAspectRatio(void)
2043 {
2044   ToolkitTestApplication application;
2045
2046   tet_infoline("Create an ImageVisual using OverFitKeepAspectRatio ( image: [600,600], view: [600,500] )");
2047   tet_infoline("  offset or size is the same as view, but adjust internally using pixelArea ");
2048
2049   ImageView     imageView = ImageView::New();
2050   Property::Map imageMap;
2051   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2052   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2053   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::OVER_FIT_KEEP_ASPECT_RATIO);
2054
2055   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2056   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 500));
2057
2058   application.GetScene().Add(imageView);
2059
2060   // Trigger a potential relayout
2061   application.SendNotification();
2062   application.Render();
2063
2064   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2065   Property::Map         returnedMap;
2066   visual.CreatePropertyMap(returnedMap);
2067
2068   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2069   DALI_TEST_CHECK(value);
2070   Property::Map* map = value->GetMap();
2071   DALI_TEST_CHECK(map);
2072
2073   // If there's
2074   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2075   DALI_TEST_CHECK(value);
2076   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 500), TEST_LOCATION); // Change the internal size according to the image view size
2077
2078   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2079   DALI_TEST_CHECK(value);
2080   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2081
2082   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2083   DALI_TEST_CHECK(value);
2084   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2085
2086   END_TEST;
2087 }
2088
2089 int UtcDaliImageViewFittingModesCenter01(void)
2090 {
2091   ToolkitTestApplication application;
2092
2093   tet_infoline("Create an ImageVisual using Center ( image: [600,600], view: [700,700] )");
2094   tet_infoline("  There should be need to change the transform, offset is adjusted to fit inside");
2095
2096   ImageView     imageView = ImageView::New();
2097   Property::Map imageMap;
2098   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2099   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2100   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::CENTER);
2101
2102   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2103   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 700));
2104
2105   application.GetScene().Add(imageView);
2106
2107   // Trigger a potential relayout
2108   application.SendNotification();
2109   application.Render();
2110
2111   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2112   Property::Map         returnedMap;
2113   visual.CreatePropertyMap(returnedMap);
2114
2115   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2116   DALI_TEST_CHECK(value);
2117   Property::Map* map = value->GetMap();
2118   DALI_TEST_CHECK(map);
2119
2120   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2121   DALI_TEST_CHECK(value);
2122   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2123
2124   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2125   DALI_TEST_CHECK(value);
2126   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2127
2128   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2129   DALI_TEST_CHECK(value);
2130   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 50), TEST_LOCATION);
2131
2132   END_TEST;
2133 }
2134
2135 int UtcDaliImageViewFittingModesCenter02(void)
2136 {
2137   ToolkitTestApplication application;
2138
2139   tet_infoline("Create an ImageVisual using Center ( image: [600,600], view: [500,500] )");
2140   tet_infoline("  There should be need to change the transform, offset is adjusted to fit inside");
2141
2142   ImageView     imageView = ImageView::New();
2143   Property::Map imageMap;
2144   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2145   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2146   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::CENTER);
2147
2148   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2149   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 700));
2150
2151   application.GetScene().Add(imageView);
2152
2153   // Trigger a potential relayout
2154   application.SendNotification();
2155   application.Render();
2156
2157   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2158   Property::Map         returnedMap;
2159   visual.CreatePropertyMap(returnedMap);
2160
2161   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2162   DALI_TEST_CHECK(value);
2163   Property::Map* map = value->GetMap();
2164   DALI_TEST_CHECK(map);
2165
2166   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2167   DALI_TEST_CHECK(value);
2168   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2169
2170   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2171   DALI_TEST_CHECK(value);
2172   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2173
2174   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2175   DALI_TEST_CHECK(value);
2176   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 50), TEST_LOCATION);
2177
2178   END_TEST;
2179 }
2180
2181 int UtcDaliImageViewFittingModesFitHeight01(void)
2182 {
2183   ToolkitTestApplication application;
2184
2185   tet_infoline("Create an ImageVisual using FitHeight ( image: [600,600], view: [600,700] )");
2186
2187   ImageView     imageView = ImageView::New();
2188   Property::Map imageMap;
2189   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2190   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2191   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_HEIGHT);
2192
2193   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2194   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 700));
2195
2196   application.GetScene().Add(imageView);
2197
2198   // Trigger a potential relayout
2199   application.SendNotification();
2200   application.Render();
2201
2202   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2203   Property::Map         returnedMap;
2204   visual.CreatePropertyMap(returnedMap);
2205
2206   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2207   DALI_TEST_CHECK(value);
2208   Property::Map* map = value->GetMap();
2209   DALI_TEST_CHECK(map);
2210
2211   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2212   DALI_TEST_CHECK(value);
2213   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 700), TEST_LOCATION); // Change the internal size according to the image view size
2214
2215   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2216   DALI_TEST_CHECK(value);
2217   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2218
2219   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2220   DALI_TEST_CHECK(value);
2221   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2222
2223   END_TEST;
2224 }
2225
2226 int UtcDaliImageViewFittingModesFitHeight02(void)
2227 {
2228   ToolkitTestApplication application;
2229
2230   tet_infoline("Create an ImageVisual using FitHeight ( image: [600,600], view: [700,600] )");
2231
2232   ImageView     imageView = ImageView::New();
2233   Property::Map imageMap;
2234   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2235   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 249x169 image
2236   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_HEIGHT);
2237
2238   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2239   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 600));
2240
2241   application.GetScene().Add(imageView);
2242
2243   // Trigger a potential relayout
2244   application.SendNotification();
2245   application.Render();
2246
2247   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2248   Property::Map         returnedMap;
2249   visual.CreatePropertyMap(returnedMap);
2250
2251   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2252   DALI_TEST_CHECK(value);
2253   Property::Map* map = value->GetMap();
2254   DALI_TEST_CHECK(map);
2255
2256   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2257   DALI_TEST_CHECK(value);
2258   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2259
2260   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2261   DALI_TEST_CHECK(value);
2262   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2263
2264   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2265   DALI_TEST_CHECK(value);
2266   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2267
2268   END_TEST;
2269 }
2270
2271 int UtcDaliImageViewFittingModesFitWidth01(void)
2272 {
2273   ToolkitTestApplication application;
2274
2275   tet_infoline("Create an ImageVisual using FitWidth ( image: [600,600], view: [600,700] )");
2276
2277   ImageView     imageView = ImageView::New();
2278   Property::Map imageMap;
2279   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2280   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2281   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_WIDTH);
2282
2283   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2284   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 700));
2285
2286   application.GetScene().Add(imageView);
2287
2288   // Trigger a potential relayout
2289   application.SendNotification();
2290   application.Render();
2291
2292   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2293   Property::Map         returnedMap;
2294   visual.CreatePropertyMap(returnedMap);
2295
2296   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2297   DALI_TEST_CHECK(value);
2298   Property::Map* map = value->GetMap();
2299   DALI_TEST_CHECK(map);
2300
2301   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2302   DALI_TEST_CHECK(value);
2303   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2304
2305   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2306   DALI_TEST_CHECK(value);
2307   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2308
2309   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2310   DALI_TEST_CHECK(value);
2311   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 50), TEST_LOCATION);
2312
2313   END_TEST;
2314 }
2315
2316 int UtcDaliImageViewFittingModesFitWidth02(void)
2317 {
2318   ToolkitTestApplication application;
2319
2320   tet_infoline("Create an ImageVisual using FitWidth ( image: [600,600], view:[700,600] )");
2321
2322   ImageView     imageView = ImageView::New();
2323   Property::Map imageMap;
2324   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2325   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 249x169 image
2326   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_WIDTH);
2327
2328   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2329   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 600));
2330
2331   application.GetScene().Add(imageView);
2332
2333   // Trigger a potential relayout
2334   application.SendNotification();
2335   application.Render();
2336
2337   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2338   Property::Map         returnedMap;
2339   visual.CreatePropertyMap(returnedMap);
2340
2341   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2342   DALI_TEST_CHECK(value);
2343   Property::Map* map = value->GetMap();
2344   DALI_TEST_CHECK(map);
2345
2346   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2347   DALI_TEST_CHECK(value);
2348   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 600), TEST_LOCATION); // Change the internal size according to the image view size
2349
2350   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2351   DALI_TEST_CHECK(value);
2352   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2353
2354   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2355   DALI_TEST_CHECK(value);
2356   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2357
2358   END_TEST;
2359 }
2360
2361 int UtcDaliImageViewFittingModesChangeFittingMode01(void)
2362 {
2363   ToolkitTestApplication application;
2364
2365   tet_infoline("UtcDaliImageViewFittingModesChangeFittingMode, image: [600,600], view:[800,700]");
2366
2367   ImageView imageView = ImageView::New();
2368
2369   // 1. Render using FittingMode::SHRINK_TO_FIT
2370   Property::Map imageMap;
2371   imageMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2372   imageMap[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2373   imageMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
2374
2375   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2376   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2377
2378   application.GetScene().Add(imageView);
2379
2380   // Trigger a potential relayout
2381   application.SendNotification();
2382   application.Render();
2383
2384   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2385   Property::Map         returnedMap;
2386   visual.CreatePropertyMap(returnedMap);
2387
2388   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2389   DALI_TEST_CHECK(value);
2390   Property::Map* map = value->GetMap();
2391   DALI_TEST_CHECK(map);
2392
2393   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2394   DALI_TEST_CHECK(value);
2395   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 700), TEST_LOCATION); // Change the internal size according to the image view size
2396
2397   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2398   DALI_TEST_CHECK(value);
2399   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2400
2401   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2402   DALI_TEST_CHECK(value);
2403   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2404
2405   // 2. Render again using DevelVisaul::CENTER
2406   Property::Map imageMap2;
2407   imageMap2[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2408   imageMap2[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2409   imageMap2[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::CENTER;
2410
2411   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap2);
2412   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2413
2414   application.GetScene().Add(imageView);
2415
2416   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2417
2418   // Trigger a potential relayout
2419   application.SendNotification();
2420   application.Render();
2421
2422   returnedMap.Clear();
2423   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2424
2425   visual.CreatePropertyMap(returnedMap);
2426
2427   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2428   DALI_TEST_CHECK(value);
2429   map = value->GetMap();
2430   DALI_TEST_CHECK(map);
2431
2432   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2433   DALI_TEST_CHECK(value);
2434   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2435
2436   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2437   DALI_TEST_CHECK(value);
2438   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2439
2440   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2441   DALI_TEST_CHECK(value);
2442   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(100, 50), TEST_LOCATION);
2443
2444   // 3. Render again using before fittingMode
2445   Property::Map imageMap3;
2446   imageMap3[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2447   imageMap3[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2448   imageMap3[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
2449
2450   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap3);
2451   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2452
2453   application.GetScene().Add(imageView);
2454
2455   // Trigger a potential relayout
2456   application.SendNotification();
2457   application.Render();
2458
2459   returnedMap.Clear();
2460   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2461   visual.CreatePropertyMap(returnedMap);
2462
2463   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2464   DALI_TEST_CHECK(value);
2465   map = value->GetMap();
2466   DALI_TEST_CHECK(map);
2467
2468   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2469   DALI_TEST_CHECK(value);
2470   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 700), TEST_LOCATION); // Change the internal size according to the image view size
2471
2472   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2473   DALI_TEST_CHECK(value);
2474   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2475
2476   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2477   DALI_TEST_CHECK(value);
2478   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2479
2480   END_TEST;
2481 }
2482
2483 int UtcDaliImageViewFittingModesChangeFittingMode02(void)
2484 {
2485   ToolkitTestApplication application;
2486
2487   tet_infoline("UtcDaliImageViewFittingModesChangeFittingMode, image: [600,600], view:[800,700]");
2488
2489   ImageView imageView = ImageView::New();
2490
2491   // 1. Render using FittingMode::OVER_FIT_KEEP_ASPECT_RATIO
2492   Property::Map imageMap;
2493   imageMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2494   imageMap[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2495   imageMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::OVER_FIT_KEEP_ASPECT_RATIO;
2496
2497   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2498   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2499
2500   application.GetScene().Add(imageView);
2501
2502   // Trigger a potential relayout
2503   application.SendNotification();
2504   application.Render();
2505
2506   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2507   Property::Map         returnedMap;
2508   visual.CreatePropertyMap(returnedMap);
2509
2510   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2511   DALI_TEST_CHECK(value);
2512   Property::Map* map = value->GetMap();
2513   DALI_TEST_CHECK(map);
2514
2515   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2516   DALI_TEST_CHECK(value);
2517   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(800, 700), TEST_LOCATION); // Change the internal size according to the image view size
2518
2519   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2520   DALI_TEST_CHECK(value);
2521   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2522
2523   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2524   DALI_TEST_CHECK(value);
2525   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
2526
2527   // 2. Render again using DevelVisaul::CENTER
2528   Property::Map imageMap2;
2529   imageMap2[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2530   imageMap2[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2531   imageMap2[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::CENTER;
2532
2533   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap2);
2534   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2535
2536   application.GetScene().Add(imageView);
2537
2538   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2539
2540   // Trigger a potential relayout
2541   application.SendNotification();
2542   application.Render();
2543
2544   returnedMap.Clear();
2545   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2546
2547   visual.CreatePropertyMap(returnedMap);
2548
2549   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2550   DALI_TEST_CHECK(value);
2551   map = value->GetMap();
2552   DALI_TEST_CHECK(map);
2553
2554   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2555   DALI_TEST_CHECK(value);
2556   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2557
2558   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2559   DALI_TEST_CHECK(value);
2560   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2561
2562   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2563   DALI_TEST_CHECK(value);
2564   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(100, 50), TEST_LOCATION);
2565
2566   // 3. Render again using before fittingMode
2567   Property::Map imageMap3;
2568   imageMap3[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2569   imageMap3[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2570   imageMap3[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::OVER_FIT_KEEP_ASPECT_RATIO;
2571
2572   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap3);
2573   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2574
2575   application.GetScene().Add(imageView);
2576
2577   // Trigger a potential relayout
2578   application.SendNotification();
2579   application.Render();
2580
2581   returnedMap.Clear();
2582   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2583   visual.CreatePropertyMap(returnedMap);
2584
2585   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2586   DALI_TEST_CHECK(value);
2587   map = value->GetMap();
2588   DALI_TEST_CHECK(map);
2589
2590   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2591   DALI_TEST_CHECK(value);
2592   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(800, 700), TEST_LOCATION); // Change the internal size according to the image view size
2593
2594   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2595   DALI_TEST_CHECK(value);
2596   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2597
2598   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2599   DALI_TEST_CHECK(value);
2600   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
2601
2602   END_TEST;
2603 }
2604
2605 int UtcDaliImageViewFittingModesWithAnimatedVectorImageVisual(void)
2606 {
2607   ToolkitTestApplication application;
2608
2609   tet_infoline("Create an ImageVisual using SCALE_TO_FILL and animated vector image ( image: [600,600], view:[600,600] )");
2610
2611   ImageView     imageView = ImageView::New();
2612   Property::Map imageMap;
2613   imageMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE);
2614   imageMap.Add(Toolkit::ImageVisual::Property::URL, TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME); // 249x169 image
2615
2616   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2617   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 600));
2618
2619   application.GetScene().Add(imageView);
2620
2621   // Trigger a potential relayout
2622   application.SendNotification();
2623   application.Render();
2624
2625   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2626   Property::Map         returnedMap;
2627   visual.CreatePropertyMap(returnedMap);
2628
2629   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2630   DALI_TEST_CHECK(value);
2631   Property::Map* map = value->GetMap();
2632   DALI_TEST_CHECK(map);
2633
2634   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2635   DALI_TEST_CHECK(value);
2636   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2::ONE, TEST_LOCATION); // Relative size so will take up 100%
2637
2638   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2639   DALI_TEST_CHECK(value);
2640   DALI_TEST_CHECK(value->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
2641
2642   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2643   DALI_TEST_CHECK(value);
2644   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2645
2646   END_TEST;
2647 }
2648
2649 int UtcDaliImageViewCustomShader(void)
2650 {
2651   ToolkitTestApplication application;
2652
2653   // Set a custom shader with an image url
2654   {
2655     Property::Map     properties;
2656     Property::Map     shader;
2657     const std::string vertexShader                    = "Foobar";
2658     const std::string fragmentShader                  = "Foobar";
2659     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2660     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2661
2662     properties[Visual::Property::TYPE]     = Visual::IMAGE;
2663     properties[Visual::Property::SHADER]   = shader;
2664     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2665
2666     ImageView imageView = ImageView::New();
2667     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2668
2669     application.GetScene().Add(imageView);
2670
2671     application.SendNotification();
2672     application.Render();
2673
2674     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2675
2676     Renderer        renderer = imageView.GetRendererAt(0);
2677     Shader          shader2  = renderer.GetShader();
2678     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2679     Property::Map*  map      = value.GetMap();
2680     DALI_TEST_CHECK(map);
2681
2682     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2683     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2684
2685     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2686     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2687   }
2688
2689   // Set a custom shader after setting an image url
2690   {
2691     Property::Map     properties;
2692     Property::Map     shader;
2693     const std::string vertexShader                    = "Foobar";
2694     const std::string fragmentShader                  = "Foobar";
2695     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2696     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2697
2698     properties[Visual::Property::SHADER] = shader;
2699
2700     ImageView imageView = ImageView::New(TEST_IMAGE_FILE_NAME);
2701     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2702
2703     application.GetScene().Add(imageView);
2704
2705     application.SendNotification();
2706     application.Render();
2707
2708     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2709
2710     Renderer        renderer = imageView.GetRendererAt(0);
2711     Shader          shader2  = renderer.GetShader();
2712     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2713     Property::Map*  map      = value.GetMap();
2714     DALI_TEST_CHECK(map);
2715
2716     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2717     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2718
2719     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2720     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2721   }
2722
2723   // Set a custom shader before setting an image url
2724   {
2725     Property::Map     properties;
2726     Property::Map     shader;
2727     const std::string vertexShader                    = "Foobar";
2728     const std::string fragmentShader                  = "Foobar";
2729     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2730     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2731
2732     properties[Visual::Property::SHADER] = shader;
2733
2734     ImageView imageView = ImageView::New();
2735     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2736     imageView.SetProperty(ImageView::Property::IMAGE, TEST_IMAGE_FILE_NAME);
2737
2738     application.GetScene().Add(imageView);
2739
2740     application.SendNotification();
2741     application.Render();
2742     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2743
2744     Renderer        renderer = imageView.GetRendererAt(0);
2745     Shader          shader2  = renderer.GetShader();
2746     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2747     Property::Map*  map      = value.GetMap();
2748     DALI_TEST_CHECK(map);
2749
2750     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2751     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2752
2753     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2754     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2755   }
2756
2757   // Set a custom shader after setting a property map
2758   {
2759     Property::Map     properties;
2760     Property::Map     shader;
2761     const std::string vertexShader                    = "Foobar";
2762     const std::string fragmentShader                  = "Foobar";
2763     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2764     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2765
2766     properties[Visual::Property::SHADER] = shader;
2767
2768     Property::Map properties1;
2769     properties1[Visual::Property::TYPE]     = Visual::IMAGE;
2770     properties1[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2771
2772     ImageView imageView = ImageView::New();
2773     imageView.SetProperty(ImageView::Property::IMAGE, properties1);
2774     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2775
2776     application.GetScene().Add(imageView);
2777
2778     application.SendNotification();
2779     application.Render();
2780     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2781
2782     Renderer        renderer = imageView.GetRendererAt(0);
2783     Shader          shader2  = renderer.GetShader();
2784     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2785     Property::Map*  map      = value.GetMap();
2786     DALI_TEST_CHECK(map);
2787
2788     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2789     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2790
2791     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2792     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2793   }
2794
2795   // Set a custom shader before setting a property map
2796   {
2797     Property::Map     properties;
2798     Property::Map     shader;
2799     const std::string vertexShader                    = "Foobar";
2800     const std::string fragmentShader                  = "Foobar";
2801     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2802     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2803
2804     properties[Visual::Property::SHADER] = shader;
2805
2806     Property::Map properties1;
2807     properties1[Visual::Property::TYPE]     = Visual::IMAGE;
2808     properties1[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2809
2810     ImageView imageView = ImageView::New();
2811     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2812     imageView.SetProperty(ImageView::Property::IMAGE, properties1);
2813
2814     application.GetScene().Add(imageView);
2815
2816     application.SendNotification();
2817     application.Render();
2818     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2819
2820     Renderer        renderer = imageView.GetRendererAt(0);
2821     Shader          shader2  = renderer.GetShader();
2822     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2823     Property::Map*  map      = value.GetMap();
2824     DALI_TEST_CHECK(map);
2825
2826     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2827     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2828
2829     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2830     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2831   }
2832
2833   END_TEST;
2834 }
2835
2836 namespace
2837 {
2838 static int gFailCounter = 0;
2839 const int  MAX_RETRIES(3);
2840
2841 void ReloadImage(ImageView imageView)
2842 {
2843   Property::Map imageImmediateLoadingMap;
2844   imageImmediateLoadingMap[ImageVisual::Property::URL]         = "Non-existant-image.jpg";
2845   imageImmediateLoadingMap[ImageVisual::Property::LOAD_POLICY] = ImageVisual::LoadPolicy::IMMEDIATE;
2846
2847   tet_infoline("Immediate load an image");
2848   imageView.SetProperty(ImageView::Property::IMAGE, imageImmediateLoadingMap);
2849 }
2850
2851 void ResourceFailedReload(Control control)
2852 {
2853   gFailCounter++;
2854 }
2855 } // namespace
2856
2857 int UtcDaliImageViewReloadFailedOnResourceReadySignal(void)
2858 {
2859   tet_infoline("Test reloading failed image from within signal handler.");
2860
2861   ToolkitTestApplication application;
2862
2863   gFailCounter = 0;
2864
2865   ImageView imageView = ImageView::New();
2866   imageView.ResourceReadySignal().Connect(&ResourceFailedReload);
2867   DALI_TEST_EQUALS(gFailCounter, 0, TEST_LOCATION);
2868   ReloadImage(imageView);
2869
2870   // loading started, this waits for the loader thread to complete
2871   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2872   DALI_TEST_EQUALS(gFailCounter, 1, TEST_LOCATION);
2873
2874   ReloadImage(imageView);
2875   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2876   DALI_TEST_EQUALS(gFailCounter, 2, TEST_LOCATION);
2877
2878   ReloadImage(imageView);
2879   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2880   DALI_TEST_EQUALS(gFailCounter, 3, TEST_LOCATION);
2881
2882   END_TEST;
2883 }
2884
2885 int UtcDaliImageViewLoadRemoteSVG(void)
2886 {
2887   tet_infoline("Test load from a remote server.");
2888
2889   ToolkitTestApplication application;
2890
2891   {
2892     Toolkit::ImageView imageView;
2893     imageView = Toolkit::ImageView::New();
2894     imageView.SetImage("https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg");
2895     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2896     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2897     imageView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
2898     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2899
2900     application.GetScene().Add(imageView);
2901
2902     DALI_TEST_CHECK(imageView);
2903
2904     DALI_TEST_EQUALS(imageView.GetRendererCount(), 0u, TEST_LOCATION);
2905
2906     application.SendNotification();
2907
2908     // Wait for loading & rasterization
2909     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2910
2911     application.SendNotification();
2912     application.Render();
2913
2914     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
2915   }
2916
2917   // Without size set
2918   {
2919     Toolkit::ImageView imageView;
2920     imageView = Toolkit::ImageView::New();
2921     imageView.SetImage("https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg");
2922     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2923     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2924     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2925
2926     application.GetScene().Add(imageView);
2927
2928     DALI_TEST_CHECK(imageView);
2929
2930     DALI_TEST_EQUALS(imageView.GetRendererCount(), 0u, TEST_LOCATION);
2931
2932     application.SendNotification();
2933
2934     // Wait for loading & rasterization
2935     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2936
2937     application.SendNotification();
2938     application.Render();
2939
2940     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
2941   }
2942
2943   END_TEST;
2944 }
2945
2946 int UtcDaliImageViewLoadRemoteLottie(void)
2947 {
2948   tet_infoline("Test load from a remote server. (Note we don't support real download now. Just for line coverage)");
2949
2950   ToolkitTestApplication application;
2951
2952   {
2953     Toolkit::ImageView imageView;
2954     imageView = Toolkit::ImageView::New();
2955     imageView.SetImage("https://lottie.json");
2956     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2957     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2958     imageView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
2959     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2960
2961     application.GetScene().Add(imageView);
2962
2963     DALI_TEST_CHECK(imageView);
2964
2965     application.SendNotification();
2966     application.Render();
2967
2968     // Do not check anything for here.
2969   }
2970
2971   END_TEST;
2972 }
2973
2974 int UtcDaliImageViewSyncSVGLoading(void)
2975 {
2976   ToolkitTestApplication application;
2977
2978   tet_infoline("ImageView Testing SVG image sync loading");
2979
2980   {
2981     ImageView imageView = ImageView::New();
2982
2983     // Sync loading is used
2984     Property::Map syncLoadingMap;
2985     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2986     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
2987     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, true);
2988     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
2989
2990     application.GetScene().Add(imageView);
2991     DALI_TEST_CHECK(imageView);
2992
2993     application.SendNotification();
2994     Vector3 naturalSize = imageView.GetNaturalSize();
2995
2996     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
2997     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
2998   }
2999   END_TEST;
3000 }
3001
3002 int UtcDaliImageViewSyncSVGLoading02(void)
3003 {
3004   ToolkitTestApplication application;
3005
3006   tet_infoline("ImageView Testing SVG image sync loading");
3007
3008   {
3009     ImageView imageView = ImageView::New();
3010
3011     // Sync loading is used
3012     Property::Map syncLoadingMap;
3013     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3014     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3015     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, true);
3016     syncLoadingMap.Insert(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO);
3017     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
3018     imageView.ResourceReadySignal().Connect(&OnResourceReadySignalSVG);
3019
3020     application.GetScene().Add(imageView);
3021     DALI_TEST_CHECK(imageView);
3022
3023     application.SendNotification();
3024     application.Render();
3025
3026     // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
3027     Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
3028     Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
3029     Property::Map               resultMap;
3030     imageVisual.CreatePropertyMap(resultMap);
3031
3032     Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
3033     DALI_TEST_CHECK(transformValue);
3034     Property::Map* retMap = transformValue->GetMap();
3035     DALI_TEST_CHECK(retMap);
3036
3037     // Image Visual should be positioned depending on ImageView's padding
3038     DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::SIZE)->Get<Vector2>(), Vector2(100, 100), TEST_LOCATION);
3039
3040     Vector3 naturalSize = imageView.GetNaturalSize();
3041     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3042     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3043   }
3044   END_TEST;
3045 }
3046
3047 int UtcDaliImageViewAsyncSVGLoading(void)
3048 {
3049   ToolkitTestApplication application;
3050
3051   tet_infoline("ImageView Testing SVG image async loading");
3052
3053   {
3054     ImageView imageView = ImageView::New();
3055
3056     // Async loading is used - default value of SYNCHRONOUS_LOADING is false.
3057     Property::Map propertyMap;
3058     propertyMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3059     propertyMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3060     imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
3061
3062     application.GetScene().Add(imageView);
3063     DALI_TEST_CHECK(imageView);
3064
3065     application.SendNotification();
3066
3067     // Wait for loading
3068     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3069
3070     application.SendNotification();
3071     application.Render(16);
3072
3073     Vector3 naturalSize = imageView.GetNaturalSize();
3074     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3075     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3076   }
3077   END_TEST;
3078 }
3079
3080 int UtcDaliImageViewSVGLoadingSyncSetInvalidValue(void)
3081 {
3082   ToolkitTestApplication application;
3083
3084   tet_infoline("ImageView Testing SVG image async loading");
3085
3086   // Sync loading
3087   {
3088     ImageView imageView = ImageView::New();
3089
3090     // Sync loading is used
3091     Property::Map syncLoadingMap;
3092     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3093     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3094
3095     // Check to set invalid value
3096     // The SYNCHRONOUS_LOADING property must be set to the bool value.
3097     // Check if error log is outputted when setting other value like string.
3098     // Even if the wrong value is set, the image will be shown normally, and the synchronous value should be the default value(false).
3099     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, std::to_string(5));
3100     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
3101
3102     application.GetScene().Add(imageView);
3103     DALI_TEST_CHECK(imageView);
3104
3105     application.SendNotification();
3106
3107     // Wait for loading
3108     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3109
3110     application.SendNotification();
3111     application.Render(16);
3112
3113     Vector3 naturalSize = imageView.GetNaturalSize();
3114     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3115     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3116
3117     Property::Value value = imageView.GetProperty(ImageView::Property::IMAGE);
3118     Property::Map*  map   = value.GetMap();
3119     DALI_TEST_CHECK(map);
3120
3121     Property::Value* sync = map->Find(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING);
3122     DALI_TEST_CHECK(sync);
3123     DALI_TEST_EQUALS(false, sync->Get<bool>(), TEST_LOCATION);
3124   }
3125   END_TEST;
3126 }
3127
3128 int UtcDaliImageViewSvgLoadingFailureLocalFile(void)
3129 {
3130   // Local svg file - invalid file path
3131   {
3132     ToolkitTestApplication application;
3133
3134     TestGlAbstraction& gl           = application.GetGlAbstraction();
3135     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3136     textureTrace.Enable(true);
3137
3138     gResourceReadySignalFired = false;
3139
3140     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/foo.svg");
3141     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3142     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3143
3144     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3145
3146     application.GetScene().Add(imageView);
3147
3148     application.SendNotification();
3149
3150     // loading started, this waits for the loader thread - load
3151     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3152
3153     application.SendNotification();
3154     application.Render(16);
3155
3156     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3157     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3158     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3159
3160     // Should be shown a broken image
3161     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3162     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3163   }
3164
3165   // Local svg file - invalid file path without size set
3166   {
3167     ToolkitTestApplication application;
3168
3169     TestGlAbstraction& gl           = application.GetGlAbstraction();
3170     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3171     textureTrace.Enable(true);
3172
3173     gResourceReadySignalFired = false;
3174     textureTrace.Reset();
3175
3176     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/foo.svg");
3177     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3178
3179     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3180
3181     application.GetScene().Add(imageView);
3182
3183     application.SendNotification();
3184
3185     // loading started, this waits for the loader thread - load & rasterize
3186     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3187
3188     application.SendNotification();
3189     application.Render(16);
3190
3191     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3192     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3193     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3194
3195     // Should be shown a broken image
3196     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3197     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3198   }
3199
3200   // Local svg file - invalid file
3201   {
3202     ToolkitTestApplication application;
3203
3204     TestGlAbstraction& gl           = application.GetGlAbstraction();
3205     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3206     textureTrace.Enable(true);
3207
3208     gResourceReadySignalFired = false;
3209     textureTrace.Reset();
3210
3211     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/invalid.svg");
3212     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3213     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3214
3215     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3216
3217     application.GetScene().Add(imageView);
3218
3219     application.SendNotification();
3220
3221     // loading started, this waits for the loader thread - load & rasterize
3222     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3223
3224     application.SendNotification();
3225     application.Render(16);
3226
3227     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3228     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3229     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3230
3231     // Should be shown a broken image
3232     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3233     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3234   }
3235
3236   END_TEST;
3237 }
3238
3239 int UtcDaliImageViewSvgLoadingFailureRemoteFile01(void)
3240 {
3241   // Remote svg file
3242   {
3243     ToolkitTestApplication application;
3244
3245     TestGlAbstraction& gl           = application.GetGlAbstraction();
3246     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3247     textureTrace.Enable(true);
3248
3249     gResourceReadySignalFired = false;
3250
3251     ImageView imageView = ImageView::New("https://127.0.0.1/foobar.svg");
3252     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3253     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3254
3255     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3256
3257     application.GetScene().Add(imageView);
3258
3259     application.SendNotification();
3260
3261     // loading started, this waits for the loader thread - load & rasterize
3262     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3263
3264     application.SendNotification();
3265     application.Render(16);
3266
3267     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3268     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3269     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3270
3271     // Should be shown a broken image
3272     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3273     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3274   }
3275
3276   END_TEST;
3277 }
3278
3279 int UtcDaliImageViewSvgLoadingFailureRemoteFile02(void)
3280 {
3281   // Remote svg file without size set
3282   {
3283     ToolkitTestApplication application;
3284
3285     TestGlAbstraction& gl           = application.GetGlAbstraction();
3286     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3287     textureTrace.Enable(true);
3288
3289     gResourceReadySignalFired = false;
3290
3291     ImageView imageView = ImageView::New("https://127.0.0.1/foobar.svg");
3292     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3293
3294     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3295
3296     application.GetScene().Add(imageView);
3297
3298     application.SendNotification();
3299
3300     // loading started, this waits for the loader thread - load & rasterize
3301     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3302
3303     application.SendNotification();
3304     application.Render(16);
3305
3306     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3307     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3308     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3309
3310     // Should be shown a broken image
3311     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3312     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3313   }
3314
3315   END_TEST;
3316 }
3317
3318 int UtcDaliImageViewSvgRasterizationFailure(void)
3319 {
3320   ToolkitTestApplication application;
3321
3322   gResourceReadySignalFired = false;
3323
3324   TestGlAbstraction& gl           = application.GetGlAbstraction();
3325   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3326   textureTrace.Enable(true);
3327
3328   ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/invalid1.svg");
3329   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3330   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3331
3332   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3333
3334   application.GetScene().Add(imageView);
3335
3336   application.SendNotification();
3337
3338   // Wait for loading & rasterization
3339   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3340
3341   application.SendNotification();
3342   application.Render(16);
3343
3344   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3345   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3346   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3347
3348   // Should be shown a broken image
3349   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3350   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3351
3352   END_TEST;
3353 }
3354
3355 int UtcDaliImageViewSvgChageSize(void)
3356 {
3357   ToolkitTestApplication application;
3358
3359   TestGlAbstraction& gl           = application.GetGlAbstraction();
3360   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3361   textureTrace.Enable(true);
3362
3363   ImageView imageView = ImageView::New(TEST_SVG_FILE_NAME);
3364   application.GetScene().Add(imageView);
3365
3366   application.SendNotification();
3367
3368   // Wait for loading & rasterization
3369   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3370
3371   application.SendNotification();
3372   application.Render(16);
3373
3374   DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
3375
3376   // Change actor size, then rasterization should be done again
3377   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3378
3379   application.SendNotification();
3380
3381   // Wait for rasterization
3382   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3383
3384   application.SendNotification();
3385   application.Render(16);
3386
3387   // We should not load the file again.
3388   DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
3389
3390   END_TEST;
3391 }
3392
3393 int UtcDaliImageViewSvgAtlasing(void)
3394 {
3395   ToolkitTestApplication application;
3396
3397   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
3398   callStack.Reset();
3399   callStack.Enable(true);
3400
3401   Property::Map propertyMap;
3402   propertyMap["url"]      = TEST_SVG_FILE_NAME;
3403   propertyMap["atlasing"] = true;
3404
3405   ImageView imageView = ImageView::New();
3406   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
3407   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3408   application.GetScene().Add(imageView);
3409
3410   application.SendNotification();
3411
3412   // Wait for loading & rasterization
3413   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3414
3415   application.SendNotification();
3416   application.Render(16);
3417
3418   // use atlas
3419   TraceCallStack::NamedParams params1;
3420   params1["width"] << 100;
3421   params1["height"] << 100;
3422   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params1), true, TEST_LOCATION);
3423
3424   imageView.SetProperty(Actor::Property::SIZE, Vector2(600.f, 600.f));
3425
3426   application.SendNotification();
3427
3428   // Wait for rasterization
3429   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3430
3431   callStack.Reset();
3432
3433   application.SendNotification();
3434   application.Render(16);
3435
3436   // not use atlas
3437   TraceCallStack::NamedParams params2;
3438   params2["width"] << 600;
3439   params2["height"] << 600;
3440   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexImage2D", params2), true, TEST_LOCATION);
3441
3442   END_TEST;
3443 }
3444
3445 int UtcDaliImageViewTVGLoading(void)
3446 {
3447   ToolkitTestApplication application;
3448
3449   tet_infoline("ImageView Testing TVG image loading");
3450
3451   {
3452     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/test.tvg");
3453     application.GetScene().Add(imageView);
3454     DALI_TEST_CHECK(imageView);
3455
3456     application.SendNotification();
3457
3458     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3459
3460     application.SendNotification();
3461     application.Render(16);
3462
3463     Vector3 naturalSize = imageView.GetNaturalSize();
3464
3465     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3466     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3467   }
3468   END_TEST;
3469 }
3470
3471 int UtcDaliImageViewSvgDesiredSize01(void)
3472 {
3473   ToolkitTestApplication application;
3474
3475   TestGlAbstraction& gl           = application.GetGlAbstraction();
3476   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3477   textureTrace.Enable(true);
3478
3479   int       desiredWidth = 100, desiredHeight = 150;
3480   ImageView imageView = ImageView::New(TEST_SVG_FILE_NAME, ImageDimensions(desiredWidth, desiredHeight));
3481
3482   application.GetScene().Add(imageView);
3483
3484   application.SendNotification();
3485
3486   // Wait for loading & rasterization
3487   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3488
3489   application.SendNotification();
3490   application.Render(16);
3491
3492   {
3493     std::stringstream out;
3494     out << GL_TEXTURE_2D << ", " << 0u << ", " << desiredWidth << ", " << desiredHeight;
3495     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
3496   }
3497
3498   END_TEST;
3499 }
3500
3501 int UtcDaliImageViewSvgDesiredSize02(void)
3502 {
3503   ToolkitTestApplication application;
3504
3505   TestGlAbstraction& gl           = application.GetGlAbstraction();
3506   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3507   textureTrace.Enable(true);
3508
3509   int       desiredWidth = 150, desiredHeight = 100;
3510   ImageView imageView                   = ImageView::New();
3511   imageView[ImageView::Property::IMAGE] = Property::Map().Add("url", TEST_SVG_FILE_NAME).Add("desiredWidth", desiredWidth).Add("desiredHeight", desiredHeight);
3512   application.GetScene().Add(imageView);
3513
3514   application.SendNotification();
3515
3516   // Wait for loading & rasterization
3517   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3518
3519   application.SendNotification();
3520   application.Render(16);
3521
3522   {
3523     std::stringstream out;
3524     out << GL_TEXTURE_2D << ", " << 0u << ", " << desiredWidth << ", " << desiredHeight;
3525     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
3526   }
3527
3528   END_TEST;
3529 }
3530
3531 int UtcDaliImageViewImageLoadFailure01(void)
3532 {
3533   ToolkitTestApplication application;
3534
3535   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3536   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
3537   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
3538   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3539
3540   std::string brokenUrl;
3541   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3542   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_S, brokenUrl, TEST_LOCATION);
3543
3544   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3545   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_M, brokenUrl, TEST_LOCATION);
3546
3547   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3548   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3549
3550   ImageView imageView = ImageView::New("invalidUrl.png");
3551   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3552
3553   application.GetScene().Add(imageView);
3554   application.SendNotification();
3555   application.Render(16);
3556
3557   // loading started, this waits for the loader thread
3558   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3559
3560   END_TEST;
3561 }
3562
3563 int UtcDaliImageViewImageLoadFailure02(void)
3564 {
3565   ToolkitTestApplication application;
3566
3567   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3568   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_DEFAULT);
3569   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
3570   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3571
3572   std::string brokenUrl;
3573   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3574   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_DEFAULT, brokenUrl, TEST_LOCATION);
3575
3576   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3577   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_M, brokenUrl, TEST_LOCATION);
3578
3579   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3580   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3581
3582   ImageView imageView = ImageView::New("invalidUrl.png");
3583   imageView.SetProperty(Actor::Property::SIZE, Vector2(30.f, 30.f));
3584   application.GetScene().Add(imageView);
3585   application.SendNotification();
3586   application.Render(16);
3587
3588   // loading started, this waits for the loader thread
3589   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3590
3591   END_TEST;
3592 }
3593
3594 int UtcDaliImageViewImageLoadFailure03(void)
3595 {
3596   ToolkitTestApplication application;
3597
3598   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3599   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_01);
3600   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_02);
3601
3602   std::string brokenUrl;
3603   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3604   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_01, brokenUrl, TEST_LOCATION);
3605
3606   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3607   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_02, brokenUrl, TEST_LOCATION);
3608
3609   ImageView imageView = ImageView::New("invalidUrl.png");
3610   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3611   application.GetScene().Add(imageView);
3612   application.SendNotification();
3613   application.Render(16);
3614
3615   // loading started, this waits for the loader thread
3616   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3617
3618   END_TEST;
3619 }
3620
3621 int UtcDaliImageViewImageLoadFailure04(void)
3622 {
3623   ToolkitTestApplication application;
3624
3625   ImageView imageView = ImageView::New("invalidUrl.png");
3626   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3627   application.GetScene().Add(imageView);
3628   application.SendNotification();
3629   application.Render(16);
3630
3631   // loading started, this waits for the loader thread
3632   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3633
3634   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3635   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
3636   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, "invalidBroken.png");
3637   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3638
3639   ImageView imageView2 = ImageView::New("invalidUrl.png");
3640   imageView2.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3641   application.GetScene().Add(imageView2);
3642
3643   std::string brokenUrl;
3644   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3645   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_S, brokenUrl, TEST_LOCATION);
3646
3647   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3648   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3649
3650   application.SendNotification();
3651   application.Render(16);
3652
3653   // loading started, this waits for the loader thread
3654   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3655
3656   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, "invalidBroken.9.png");
3657
3658   ImageView imageView3 = ImageView::New("invalidUrl.png");
3659   imageView3.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3660   application.GetScene().Add(imageView3);
3661
3662   application.SendNotification();
3663   application.Render(16);
3664
3665   // loading started, this waits for the loader thread
3666   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3667
3668   END_TEST;
3669 }
3670
3671 namespace
3672 {
3673 static int gResourceReadySignalCounter = 0;
3674
3675 void OnResourceReadySignal01(Control control)
3676 {
3677   gResourceReadySignalCounter++;
3678
3679   if(control.GetVisualResourceStatus(ImageView::Property::IMAGE) == Visual::ResourceStatus::READY)
3680   {
3681     if(gResourceReadySignalCounter == 1)
3682     {
3683       // Set image twice
3684       // It makes the first new visual be deleted immediately
3685       ImageView::DownCast(control).SetImage(gImage_34_RGBA);
3686       ImageView::DownCast(control).SetImage(gImage_34_RGBA);
3687     }
3688   }
3689   else if(control.GetVisualResourceStatus(ImageView::Property::IMAGE) == Visual::ResourceStatus::FAILED)
3690   {
3691     // Make the resource ready immediately
3692     control[ImageView::Property::IMAGE] = gImage_600_RGB;
3693   }
3694 }
3695
3696 void OnResourceReadySignal02(Control control)
3697 {
3698   if(++gResourceReadySignalCounter == 1)
3699   {
3700     // It makes the first new visual be deleted immediately
3701     // The first image will not be loaded.
3702     control[ImageView::Property::IMAGE] = Property::Map().Add(ImageVisual::Property::URL, gImage_600_RGB).Add(ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER);
3703     control[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3704   }
3705 }
3706
3707 ImageView gImageView1;
3708 ImageView gImageView2;
3709 ImageView gImageView3;
3710 ImageView gImageView4;
3711
3712 void OnResourceReadySignal03(Control control)
3713 {
3714   if(gResourceReadySignalCounter == 0)
3715   {
3716     // Queue loading
3717     // 1. Use cached image, then LoadComplete will be called right after OnResourceReadySignal03.
3718     gImageView2[ImageView::Property::IMAGE] = gImage_34_RGBA;
3719
3720     // 2. Load a new image
3721     gImageView3[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3722
3723     // 3. Use the new image again
3724     gImageView1[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3725     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal03);
3726   }
3727   else if(gResourceReadySignalCounter == 1)
3728   {
3729     // This is called from TextureManager::ProcessQueuedTextures().
3730     gImageView1.Unparent();
3731     gImageView1.Reset();
3732   }
3733   gResourceReadySignalCounter++;
3734 }
3735
3736 void OnSimpleResourceReadySignal(Control control)
3737 {
3738   // simply increate counter
3739   gResourceReadySignalCounter++;
3740 }
3741
3742 int gResourceReadySignal04ComesOrder = 0;
3743
3744 void OnResourceReadySignal04(Control control)
3745 {
3746   gResourceReadySignalCounter++;
3747   tet_printf("rc %d\n", gResourceReadySignalCounter);
3748   if(gResourceReadySignalCounter == 1)
3749   {
3750     auto scene = gImageView1.GetParent();
3751
3752     // Request load something
3753     // We hope this request result is return later than gImageView2.
3754     gImageView3 = ImageView::New(TEST_IMAGE_1);
3755     gImageView3.ResourceReadySignal().Connect(&OnResourceReadySignal04);
3756     scene.Add(gImageView3);
3757     gImageView4 = ImageView::New(TEST_IMAGE_2);
3758     gImageView4.ResourceReadySignal().Connect(&OnResourceReadySignal04);
3759     scene.Add(gImageView4);
3760
3761     if(control == gImageView1)
3762     {
3763       gResourceReadySignal04ComesOrder = 1;
3764     }
3765     else
3766     {
3767       gResourceReadySignal04ComesOrder = 2;
3768     }
3769   }
3770   if(gResourceReadySignalCounter == 2)
3771   {
3772     if(gResourceReadySignal04ComesOrder == 1 && control == gImageView2)
3773     {
3774       // Scene off first one.
3775       gImageView1.Unparent();
3776
3777       // Scene off second one.
3778       gImageView2.Unparent();
3779     }
3780     else if(gResourceReadySignal04ComesOrder == 2 && control == gImageView1)
3781     {
3782       // Scene off first one.
3783       gImageView2.Unparent();
3784
3785       // Scene off second one.
3786       gImageView1.Unparent();
3787     }
3788     else
3789     {
3790       // We can't check that this utc fail case. just pass always when we come here.
3791       gResourceReadySignal04ComesOrder = -1;
3792     }
3793
3794     // If we don't seperate index of FreeList area
3795     // and if we don't queue remove during obversing,
3796     // cache index become something invalid data.
3797     // In this case, some strange observer can be called.
3798     // For example, gImageView4.LoadComplete will be called.
3799   }
3800 }
3801
3802 void OnResourceReadySignal05(Control control)
3803 {
3804   gResourceReadySignalCounter++;
3805
3806   // Request load with same image
3807   // NOTE : The url must not be same as gImageView1
3808   const int viewCount = 4;
3809   for(int i = 0; i < viewCount; ++i)
3810   {
3811     gImageView1.Add(ImageView::New("invalid2.jpg"));
3812   }
3813 }
3814
3815 int gResourceReadySignal06ComesOrder = 0;
3816
3817 void OnResourceReadySignal06(Control control)
3818 {
3819   gResourceReadySignalCounter++;
3820   if(gResourceReadySignalCounter == 1)
3821   {
3822     auto scene = gImageView1.GetParent();
3823
3824     // Request load something
3825     // We hope this request result is return later than gImageView2.
3826
3827     Property::Map map1;
3828     map1[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_1;
3829     map1[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
3830
3831     gImageView3 = ImageView::New();
3832     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3833     gImageView3.ResourceReadySignal().Connect(&OnResourceReadySignal06);
3834
3835     Property::Map map2;
3836     map2[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_2;
3837     map2[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_S;
3838     gImageView4                                          = ImageView::New();
3839     gImageView4.SetProperty(Toolkit::ImageView::Property::IMAGE, map2);
3840     gImageView4.ResourceReadySignal().Connect(&OnResourceReadySignal06);
3841
3842     if(control == gImageView1)
3843     {
3844       gResourceReadySignal06ComesOrder = 1;
3845     }
3846     else
3847     {
3848       gResourceReadySignal06ComesOrder = 2;
3849     }
3850   }
3851   if(gResourceReadySignalCounter == 2)
3852   {
3853     if(gResourceReadySignal06ComesOrder == 1 && control == gImageView2)
3854     {
3855       // Scene off first one.
3856       gImageView1.Unparent();
3857
3858       // Scene off second one.
3859       gImageView2.Unparent();
3860     }
3861     else if(gResourceReadySignal06ComesOrder == 2 && control == gImageView1)
3862     {
3863       // Scene off first one.
3864       gImageView2.Unparent();
3865
3866       // Scene off second one.
3867       gImageView1.Unparent();
3868     }
3869     else
3870     {
3871       // We can't check that this utc fail case. just pass always when we come here.
3872       gResourceReadySignal06ComesOrder = -1;
3873     }
3874
3875     // If we don't seperate index of FreeList area
3876     // and if we don't queue remove during obversing,
3877     // cache index become something invalid data.
3878     // In this case, some strange observer can be called.
3879     // For example, gImageView4.LoadComplete will be called.
3880   }
3881 }
3882
3883 void OnResourceReadySignal07(Control control)
3884 {
3885   gResourceReadySignalCounter++;
3886   // Load masked image
3887   tet_printf("rc %d %d\n", gResourceReadySignalCounter, static_cast<bool>(gImageView2));
3888
3889   if(!gImageView2)
3890   {
3891     auto scene = gImageView1.GetParent();
3892
3893     Property::Map map1;
3894     map1[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_1;
3895     map1[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
3896
3897     gImageView2 = ImageView::New();
3898     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3899     gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal07);
3900
3901     scene.Add(gImageView2);
3902   }
3903 }
3904
3905 void OnResourceReadySignal08(Control control)
3906 {
3907   gResourceReadySignalCounter++;
3908
3909   if(gImageView1)
3910   {
3911     gImageView1.Unparent();
3912     gImageView1.Reset();
3913   }
3914   if(gImageView2)
3915   {
3916     gImageView2.Unparent();
3917     gImageView2.Reset();
3918   }
3919 }
3920
3921 std::size_t gResourceReadySignal09Emitted = false;
3922
3923 void OnResourceReadySignal09(Control control)
3924 {
3925   gResourceReadySignalCounter++;
3926
3927   if(gImageView1 && !gResourceReadySignal09Emitted)
3928   {
3929     gResourceReadySignal09Emitted = true;
3930     gImageView1.ResourceReadySignal().Disconnect(&OnResourceReadySignal09);
3931
3932     // Try to load cached invalid nine patch image. It will request load now.
3933     gImageView1.SetImage(TEST_INVALID_NPATCH_FILE_NAME_01);
3934     gImageView2.SetImage(TEST_INVALID_NPATCH_FILE_NAME_01);
3935
3936     // Destroy all visuals immediatly.
3937     gImageView1.Unparent();
3938     gImageView1.Reset();
3939     gImageView2.Unparent();
3940     gImageView2.Reset();
3941   }
3942 }
3943 constexpr int gResourceReadySignal10MaxCounter = 5;
3944
3945 void OnResourceReadySignal10(Control control)
3946 {
3947   gResourceReadySignalCounter++;
3948
3949   tet_printf("OnResourceReadySignal10 comes!\n");
3950   if(gResourceReadySignalCounter < gResourceReadySignal10MaxCounter)
3951   {
3952     tet_printf("OnResourceReadySignal10 Set image\n");
3953     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
3954     tet_printf("OnResourceReadySignal10 Set image done\n");
3955   }
3956 }
3957
3958 void OnResourceReadySignal11(Control control)
3959 {
3960   gResourceReadySignalCounter++;
3961
3962   if(!gImageView2)
3963   {
3964     auto scene = gImageView1.GetParent();
3965
3966     // Try to load animated image visual here which is already cached, and then ignore forcely.
3967
3968     Property::Map map1;
3969     map1[Toolkit::ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3970
3971     gImageView2 = ImageView::New();
3972     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3973
3974     gImageView3 = ImageView::New();
3975     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3976
3977     scene.Add(gImageView2);
3978     gImageView2.Unparent();
3979
3980     scene.Add(gImageView3);
3981     gImageView3.Unparent();
3982     gImageView3.Reset(); // Destroy visual
3983   }
3984 }
3985
3986 } // namespace
3987
3988 int UtcDaliImageViewSetImageOnResourceReadySignal01(void)
3989 {
3990   tet_infoline("Test setting image from within signal handler.");
3991
3992   ToolkitTestApplication application;
3993
3994   gResourceReadySignalCounter = 0;
3995
3996   ImageView imageView = ImageView::New(gImage_34_RGBA);
3997   imageView.ResourceReadySignal().Connect(&OnResourceReadySignal01);
3998
3999   application.GetScene().Add(imageView);
4000
4001   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4002
4003   application.SendNotification();
4004   application.Render();
4005
4006   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4007
4008   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4009
4010   // Create a new ImageView to cache the image
4011   ImageView imageView1 = ImageView::New(gImage_600_RGB);
4012   application.GetScene().Add(imageView1);
4013
4014   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4015
4016   application.SendNotification();
4017   application.Render();
4018
4019   // Reset count
4020   gResourceReadySignalCounter = 0;
4021
4022   imageView[ImageView::Property::IMAGE] = "invalid.jpg";
4023
4024   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4025
4026   application.SendNotification();
4027   application.Render();
4028
4029   // Run idle callback
4030   application.RunIdles();
4031
4032   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4033
4034   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4035
4036   END_TEST;
4037 }
4038
4039 int UtcDaliImageViewSetImageOnResourceReadySignal02(void)
4040 {
4041   tet_infoline("Test setting image from within signal handler.");
4042
4043   ToolkitTestApplication application;
4044
4045   gResourceReadySignalCounter = 0;
4046
4047   ImageView imageView = ImageView::New(gImage_34_RGBA);
4048   imageView.ResourceReadySignal().Connect(&OnResourceReadySignal02);
4049
4050   application.GetScene().Add(imageView);
4051
4052   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4053
4054   application.SendNotification();
4055   application.Render();
4056
4057   // Wait for loading an image
4058   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4059
4060   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4061
4062   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4063
4064   END_TEST;
4065 }
4066
4067 int UtcDaliImageViewSetImageOnResourceReadySignal03(void)
4068 {
4069   tet_infoline("Test setting image from within signal handler.");
4070
4071   ToolkitTestApplication application;
4072
4073   gResourceReadySignalCounter = 0;
4074
4075   gImageView1 = ImageView::New(gImage_34_RGBA);
4076   application.GetScene().Add(gImageView1);
4077
4078   // Wait for loading
4079   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4080
4081   gImageView2 = ImageView::New(gImage_600_RGB);
4082   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal03);
4083   application.GetScene().Add(gImageView2);
4084
4085   gImageView3 = ImageView::New();
4086   application.GetScene().Add(gImageView3);
4087
4088   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4089
4090   application.SendNotification();
4091   application.Render();
4092
4093   END_TEST;
4094 }
4095
4096 int UtcDaliImageViewOnResourceReadySignalWithBrokenAlphaMask01(void)
4097 {
4098   tet_infoline("Test signal handler when image / mask image is broken.");
4099
4100   ToolkitTestApplication application;
4101
4102   auto TestResourceReadyUrl = [&application](int eventTriggerCount, bool isSynchronous, const std::string& url, const std::string& mask, const char* location) {
4103     gResourceReadySignalCounter = 0;
4104
4105     Property::Map map;
4106     map[Toolkit::ImageVisual::Property::URL] = url;
4107     if(!mask.empty())
4108     {
4109       map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = mask;
4110     }
4111     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = isSynchronous;
4112
4113     ImageView imageView                            = ImageView::New();
4114     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4115     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4116     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4117
4118     application.GetScene().Add(imageView);
4119     application.SendNotification();
4120     application.Render();
4121
4122     if(!isSynchronous)
4123     {
4124       // Wait for loading
4125       DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(eventTriggerCount), true, location);
4126     }
4127     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4128     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4129
4130     imageView.Unparent();
4131   };
4132
4133   for(int synchronous = 0; synchronous <= 1; synchronous++)
4134   {
4135     tet_printf("Test normal case (sync:%d)\n", synchronous);
4136     TestResourceReadyUrl(1, synchronous, gImage_600_RGB, "", TEST_LOCATION);
4137     TestResourceReadyUrl(3, synchronous, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION); // 3 event trigger required : 2 image load + 1 apply mask
4138
4139     tet_printf("Test broken image case (sync:%d)\n", synchronous);
4140     TestResourceReadyUrl(1, synchronous, "invalid.jpg", "", TEST_LOCATION);
4141     TestResourceReadyUrl(2, synchronous, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION);
4142
4143     tet_printf("Test broken mask image case (sync:%d)\n", synchronous);
4144     TestResourceReadyUrl(2, synchronous, gImage_600_RGB, "invalid.png", TEST_LOCATION);
4145
4146     tet_printf("Test broken both image, mask image case (sync:%d)\n", synchronous);
4147     TestResourceReadyUrl(2, synchronous, "invalid.jpg", "invalid.png", TEST_LOCATION);
4148   }
4149
4150   END_TEST;
4151 }
4152
4153 int UtcDaliImageViewOnResourceReadySignalWithBrokenAlphaMask02(void)
4154 {
4155   tet_infoline("Test signal handler when image try to use cached-and-broken mask image.");
4156
4157   ToolkitTestApplication application;
4158
4159   gResourceReadySignalCounter = 0;
4160
4161   auto TestBrokenMaskResourceReadyUrl = [&application](const std::string& url, const char* location) {
4162     Property::Map map;
4163     map[Toolkit::ImageVisual::Property::URL] = url;
4164     // Use invalid mask url
4165     map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = "invalid.png";
4166
4167     ImageView imageView                            = ImageView::New();
4168     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4169     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4170     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4171
4172     application.GetScene().Add(imageView);
4173
4174     // Don't unparent imageView, for keep the cache.
4175   };
4176
4177   // Use more than 4 images (The number of LocalImageLoadThread)
4178   const std::vector<std::string> testUrlList = {gImage_34_RGBA, gImage_600_RGB, "invalid.jpg" /* invalid url */, TEST_IMAGE_1, TEST_IMAGE_2, TEST_BROKEN_IMAGE_DEFAULT};
4179
4180   int expectResourceReadySignalCounter = 0;
4181
4182   for(auto& url : testUrlList)
4183   {
4184     TestBrokenMaskResourceReadyUrl(url, TEST_LOCATION);
4185     expectResourceReadySignalCounter++;
4186   }
4187
4188   // Remain 1 signal due to we use #URL + 1 mask image.
4189   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(expectResourceReadySignalCounter + 1), true, TEST_LOCATION);
4190   application.SendNotification();
4191   application.Render();
4192   DALI_TEST_EQUALS(gResourceReadySignalCounter, expectResourceReadySignalCounter, TEST_LOCATION);
4193
4194   END_TEST;
4195 }
4196
4197 int UtcDaliImageViewCheckVariousCaseSendOnResourceReadySignal(void)
4198 {
4199   tet_infoline("Test signal handler various case.");
4200
4201   auto TestResourceReadyUrl = [](int eventTriggerCount, bool isSynchronous, bool loadSuccess, const std::string& url, const std::string& mask, const char* location) {
4202     ToolkitTestApplication application;
4203
4204     gResourceReadySignalCounter = 0;
4205
4206     Property::Map map;
4207     map[Toolkit::ImageVisual::Property::URL] = url;
4208     if(!mask.empty())
4209     {
4210       map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = mask;
4211     }
4212     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = isSynchronous;
4213
4214     ImageView imageView                            = ImageView::New();
4215     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4216     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4217     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4218
4219     application.GetScene().Add(imageView);
4220     application.SendNotification();
4221     application.Render();
4222
4223     // Wait for loading
4224     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(eventTriggerCount), true, location);
4225
4226     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4227     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4228     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(Toolkit::ImageView::Property::IMAGE), loadSuccess ? Toolkit::Visual::ResourceStatus::READY : Toolkit::Visual::ResourceStatus::FAILED, location);
4229
4230     imageView.Unparent();
4231   };
4232
4233   auto TestAuxiliaryResourceReadyUrl = [](bool isSynchronous, bool loadSuccess, const std::string& url, const std::string& auxiliaryUrl, const char* location) {
4234     ToolkitTestApplication application;
4235
4236     gResourceReadySignalCounter = 0;
4237
4238     Property::Map map;
4239     map[Toolkit::ImageVisual::Property::URL]                        = url;
4240     map[Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE]       = auxiliaryUrl;
4241     map[Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA] = 0.5f;
4242     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING]        = isSynchronous;
4243
4244     ImageView imageView = ImageView::New();
4245     imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4246     imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
4247     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4248     application.GetScene().Add(imageView);
4249
4250     application.SendNotification();
4251     application.Render();
4252
4253     if(!isSynchronous)
4254     {
4255       // Wait for loading
4256       DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, location);
4257     }
4258
4259     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4260     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4261     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(Toolkit::ImageView::Property::IMAGE), loadSuccess ? Toolkit::Visual::ResourceStatus::READY : Toolkit::Visual::ResourceStatus::FAILED, TEST_LOCATION);
4262
4263     imageView.Unparent();
4264   };
4265
4266   // Case 1 : asynchronous loading
4267   tet_printf("Test invalid single simple image Asynchronous\n");
4268
4269   // Test normal case
4270   TestResourceReadyUrl(1, 0, 1, gImage_600_RGB, "", TEST_LOCATION);
4271   TestResourceReadyUrl(2, 0, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // load & rasterize
4272   TestResourceReadyUrl(1, 0, 1, TEST_BROKEN_IMAGE_L, "", TEST_LOCATION);
4273
4274   TestResourceReadyUrl(2, 0, 1, TEST_GIF_FILE_NAME, "", TEST_LOCATION);                   // 2 image loading - batch size
4275   TestResourceReadyUrl(2, 0, 1, TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME, "", TEST_LOCATION); // load & rasterize
4276
4277   TestResourceReadyUrl(3, 0, 1, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION); // 2 image loading + 1 applymask
4278
4279   TestAuxiliaryResourceReadyUrl(0, 1, TEST_BROKEN_IMAGE_L, gImage_34_RGBA, TEST_LOCATION);
4280
4281   // Test broken case
4282   TestResourceReadyUrl(1, 0, 0, "invalid.jpg", "", TEST_LOCATION);
4283   TestResourceReadyUrl(1, 0, 0, "invalid.svg", "", TEST_LOCATION);
4284   TestResourceReadyUrl(1, 0, 0, "invalid.9.png", "", TEST_LOCATION);
4285   TestResourceReadyUrl(1, 0, 0, "invalid.gif", "", TEST_LOCATION);  // 1 image loading
4286   TestResourceReadyUrl(1, 0, 0, "invalid.json", "", TEST_LOCATION); // 0 rasterize
4287
4288   TestResourceReadyUrl(2, 0, 0, "invalid.jpg", "invalid.png", TEST_LOCATION);  // 2 image loading
4289   TestResourceReadyUrl(2, 0, 1, gImage_600_RGB, "invalid.png", TEST_LOCATION); // 2 image loading
4290   TestResourceReadyUrl(2, 0, 0, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION); // 2 image loading
4291
4292   TestAuxiliaryResourceReadyUrl(0, 0, "invalid.9.png", "invalid.png", TEST_LOCATION);
4293   TestAuxiliaryResourceReadyUrl(0, 1, TEST_BROKEN_IMAGE_L, "invalid.png", TEST_LOCATION);
4294   TestAuxiliaryResourceReadyUrl(0, 0, "invalid.9.png", gImage_34_RGBA, TEST_LOCATION);
4295
4296   // Case 2 : Synchronous loading
4297   tet_printf("Test invalid single simple image Synchronous\n");
4298
4299   // Test normal case
4300   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, "", TEST_LOCATION);
4301   TestResourceReadyUrl(0, 1, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // synchronous rasterize
4302   TestResourceReadyUrl(0, 1, 1, TEST_BROKEN_IMAGE_L, "", TEST_LOCATION);
4303
4304   TestResourceReadyUrl(1, 1, 1, TEST_GIF_FILE_NAME, "", TEST_LOCATION); // first frame image loading sync + second frame image loading async
4305
4306   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION);
4307
4308   TestAuxiliaryResourceReadyUrl(1, 1, TEST_BROKEN_IMAGE_L, gImage_34_RGBA, TEST_LOCATION);
4309
4310   // Test broken case
4311   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", "", TEST_LOCATION);
4312   TestResourceReadyUrl(0, 1, 0, "invalid.svg", "", TEST_LOCATION);
4313   TestResourceReadyUrl(0, 1, 0, "invalid.9.png", "", TEST_LOCATION);
4314   TestResourceReadyUrl(0, 1, 0, "invalid.gif", "", TEST_LOCATION);
4315
4316   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", "invalid.png", TEST_LOCATION);
4317   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, "invalid.png", TEST_LOCATION);
4318   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION);
4319
4320   TestAuxiliaryResourceReadyUrl(1, 0, "invalid.9.png", "invalid.png", TEST_LOCATION);
4321   TestAuxiliaryResourceReadyUrl(1, 1, TEST_BROKEN_IMAGE_L, "invalid.png", TEST_LOCATION);
4322   TestAuxiliaryResourceReadyUrl(1, 0, "invalid.9.png", gImage_34_RGBA, TEST_LOCATION);
4323
4324   END_TEST;
4325 }
4326
4327 int UtcDaliImageViewSetImageOnResourceReadySignal04(void)
4328 {
4329   tet_infoline("Test texturemanager's remove queue works well within signal handler.");
4330
4331   ToolkitTestApplication application;
4332
4333   gResourceReadySignalCounter      = 0;
4334   gResourceReadySignal04ComesOrder = 0;
4335
4336   gImageView1 = ImageView::New("invalid.jpg"); // request invalid image, to make loading failed fast.
4337   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal04);
4338   application.GetScene().Add(gImageView1);
4339
4340   gImageView2 = ImageView::New("invalid.png"); // request invalid image, to make loading failed fast.
4341   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal04);
4342   application.GetScene().Add(gImageView2);
4343
4344   application.SendNotification();
4345   application.Render();
4346
4347   tet_infoline("Try to load 2 invalid image");
4348
4349   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4350   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4351
4352   tet_infoline("load done");
4353
4354   // We can test this UTC only if gImageView1 and gImageView2 loaded done.
4355   if(gResourceReadySignal04ComesOrder == -1)
4356   {
4357     tet_infoline("Bad news.. gImageView3 or gImageView4 loaded faster than others. just skip this UTC");
4358   }
4359   else
4360   {
4361     // gImageView3 and gImageView4 load must not be successed yet.
4362     DALI_TEST_EQUALS(gImageView3.GetRendererCount(), 0u, TEST_LOCATION);
4363     DALI_TEST_EQUALS(gImageView4.GetRendererCount(), 0u, TEST_LOCATION);
4364
4365     application.SendNotification();
4366     application.Render();
4367
4368     tet_infoline("Try to load 2 valid image");
4369
4370     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4371     DALI_TEST_EQUALS(gResourceReadySignalCounter, 4, TEST_LOCATION);
4372
4373     tet_infoline("load done");
4374
4375     // gImageView3 and gImageView4 load must be successed now.
4376     DALI_TEST_EQUALS(gImageView3.GetRendererAt(0).GetTextures().GetTextureCount(), 1u, TEST_LOCATION);
4377     DALI_TEST_EQUALS(gImageView4.GetRendererAt(0).GetTextures().GetTextureCount(), 1u, TEST_LOCATION);
4378   }
4379
4380   END_TEST;
4381 }
4382 int UtcDaliImageViewSetImageOnResourceReadySignal05(void)
4383 {
4384   tet_infoline("Test multiple views with same image during ResourceReady load the image only 1 times");
4385
4386   ToolkitTestApplication application;
4387
4388   gResourceReadySignalCounter = 0;
4389
4390   gImageView1 = ImageView::New("invalid.jpg"); // request invalid image, to make loading failed fast.
4391   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal05);
4392   application.GetScene().Add(gImageView1);
4393
4394   application.SendNotification();
4395   application.Render();
4396
4397   tet_infoline("Try to load 1 invalid.jpg image");
4398   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4399   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4400
4401   tet_infoline("Try to load 1 invalid2.jpg image");
4402   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4403
4404   tet_infoline("Now we don't have any image to be loaded. Check event thread trigger failed.");
4405   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, 1), false, TEST_LOCATION);
4406
4407   gImageView1.Unparent();
4408   gImageView1.Reset();
4409
4410   END_TEST;
4411 }
4412 int UtcDaliImageViewSetImageOnResourceReadySignal06(void)
4413 {
4414   tet_infoline("Test texturemanager's remove image & mask queue works well within signal handler.");
4415
4416   ToolkitTestApplication application;
4417
4418   gResourceReadySignalCounter      = 0;
4419   gResourceReadySignal06ComesOrder = 0;
4420
4421   Property::Map map;
4422   map[Toolkit::ImageVisual::Property::URL]            = "invalid.jpg";
4423   map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = "invalid.png";
4424
4425   gImageView1 = ImageView::New(); // request invalid image, to make loading failed fast.
4426   gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4427   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal06);
4428   application.GetScene().Add(gImageView1);
4429
4430   gImageView2 = ImageView::New(); // request invalid image, to make loading failed fast.
4431   gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4432   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal06);
4433   application.GetScene().Add(gImageView2);
4434
4435   application.SendNotification();
4436   application.Render();
4437
4438   tet_infoline("Try to load 2 invalid image");
4439
4440   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4441   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4442
4443   tet_infoline("load done");
4444
4445   // We can test this UTC only if gImageView1 and gImageView2 loaded done.
4446   if(gResourceReadySignal06ComesOrder == -1)
4447   {
4448     tet_infoline("Bad news.. gImageView3 or gImageView4 loaded faster than others. just skip this UTC");
4449   }
4450   else
4451   {
4452     // gImageView3 and gImageView4 load must not be successed yet.
4453     DALI_TEST_EQUALS(gImageView3.GetRendererCount(), 0u, TEST_LOCATION);
4454     DALI_TEST_EQUALS(gImageView4.GetRendererCount(), 0u, TEST_LOCATION);
4455
4456     application.GetScene().Add(gImageView3);
4457     application.GetScene().Add(gImageView4);
4458     application.SendNotification();
4459     application.Render();
4460
4461     tet_infoline("Try to load 2 valid image");
4462
4463     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4464     DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4465
4466     tet_infoline("Note that resource ready should not come now.");
4467     tet_infoline("Try to load remained 2 valid image + apply masking");
4468
4469     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(4), true, TEST_LOCATION);
4470     DALI_TEST_EQUALS(gResourceReadySignalCounter, 4, TEST_LOCATION);
4471
4472     tet_infoline("Check all resource ready comes now.");
4473   }
4474   END_TEST;
4475 }
4476
4477 int UtcDaliImageViewSetImageOnResourceReadySignal07(void)
4478 {
4479   tet_infoline("Test texturemanager's remove image & mask queue works well within signal handler 02.");
4480
4481   ToolkitTestApplication application;
4482
4483   gResourceReadySignalCounter = 0;
4484
4485   Property::Map map;
4486   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
4487
4488   // Clear image view for clear test
4489
4490   if(gImageView1)
4491   {
4492     gImageView1.Reset();
4493   }
4494   if(gImageView2)
4495   {
4496     gImageView2.Reset();
4497   }
4498
4499   gImageView1 = ImageView::New();
4500   gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4501   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal07);
4502   application.GetScene().Add(gImageView1);
4503
4504   application.SendNotification();
4505   application.Render();
4506
4507   // Load gImageView1
4508
4509   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4510   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4511
4512   tet_infoline("load image1 done");
4513
4514   // Load gImageView2 and mask
4515
4516   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4517   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4518
4519   // gImageView2 mask apply done
4520
4521   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4522   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4523
4524   tet_infoline("load image2 done");
4525   END_TEST;
4526 }
4527
4528 int UtcDaliImageViewSetImageOnResourceReadySignal08(void)
4529 {
4530   tet_infoline("Test remove npatch images during resource ready");
4531
4532   ToolkitTestApplication application;
4533
4534   gResourceReadySignalCounter = 0;
4535
4536   Property::Map map;
4537   map[Toolkit::ImageVisual::Property::URL] = TEST_BROKEN_IMAGE_M;
4538
4539   // Clear image view for clear test
4540
4541   if(gImageView1)
4542   {
4543     gImageView1.Reset();
4544   }
4545   if(gImageView2)
4546   {
4547     gImageView2.Reset();
4548   }
4549
4550   // Case 1 : Remove all images during resource ready.
4551   try
4552   {
4553     gImageView1 = ImageView::New();
4554     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4555     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal08);
4556     application.GetScene().Add(gImageView1);
4557
4558     application.SendNotification();
4559     application.Render();
4560
4561     // Load gImageView1
4562     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4563     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4564
4565     application.SendNotification();
4566     application.Render();
4567
4568     DALI_TEST_CHECK(true);
4569   }
4570   catch(...)
4571   {
4572     // Exception should not happened
4573     DALI_TEST_CHECK(false);
4574   }
4575
4576   // Clear cache.
4577   application.SendNotification();
4578   application.Render();
4579
4580   gResourceReadySignalCounter = 0;
4581
4582   // Case 2 : Remove all images when we use cached resource.
4583   try
4584   {
4585     gImageView1 = ImageView::New();
4586     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4587     gImageView1.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4588     application.GetScene().Add(gImageView1);
4589
4590     application.SendNotification();
4591     application.Render();
4592
4593     // Load gImageView1
4594     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4595     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4596
4597     application.SendNotification();
4598     application.Render();
4599
4600     gImageView2 = ImageView::New();
4601     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4602     gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal08);
4603     application.GetScene().Add(gImageView2);
4604     DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4605
4606     application.SendNotification();
4607     application.Render();
4608
4609     DALI_TEST_CHECK(true);
4610   }
4611   catch(...)
4612   {
4613     // Exception should not happened
4614     DALI_TEST_CHECK(false);
4615   }
4616   gResourceReadySignalCounter = 0;
4617
4618   // Clear image view for clear test
4619
4620   if(gImageView1)
4621   {
4622     gImageView1.Reset();
4623   }
4624   if(gImageView2)
4625   {
4626     gImageView2.Reset();
4627   }
4628
4629   END_TEST;
4630 }
4631
4632 int UtcDaliImageViewSetImageOnResourceReadySignal09(void)
4633 {
4634   tet_infoline("Test load invalid npatch images during invalid resource ready");
4635
4636   ToolkitTestApplication application;
4637
4638   gResourceReadySignalCounter = 0;
4639
4640   Property::Map map;
4641   map[Toolkit::ImageVisual::Property::URL] = TEST_INVALID_NPATCH_FILE_NAME_01;
4642
4643   // Clear image view for clear test
4644
4645   if(gImageView1)
4646   {
4647     gImageView1.Reset();
4648   }
4649   if(gImageView2)
4650   {
4651     gImageView2.Reset();
4652   }
4653   if(gImageView3)
4654   {
4655     gImageView3.Reset();
4656   }
4657
4658   // Dummy view with npatch image
4659   ImageView dummyView = ImageView::New(TEST_BROKEN_IMAGE_M);
4660   application.GetScene().Add(dummyView);
4661
4662   application.SendNotification();
4663   application.Render();
4664   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4665   application.SendNotification();
4666   application.Render();
4667
4668   // Case 1 : Reload images during resource ready.
4669   try
4670   {
4671     gResourceReadySignal09Emitted = false;
4672
4673     gImageView1 = ImageView::New();
4674     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4675     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal09);
4676     application.GetScene().Add(gImageView1);
4677
4678     gImageView2 = ImageView::New();
4679     application.GetScene().Add(gImageView2);
4680
4681     // Load TEST_INVALID_NPATCH_FILE_NAME_01
4682     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4683
4684     // Load TEST_INVALID_NPATCH_FILE_NAME_01 one more times.
4685     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4686
4687     application.SendNotification();
4688     application.Render();
4689
4690     DALI_TEST_CHECK(true);
4691   }
4692   catch(...)
4693   {
4694     // Exception should not happened
4695     DALI_TEST_CHECK(false);
4696   }
4697
4698   // Clear cache.
4699   application.SendNotification();
4700   application.Render();
4701
4702   gResourceReadySignalCounter = 0;
4703
4704   // Case 2 : Remove all images when we use cached resource.
4705   try
4706   {
4707     gResourceReadySignal09Emitted = false;
4708
4709     gImageView3 = ImageView::New();
4710     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4711     gImageView3.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4712     application.GetScene().Add(gImageView3);
4713
4714     gImageView2 = ImageView::New();
4715     application.GetScene().Add(gImageView2);
4716
4717     // Load gImageView2
4718     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4719
4720     gImageView1 = ImageView::New();
4721     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4722     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal09);
4723     application.GetScene().Add(gImageView1);
4724
4725     // Load gImageView1
4726     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4727
4728     // Load TEST_INVALID_NPATCH_FILE_NAME_01 one more times.
4729     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4730
4731     application.SendNotification();
4732     application.Render();
4733
4734     DALI_TEST_CHECK(true);
4735   }
4736   catch(...)
4737   {
4738     // Exception should not happened
4739     DALI_TEST_CHECK(false);
4740   }
4741   gResourceReadySignalCounter = 0;
4742
4743   // Clear image view for clear test
4744
4745   if(gImageView1)
4746   {
4747     gImageView1.Reset();
4748   }
4749   if(gImageView2)
4750   {
4751     gImageView2.Reset();
4752   }
4753   if(gImageView3)
4754   {
4755     gImageView3.Reset();
4756   }
4757
4758   END_TEST;
4759 }
4760
4761 int UtcDaliImageViewSetImageOnResourceReadySignal10(void)
4762 {
4763   tet_infoline("Test ResourceReady signal comes more than 2 times.");
4764
4765   ToolkitTestApplication application;
4766
4767   gResourceReadySignalCounter = 0;
4768
4769   // Clear image view for clear test
4770
4771   if(gImageView1)
4772   {
4773     gImageView1.Reset();
4774   }
4775
4776   // Dummy view to cache image.
4777   ImageView dummyView = ImageView::New(gImage_34_RGBA);
4778   application.GetScene().Add(dummyView);
4779
4780   application.SendNotification();
4781   application.Render();
4782   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4783   application.SendNotification();
4784   application.Render();
4785
4786   try
4787   {
4788     gImageView1 = ImageView::New();
4789     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
4790     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal10);
4791     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4792
4793     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4794
4795     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready call too much.
4796
4797     for(int i = 0; i < gResourceReadySignal10MaxCounter; ++i)
4798     {
4799       tet_printf("RunIdles\n");
4800       // Executes the idle callbacks.
4801       application.RunIdles();
4802       application.SendNotification();
4803       application.Render();
4804       tet_printf("RunIdles done\n");
4805     }
4806     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4807
4808     DALI_TEST_EQUALS(gResourceReadySignalCounter, gResourceReadySignal10MaxCounter, TEST_LOCATION);
4809
4810     DALI_TEST_CHECK(true);
4811   }
4812   catch(...)
4813   {
4814     // Exception should not happened
4815     DALI_TEST_CHECK(false);
4816   }
4817
4818   // Clear cache.
4819   application.SendNotification();
4820   application.Render();
4821
4822   gResourceReadySignalCounter = 0;
4823
4824   gResourceReadySignalCounter = 0;
4825
4826   // Clear image view for clear test
4827
4828   if(gImageView1)
4829   {
4830     gImageView1.Reset();
4831   }
4832
4833   END_TEST;
4834 }
4835
4836 int UtcDaliImageViewSetImageOnResourceReadySignal10WhenAddIdleFailed(void)
4837 {
4838   tet_infoline("Test ResourceReady signal comes more than 2 times, but do not call again if AddIdle failed");
4839
4840   ToolkitTestApplication application;
4841
4842   gResourceReadySignalCounter = 0;
4843
4844   // Clear image view for clear test
4845
4846   if(gImageView1)
4847   {
4848     gImageView1.Reset();
4849   }
4850
4851   // Dummy view to cache image.
4852   ImageView dummyView = ImageView::New(gImage_34_RGBA);
4853   application.GetScene().Add(dummyView);
4854
4855   application.SendNotification();
4856   application.Render();
4857   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4858   application.SendNotification();
4859   application.Render();
4860
4861   // Make AddIdle failed.
4862   ToolkitApplication::ADD_IDLE_SUCCESS = false;
4863
4864   try
4865   {
4866     gImageView1 = ImageView::New();
4867     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
4868     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal10);
4869     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4870
4871     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4872
4873     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready call too much.
4874
4875     for(int i = 0; i < gResourceReadySignal10MaxCounter; ++i)
4876     {
4877       tet_printf("RunIdles\n");
4878       // Executes the idle callbacks.
4879       application.RunIdles();
4880       application.SendNotification();
4881       application.Render();
4882       tet_printf("RunIdles done\n");
4883     }
4884     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4885
4886     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready not called multiple times.
4887
4888     DALI_TEST_CHECK(true);
4889   }
4890   catch(...)
4891   {
4892     // Exception should not happened
4893     DALI_TEST_CHECK(false);
4894   }
4895
4896   ToolkitApplication::ADD_IDLE_SUCCESS = true;
4897
4898   // Clear cache.
4899   application.SendNotification();
4900   application.Render();
4901
4902   gResourceReadySignalCounter = 0;
4903
4904   gResourceReadySignalCounter = 0;
4905
4906   // Clear image view for clear test
4907
4908   if(gImageView1)
4909   {
4910     gImageView1.Reset();
4911   }
4912
4913   END_TEST;
4914 }
4915
4916 int UtcDaliImageViewSetImageOnResourceReadySignal11(void)
4917 {
4918   tet_infoline("Test ResourceReady Add AnimatedImageVisual and then Remove immediately.");
4919
4920   ToolkitTestApplication application;
4921
4922   gResourceReadySignalCounter = 0;
4923
4924   // Clear image view for clear test
4925
4926   if(gImageView1)
4927   {
4928     gImageView1.Reset();
4929   }
4930   if(gImageView2)
4931   {
4932     gImageView2.Reset();
4933   }
4934   if(gImageView3)
4935   {
4936     gImageView3.Reset();
4937   }
4938
4939   try
4940   {
4941     gImageView1 = ImageView::New();
4942     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, TEST_GIF_FILE_NAME);
4943     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal11);
4944     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4945
4946     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4947
4948     DALI_TEST_EQUALS(gResourceReadySignalCounter, 0, TEST_LOCATION);
4949
4950     application.SendNotification();
4951     application.Render();
4952
4953     // Load gImageView1
4954     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4955
4956     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4957
4958     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4959
4960     DALI_TEST_CHECK(true);
4961   }
4962   catch(...)
4963   {
4964     // Exception should not happened
4965     DALI_TEST_CHECK(false);
4966   }
4967
4968   // Clear cache.
4969   application.SendNotification();
4970   application.Render();
4971
4972   gResourceReadySignalCounter = 0;
4973
4974   // Clear image view for clear test
4975
4976   if(gImageView1)
4977   {
4978     gImageView1.Reset();
4979   }
4980   if(gImageView2)
4981   {
4982     gImageView2.Reset();
4983   }
4984   if(gImageView3)
4985   {
4986     gImageView3.Reset();
4987   }
4988
4989   END_TEST;
4990 }
4991
4992 int UtcDaliImageViewUseSameUrlWithAnimatedImageVisual(void)
4993 {
4994   tet_infoline("Test multiple views with same image in animated image visual");
4995   ToolkitTestApplication application;
4996
4997   gImageView1 = ImageView::New(TEST_WEBP_FILE_NAME);
4998   application.GetScene().Add(gImageView1);
4999
5000   tet_infoline("Remove imageView and Create new imageView with same url");
5001   application.GetScene().Remove(gImageView1);
5002   gImageView2 = ImageView::New(TEST_WEBP_FILE_NAME);
5003   application.GetScene().Add(gImageView2);
5004
5005   application.SendNotification();
5006   application.Render();
5007
5008   tet_infoline("Check the ImageView load image successfully");
5009   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5010   END_TEST;
5011 }
5012
5013 int UtcDaliImageViewNpatchImageCacheTest01(void)
5014 {
5015   tet_infoline("Test npatch image cached");
5016
5017   ToolkitTestApplication application;
5018   ImageView              imageView[2];
5019
5020   auto& gl = application.GetGlAbstraction();
5021   gl.EnableTextureCallTrace(true);
5022   auto& textureCallStack = gl.GetTextureTrace();
5023   textureCallStack.Enable(true);
5024   textureCallStack.EnableLogging(true);
5025
5026   auto TestNPatch = [&](int index, const std::string& nPatchImageUrl, const char* location) {
5027     if(imageView[index])
5028     {
5029       imageView[index].Unparent();
5030     }
5031
5032     // Ensure remove npatch cache if required.
5033     application.SendNotification();
5034     application.Render();
5035
5036     imageView[index] = ImageView::New(nPatchImageUrl);
5037     imageView[index].SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5038     application.GetScene().Add(imageView[index]);
5039   };
5040
5041   TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5042   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5043
5044   application.SendNotification();
5045   application.Render();
5046
5047   tet_printf("trace : \n%s\n", textureCallStack.GetTraceString().c_str());
5048
5049   // Check we gen only 1 textures
5050   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 1, TEST_LOCATION);
5051   textureCallStack.Reset();
5052
5053   // Let we use cached textures
5054   for(int i = 0; i < 10; i++)
5055   {
5056     TestNPatch(1, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5057     TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5058   }
5059
5060   application.SendNotification();
5061   application.Render();
5062   // Check we use cached npatch data so we don't generate new texture textures
5063   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 0, TEST_LOCATION);
5064
5065   // Clear all cached
5066   imageView[0].Unparent();
5067   imageView[0].Reset();
5068   imageView[1].Unparent();
5069   imageView[1].Reset();
5070
5071   application.SendNotification();
5072   application.Render();
5073
5074   textureCallStack.Reset();
5075   // Let we use deference textures
5076   TestNPatch(1, TEST_BROKEN_IMAGE_S, TEST_LOCATION);
5077   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5078
5079   application.SendNotification();
5080   application.Render();
5081   // Try to load multiple times.
5082   for(int i = 0; i < 3; i++)
5083   {
5084     TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5085     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5086     TestNPatch(1, TEST_BROKEN_IMAGE_S, TEST_LOCATION);
5087     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5088   }
5089   application.SendNotification();
5090   application.Render();
5091
5092   imageView[0].Unparent();
5093   imageView[0].Reset();
5094   imageView[1].Unparent();
5095   imageView[1].Reset();
5096
5097   application.SendNotification();
5098   application.Render();
5099
5100   // Check memory leak
5101   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), textureCallStack.CountMethod("DeleteTextures"), TEST_LOCATION);
5102
5103   END_TEST;
5104 }
5105
5106 int UtcDaliImageViewNpatchImageCacheTest02(void)
5107 {
5108   tet_infoline("Test npatch image cached with border");
5109
5110   ToolkitTestApplication application;
5111   ImageView              imageView[2];
5112
5113   auto& gl = application.GetGlAbstraction();
5114   gl.EnableTextureCallTrace(true);
5115   auto& textureCallStack = gl.GetTextureTrace();
5116   textureCallStack.Enable(true);
5117   textureCallStack.EnableLogging(true);
5118
5119   auto TestBorderImage = [&](int index, const std::string& normalImageUrl, const Rect<int> border, const char* location) {
5120     Property::Map map;
5121     map[Toolkit::Visual::Property::TYPE]        = Toolkit::Visual::N_PATCH;
5122     map[Toolkit::ImageVisual::Property::URL]    = normalImageUrl;
5123     map[Toolkit::ImageVisual::Property::BORDER] = border;
5124
5125     imageView[index] = ImageView::New();
5126     imageView[index].SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5127     imageView[index].SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5128     application.GetScene().Add(imageView[index]);
5129   };
5130
5131   TestBorderImage(0, gImage_34_RGBA, Rect<int>(0, 0, 0, 0), TEST_LOCATION);
5132   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5133
5134   application.SendNotification();
5135   application.Render();
5136
5137   tet_printf("trace : \n%s\n", textureCallStack.GetTraceString().c_str());
5138
5139   // Check we gen only 1 textures
5140   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 1, TEST_LOCATION);
5141   textureCallStack.Reset();
5142
5143   // Let we use cached textures
5144   for(int i = 0; i < 10; i++)
5145   {
5146     TestBorderImage(0, gImage_34_RGBA, Rect<int>(i, i + 1, i + 2, i + 3), TEST_LOCATION);
5147     TestBorderImage(1, gImage_34_RGBA, Rect<int>(i + 1, i, i + 3, i + 2), TEST_LOCATION);
5148   }
5149
5150   application.SendNotification();
5151   application.Render();
5152
5153   // Check we use cached npatch data so we don't generate new texture textures
5154   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 0, TEST_LOCATION);
5155
5156   END_TEST;
5157 }
5158
5159 int UtcDaliImageViewPlaceholderImage01(void)
5160 {
5161   tet_infoline("Test imageView use placeholder image");
5162
5163   ToolkitTestApplication application;
5164   Property::Map          map;
5165   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5166
5167   ImageView imageView = ImageView::New();
5168   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5169   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5170   application.GetScene().Add(imageView);
5171
5172   Property::Value value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5173   std::string     url;
5174   DALI_TEST_CHECK(value.Get(url));
5175   DALI_TEST_CHECK(url.empty());
5176   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5177
5178   application.SendNotification();
5179   application.Render();
5180
5181   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5182   DALI_TEST_CHECK(value.Get(url));
5183   DALI_TEST_CHECK(url == gImage_34_RGBA);
5184
5185   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5186   application.SendNotification();
5187   application.Render();
5188
5189   // Replace Image test
5190   map[Toolkit::ImageVisual::Property::URL]    = TEST_IMAGE_1;
5191   map[ImageView::Property::PLACEHOLDER_IMAGE] = gImage_34_RGBA;
5192   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5193   application.SendNotification();
5194   application.Render();
5195
5196   map[Toolkit::ImageVisual::Property::URL] = "";
5197   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5198   application.SendNotification();
5199   application.Render();
5200
5201   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_2;
5202   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5203   application.SendNotification();
5204   application.Render();
5205
5206   // Replace Image test2
5207   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5208   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5209   application.SendNotification();
5210   application.Render();
5211
5212   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_2;
5213   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5214   application.SendNotification();
5215   application.Render();
5216
5217   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5218   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5219   application.SendNotification();
5220   application.Render(900);
5221
5222   map[Toolkit::ImageVisual::Property::URL] = "";
5223   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5224   application.SendNotification();
5225   application.Render();
5226
5227   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5228   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5229   application.SendNotification();
5230   application.Render();
5231
5232   END_TEST;
5233 }
5234
5235 int UtcDaliImageViewPlaceholderImage02(void)
5236 {
5237   tet_infoline("Test imageView use placeholder image without resource ready");
5238
5239   ToolkitTestApplication application;
5240
5241   Property::Map map;
5242   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5243
5244   ImageView imageView = ImageView::New();
5245   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5246   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5247   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
5248   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5249   application.GetScene().Add(imageView);
5250
5251   Property::Value value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5252   std::string     url;
5253   DALI_TEST_CHECK(value.Get(url));
5254   DALI_TEST_CHECK(url.empty());
5255
5256   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5257   application.SendNotification();
5258   application.Render();
5259
5260   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5261
5262   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5263   DALI_TEST_CHECK(value.Get(url));
5264   DALI_TEST_CHECK(url == gImage_34_RGBA);
5265
5266   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5267   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5268
5269   gResourceReadySignalFired                = false;
5270   map[Toolkit::ImageVisual::Property::URL] = "";
5271   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5272   application.SendNotification();
5273   application.Render();
5274
5275   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5276   DALI_TEST_EQUALS(gResourceReadySignalFired, false, TEST_LOCATION);
5277
5278   END_TEST;
5279 }
5280
5281 int UtcDaliImageViewTransitionEffect01(void)
5282 {
5283   tet_infoline("Test imageView use transition effect");
5284
5285   ToolkitTestApplication application;
5286   Property::Map          map;
5287   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5288   map[Toolkit::Visual::Property::OPACITY]  = 0.9f;
5289
5290   ImageView imageView = ImageView::New();
5291   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5292   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5293   application.GetScene().Add(imageView);
5294
5295   Property::Value value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5296   bool            transition;
5297   DALI_TEST_CHECK(value.Get(transition));
5298   DALI_TEST_CHECK(transition == false);
5299   imageView.SetProperty(Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5300
5301   application.SendNotification();
5302   application.Render();
5303
5304   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5305   DALI_TEST_CHECK(value.Get(transition));
5306   DALI_TEST_CHECK(transition == true);
5307
5308   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5309   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5310   application.SendNotification();
5311   application.Render();
5312
5313   // Test transition effect with placeholder
5314   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5315   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5316   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5317   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5318   application.SendNotification();
5319   application.Render();
5320
5321   map[Toolkit::ImageVisual::Property::URL] = "";
5322   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5323   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5324   application.SendNotification();
5325   application.Render();
5326
5327   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5328   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5329   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5330   application.SendNotification();
5331   application.Render();
5332
5333   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5334   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5335   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5336   application.SendNotification();
5337
5338   map[Toolkit::ImageVisual::Property::URL] = "";
5339   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5340   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5341   application.SendNotification();
5342   application.Render();
5343
5344   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5345   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5346   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, "");
5347   application.SendNotification();
5348   application.Render();
5349
5350   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5351   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5352   application.SendNotification();
5353   application.Render();
5354
5355   map[Toolkit::ImageVisual::Property::URL] = "";
5356   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5357   application.SendNotification();
5358   application.Render();
5359
5360   // Test transition effect without placeholder
5361   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5362   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5363   application.SendNotification();
5364   application.Render();
5365
5366   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5367   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5368   application.SendNotification();
5369   application.Render();
5370
5371   map[Toolkit::ImageVisual::Property::URL] = "";
5372   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5373   application.SendNotification();
5374   application.Render();
5375
5376   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5377   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5378   application.SendNotification();
5379   application.Render();
5380
5381   imageView.SetImage(TEST_IMAGE_1);
5382   application.SendNotification();
5383   application.Render();
5384
5385   imageView.SetImage(gImage_600_RGB);
5386   application.SendNotification();
5387   application.Render(9000);
5388
5389   imageView.SetImage("");
5390   application.SendNotification();
5391   application.Render();
5392
5393   imageView.SetImage(TEST_IMAGE_1);
5394   application.SendNotification();
5395   application.Render();
5396
5397   // Clear all cached
5398   imageView.Unparent();
5399   imageView.Reset();
5400
5401   END_TEST;
5402 }
5403
5404 int UtcDaliImageViewTransitionEffect02(void)
5405 {
5406   tet_infoline("Test imageView use transition effect with replace image");
5407
5408   ToolkitTestApplication application;
5409
5410   Property::Map map;
5411
5412   ImageView imageView = ImageView::New();
5413   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5414   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5415   application.GetScene().Add(imageView);
5416
5417   Property::Value value;
5418   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5419   bool transition;
5420   DALI_TEST_CHECK(value.Get(transition));
5421   DALI_TEST_CHECK(transition == false);
5422   imageView.SetProperty(Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5423
5424   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5425   std::string url;
5426   DALI_TEST_CHECK(value.Get(url));
5427   DALI_TEST_CHECK(url.empty());
5428   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5429   application.SendNotification();
5430   application.Render();
5431
5432   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, "");
5433   application.SendNotification();
5434   application.Render();
5435
5436   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5437   application.SendNotification();
5438   application.Render();
5439
5440   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5441   DALI_TEST_CHECK(value.Get(transition));
5442   DALI_TEST_CHECK(transition == true);
5443
5444   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5445   DALI_TEST_CHECK(value.Get(url));
5446   DALI_TEST_CHECK(url == gImage_34_RGBA);
5447
5448   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5449   application.SendNotification();
5450   application.Render();
5451
5452   // Clear all cached
5453   imageView.Unparent();
5454   imageView.Reset();
5455
5456   END_TEST;
5457 }
5458
5459 int UtcDaliImageViewTransitionEffect03(void)
5460 {
5461   tet_infoline("Test imageView use transition effect with placeholder");
5462
5463   ToolkitTestApplication application;
5464   Property::Map          map;
5465
5466   ImageView imageView = ImageView::New();
5467   imageView.SetImage("");
5468   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5469   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5470   imageView.SetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5471   application.GetScene().Add(imageView);
5472
5473   //DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5474
5475   application.SendNotification();
5476   application.Render(16);
5477
5478   tet_infoline("(1)");
5479   imageView.SetImage(gImage_600_RGB);
5480   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5481   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5482   application.SendNotification();
5483   application.Render(16);
5484
5485   Property::Value value;
5486   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5487   bool transition;
5488   DALI_TEST_CHECK(value.Get(transition));
5489   DALI_TEST_CHECK(transition == true);
5490
5491   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5492   std::string url;
5493   DALI_TEST_CHECK(value.Get(url));
5494   DALI_TEST_CHECK(url == gImage_34_RGBA);
5495
5496   imageView.SetImage("");
5497   application.SendNotification();
5498   application.Render(16);
5499
5500   imageView.SetImage(TEST_IMAGE_1);
5501   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5502   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5503   application.SendNotification();
5504   application.Render(16);
5505
5506   // Clear all cached
5507   imageView.Unparent();
5508   imageView.Reset();
5509
5510   END_TEST;
5511 }
5512
5513 int UtcDaliImageViewImageLoadFailureAndReload01(void)
5514 {
5515   tet_infoline("Try to load invalid image first, and then reload after that image valid.");
5516   ToolkitTestApplication application;
5517
5518   gResourceReadySignalFired = false;
5519
5520   // Make overwritable image invalid first.
5521   OverwriteImage("");
5522
5523   ImageView imageView = ImageView::New(TEST_OVERWRITABLE_IMAGE_FILE_NAME);
5524   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
5525   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5526
5527   application.GetScene().Add(imageView);
5528   application.SendNotification();
5529   application.Render(16);
5530
5531   // loading started, this waits for the loader thread
5532   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5533
5534   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5535   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5536   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
5537
5538   gResourceReadySignalFired = false;
5539
5540   // Make overwritable image valid now.
5541   OverwriteImage(gImage_34_RGBA);
5542
5543   // Reload the image
5544   Property::Map attributes;
5545   DevelControl::DoAction(imageView, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
5546   application.SendNotification();
5547   application.Render(16);
5548
5549   // loading started, this waits for the loader thread
5550   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5551
5552   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5553   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5554   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5555
5556   // Make overwritable image invalid end of test (for clean).
5557   OverwriteImage("");
5558
5559   gResourceReadySignalFired = false;
5560
5561   END_TEST;
5562 }
5563
5564 int UtcDaliImageViewImageLoadFailureAndReload02(void)
5565 {
5566   tet_infoline("Try to load invalid image first, and then reload after that image valid.");
5567   tet_infoline("This case, broken image was n-patch. So we should check whether Geometry / Shader changed after reload");
5568   ToolkitTestApplication application;
5569
5570   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
5571   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
5572   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
5573   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
5574
5575   gResourceReadySignalFired = false;
5576
5577   // Make overwritable image invalid first.
5578   OverwriteImage("");
5579
5580   ImageView imageView = ImageView::New(TEST_OVERWRITABLE_IMAGE_FILE_NAME);
5581   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
5582   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5583
5584   application.GetScene().Add(imageView);
5585   application.SendNotification();
5586   application.Render(16);
5587
5588   // loading started, this waits for the loader thread
5589   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5590
5591   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5592   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5593   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
5594
5595   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
5596   Geometry brokenGeometry = imageView.GetRendererAt(0u).GetGeometry();
5597   Shader   brokenShader   = imageView.GetRendererAt(0u).GetShader();
5598   DALI_TEST_CHECK(brokenGeometry);
5599   DALI_TEST_CHECK(brokenShader);
5600
5601   gResourceReadySignalFired = false;
5602
5603   // Make overwritable image valid now.
5604   OverwriteImage(gImage_34_RGBA);
5605
5606   // Reload the image
5607   Property::Map attributes;
5608   DevelControl::DoAction(imageView, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
5609   application.SendNotification();
5610   application.Render(16);
5611
5612   // loading started, this waits for the loader thread
5613   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5614
5615   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5616   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5617   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5618
5619   // Check whether we don't use n-patch shader and geometry in this case.
5620   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
5621   DALI_TEST_CHECK(brokenGeometry != imageView.GetRendererAt(0u).GetGeometry());
5622   DALI_TEST_CHECK(brokenShader != imageView.GetRendererAt(0u).GetShader());
5623
5624   // Make overwritable image invalid end of test (for clean).
5625   OverwriteImage("");
5626
5627   gResourceReadySignalFired = false;
5628
5629   END_TEST;
5630 }