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   value = returnedMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE);
2224   DALI_TEST_CHECK(value);
2225   DALI_TEST_EQUALS(value->Get<std::string>(), "FIT_HEIGHT", TEST_LOCATION); // OFFSET is zero
2226
2227   END_TEST;
2228 }
2229
2230 int UtcDaliImageViewFittingModesFitHeight02(void)
2231 {
2232   ToolkitTestApplication application;
2233
2234   tet_infoline("Create an ImageVisual using FitHeight ( image: [600,600], view: [700,600] )");
2235
2236   ImageView     imageView = ImageView::New();
2237   Property::Map imageMap;
2238   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2239   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 249x169 image
2240   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_HEIGHT);
2241
2242   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2243   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 600));
2244
2245   application.GetScene().Add(imageView);
2246
2247   // Trigger a potential relayout
2248   application.SendNotification();
2249   application.Render();
2250
2251   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2252   Property::Map         returnedMap;
2253   visual.CreatePropertyMap(returnedMap);
2254
2255   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2256   DALI_TEST_CHECK(value);
2257   Property::Map* map = value->GetMap();
2258   DALI_TEST_CHECK(map);
2259
2260   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2261   DALI_TEST_CHECK(value);
2262   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2263
2264   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2265   DALI_TEST_CHECK(value);
2266   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2267
2268   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2269   DALI_TEST_CHECK(value);
2270   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2271
2272   END_TEST;
2273 }
2274
2275 int UtcDaliImageViewFittingModesFitWidth01(void)
2276 {
2277   ToolkitTestApplication application;
2278
2279   tet_infoline("Create an ImageVisual using FitWidth ( image: [600,600], view: [600,700] )");
2280
2281   ImageView     imageView = ImageView::New();
2282   Property::Map imageMap;
2283   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2284   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 600x600 image
2285   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_WIDTH);
2286
2287   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2288   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 700));
2289
2290   application.GetScene().Add(imageView);
2291
2292   // Trigger a potential relayout
2293   application.SendNotification();
2294   application.Render();
2295
2296   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2297   Property::Map         returnedMap;
2298   visual.CreatePropertyMap(returnedMap);
2299
2300   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2301   DALI_TEST_CHECK(value);
2302   Property::Map* map = value->GetMap();
2303   DALI_TEST_CHECK(map);
2304
2305   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2306   DALI_TEST_CHECK(value);
2307   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2308
2309   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2310   DALI_TEST_CHECK(value);
2311   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2312
2313   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2314   DALI_TEST_CHECK(value);
2315   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 50), TEST_LOCATION);
2316
2317   value = returnedMap.Find(DevelVisual::Property::VISUAL_FITTING_MODE);
2318   DALI_TEST_CHECK(value);
2319   DALI_TEST_EQUALS(value->Get<std::string>(), "FIT_WIDTH", TEST_LOCATION); // OFFSET is zero
2320
2321   END_TEST;
2322 }
2323
2324 int UtcDaliImageViewFittingModesFitWidth02(void)
2325 {
2326   ToolkitTestApplication application;
2327
2328   tet_infoline("Create an ImageVisual using FitWidth ( image: [600,600], view:[700,600] )");
2329
2330   ImageView     imageView = ImageView::New();
2331   Property::Map imageMap;
2332   imageMap.Add(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2333   imageMap.Add(Toolkit::ImageVisual::Property::URL, gImage_600_RGB); // 249x169 image
2334   imageMap.Add(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_WIDTH);
2335
2336   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2337   imageView.SetProperty(Actor::Property::SIZE, Vector2(700, 600));
2338
2339   application.GetScene().Add(imageView);
2340
2341   // Trigger a potential relayout
2342   application.SendNotification();
2343   application.Render();
2344
2345   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2346   Property::Map         returnedMap;
2347   visual.CreatePropertyMap(returnedMap);
2348
2349   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2350   DALI_TEST_CHECK(value);
2351   Property::Map* map = value->GetMap();
2352   DALI_TEST_CHECK(map);
2353
2354   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2355   DALI_TEST_CHECK(value);
2356   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 600), TEST_LOCATION); // Change the internal size according to the image view size
2357
2358   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2359   DALI_TEST_CHECK(value);
2360   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2361
2362   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2363   DALI_TEST_CHECK(value);
2364   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2365
2366   END_TEST;
2367 }
2368
2369 int UtcDaliImageViewFittingModesChangeFittingMode01(void)
2370 {
2371   ToolkitTestApplication application;
2372
2373   tet_infoline("UtcDaliImageViewFittingModesChangeFittingMode, image: [600,600], view:[800,700]");
2374
2375   ImageView imageView = ImageView::New();
2376
2377   // 1. Render using FittingMode::SHRINK_TO_FIT
2378   Property::Map imageMap;
2379   imageMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2380   imageMap[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2381   imageMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
2382
2383   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2384   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2385
2386   application.GetScene().Add(imageView);
2387
2388   // Trigger a potential relayout
2389   application.SendNotification();
2390   application.Render();
2391
2392   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2393   Property::Map         returnedMap;
2394   visual.CreatePropertyMap(returnedMap);
2395
2396   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2397   DALI_TEST_CHECK(value);
2398   Property::Map* map = value->GetMap();
2399   DALI_TEST_CHECK(map);
2400
2401   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2402   DALI_TEST_CHECK(value);
2403   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 700), TEST_LOCATION); // Change the internal size according to the image view size
2404
2405   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2406   DALI_TEST_CHECK(value);
2407   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2408
2409   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2410   DALI_TEST_CHECK(value);
2411   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2412
2413   // 2. Render again using DevelVisaul::CENTER
2414   Property::Map imageMap2;
2415   imageMap2[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2416   imageMap2[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2417   imageMap2[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::CENTER;
2418
2419   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap2);
2420   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2421
2422   application.GetScene().Add(imageView);
2423
2424   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2425
2426   // Trigger a potential relayout
2427   application.SendNotification();
2428   application.Render();
2429
2430   returnedMap.Clear();
2431   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2432
2433   visual.CreatePropertyMap(returnedMap);
2434
2435   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2436   DALI_TEST_CHECK(value);
2437   map = value->GetMap();
2438   DALI_TEST_CHECK(map);
2439
2440   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2441   DALI_TEST_CHECK(value);
2442   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2443
2444   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2445   DALI_TEST_CHECK(value);
2446   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2447
2448   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2449   DALI_TEST_CHECK(value);
2450   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(100, 50), TEST_LOCATION);
2451
2452   // 3. Render again using before fittingMode
2453   Property::Map imageMap3;
2454   imageMap3[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2455   imageMap3[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2456   imageMap3[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO;
2457
2458   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap3);
2459   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2460
2461   application.GetScene().Add(imageView);
2462
2463   // Trigger a potential relayout
2464   application.SendNotification();
2465   application.Render();
2466
2467   returnedMap.Clear();
2468   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2469   visual.CreatePropertyMap(returnedMap);
2470
2471   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2472   DALI_TEST_CHECK(value);
2473   map = value->GetMap();
2474   DALI_TEST_CHECK(map);
2475
2476   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2477   DALI_TEST_CHECK(value);
2478   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(700, 700), TEST_LOCATION); // Change the internal size according to the image view size
2479
2480   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2481   DALI_TEST_CHECK(value);
2482   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2483
2484   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2485   DALI_TEST_CHECK(value);
2486   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(50, 0), TEST_LOCATION);
2487
2488   END_TEST;
2489 }
2490
2491 int UtcDaliImageViewFittingModesChangeFittingMode02(void)
2492 {
2493   ToolkitTestApplication application;
2494
2495   tet_infoline("UtcDaliImageViewFittingModesChangeFittingMode, image: [600,600], view:[800,700]");
2496
2497   ImageView imageView = ImageView::New();
2498
2499   // 1. Render using FittingMode::OVER_FIT_KEEP_ASPECT_RATIO
2500   Property::Map imageMap;
2501   imageMap[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2502   imageMap[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2503   imageMap[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::OVER_FIT_KEEP_ASPECT_RATIO;
2504
2505   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2506   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2507
2508   application.GetScene().Add(imageView);
2509
2510   // Trigger a potential relayout
2511   application.SendNotification();
2512   application.Render();
2513
2514   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2515   Property::Map         returnedMap;
2516   visual.CreatePropertyMap(returnedMap);
2517
2518   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2519   DALI_TEST_CHECK(value);
2520   Property::Map* map = value->GetMap();
2521   DALI_TEST_CHECK(map);
2522
2523   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2524   DALI_TEST_CHECK(value);
2525   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(800, 700), TEST_LOCATION); // Change the internal size according to the image view size
2526
2527   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2528   DALI_TEST_CHECK(value);
2529   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2530
2531   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2532   DALI_TEST_CHECK(value);
2533   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
2534
2535   // 2. Render again using DevelVisaul::CENTER
2536   Property::Map imageMap2;
2537   imageMap2[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2538   imageMap2[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2539   imageMap2[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::CENTER;
2540
2541   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap2);
2542   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2543
2544   application.GetScene().Add(imageView);
2545
2546   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2547
2548   // Trigger a potential relayout
2549   application.SendNotification();
2550   application.Render();
2551
2552   returnedMap.Clear();
2553   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2554
2555   visual.CreatePropertyMap(returnedMap);
2556
2557   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2558   DALI_TEST_CHECK(value);
2559   map = value->GetMap();
2560   DALI_TEST_CHECK(map);
2561
2562   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2563   DALI_TEST_CHECK(value);
2564   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(600, 600), TEST_LOCATION); // Change the internal size according to the image view size
2565
2566   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2567   DALI_TEST_CHECK(value);
2568   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2569
2570   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2571   DALI_TEST_CHECK(value);
2572   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(100, 50), TEST_LOCATION);
2573
2574   // 3. Render again using before fittingMode
2575   Property::Map imageMap3;
2576   imageMap3[Toolkit::Visual::Property::TYPE]            = Toolkit::Visual::IMAGE;
2577   imageMap3[Toolkit::ImageVisual::Property::URL]        = gImage_600_RGB;
2578   imageMap3[DevelVisual::Property::VISUAL_FITTING_MODE] = Toolkit::DevelVisual::OVER_FIT_KEEP_ASPECT_RATIO;
2579
2580   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap3);
2581   imageView.SetProperty(Actor::Property::SIZE, Vector2(800, 700));
2582
2583   application.GetScene().Add(imageView);
2584
2585   // Trigger a potential relayout
2586   application.SendNotification();
2587   application.Render();
2588
2589   returnedMap.Clear();
2590   visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2591   visual.CreatePropertyMap(returnedMap);
2592
2593   value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2594   DALI_TEST_CHECK(value);
2595   map = value->GetMap();
2596   DALI_TEST_CHECK(map);
2597
2598   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2599   DALI_TEST_CHECK(value);
2600   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(800, 700), TEST_LOCATION); // Change the internal size according to the image view size
2601
2602   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2603   DALI_TEST_CHECK(value);
2604   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2605
2606   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2607   DALI_TEST_CHECK(value);
2608   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION);
2609
2610   END_TEST;
2611 }
2612
2613 int UtcDaliImageViewFittingModesWithAnimatedVectorImageVisual(void)
2614 {
2615   ToolkitTestApplication application;
2616
2617   tet_infoline("Create an ImageVisual using SCALE_TO_FILL and animated vector image ( image: [600,600], view:[600,600] )");
2618
2619   ImageView     imageView = ImageView::New();
2620   Property::Map imageMap;
2621   imageMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE);
2622   imageMap.Add(Toolkit::ImageVisual::Property::URL, TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME); // 249x169 image
2623
2624   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, imageMap);
2625   imageView.SetProperty(Actor::Property::SIZE, Vector2(600, 600));
2626
2627   application.GetScene().Add(imageView);
2628
2629   // Trigger a potential relayout
2630   application.SendNotification();
2631   application.Render();
2632
2633   Toolkit::Visual::Base visual = DevelControl::GetVisual(Toolkit::Internal::GetImplementation(imageView), Toolkit::ImageView::Property::IMAGE);
2634   Property::Map         returnedMap;
2635   visual.CreatePropertyMap(returnedMap);
2636
2637   Property::Value* value = returnedMap.Find(Toolkit::Visual::Property::TRANSFORM);
2638   DALI_TEST_CHECK(value);
2639   Property::Map* map = value->GetMap();
2640   DALI_TEST_CHECK(map);
2641
2642   value = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2643   DALI_TEST_CHECK(value);
2644   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2::ONE, TEST_LOCATION); // Relative size so will take up 100%
2645
2646   value = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2647   DALI_TEST_CHECK(value);
2648   DALI_TEST_CHECK(value->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
2649
2650   value = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2651   DALI_TEST_CHECK(value);
2652   DALI_TEST_EQUALS(value->Get<Vector2>(), Vector2(0, 0), TEST_LOCATION); // OFFSET is zero
2653
2654   END_TEST;
2655 }
2656
2657 int UtcDaliImageViewCustomShader(void)
2658 {
2659   ToolkitTestApplication application;
2660
2661   // Set a custom shader with an image url
2662   {
2663     Property::Map     properties;
2664     Property::Map     shader;
2665     const std::string vertexShader                    = "Foobar";
2666     const std::string fragmentShader                  = "Foobar";
2667     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2668     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2669
2670     properties[Visual::Property::TYPE]     = Visual::IMAGE;
2671     properties[Visual::Property::SHADER]   = shader;
2672     properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2673
2674     ImageView imageView = ImageView::New();
2675     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2676
2677     application.GetScene().Add(imageView);
2678
2679     application.SendNotification();
2680     application.Render();
2681
2682     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2683
2684     Renderer        renderer = imageView.GetRendererAt(0);
2685     Shader          shader2  = renderer.GetShader();
2686     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2687     Property::Map*  map      = value.GetMap();
2688     DALI_TEST_CHECK(map);
2689
2690     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2691     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2692
2693     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2694     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2695   }
2696
2697   // Set a custom shader after setting an image url
2698   {
2699     Property::Map     properties;
2700     Property::Map     shader;
2701     const std::string vertexShader                    = "Foobar";
2702     const std::string fragmentShader                  = "Foobar";
2703     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2704     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2705
2706     properties[Visual::Property::SHADER] = shader;
2707
2708     ImageView imageView = ImageView::New(TEST_IMAGE_FILE_NAME);
2709     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2710
2711     application.GetScene().Add(imageView);
2712
2713     application.SendNotification();
2714     application.Render();
2715
2716     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2717
2718     Renderer        renderer = imageView.GetRendererAt(0);
2719     Shader          shader2  = renderer.GetShader();
2720     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2721     Property::Map*  map      = value.GetMap();
2722     DALI_TEST_CHECK(map);
2723
2724     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2725     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2726
2727     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2728     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2729   }
2730
2731   // Set a custom shader before setting an image url
2732   {
2733     Property::Map     properties;
2734     Property::Map     shader;
2735     const std::string vertexShader                    = "Foobar";
2736     const std::string fragmentShader                  = "Foobar";
2737     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2738     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2739
2740     properties[Visual::Property::SHADER] = shader;
2741
2742     ImageView imageView = ImageView::New();
2743     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2744     imageView.SetProperty(ImageView::Property::IMAGE, TEST_IMAGE_FILE_NAME);
2745
2746     application.GetScene().Add(imageView);
2747
2748     application.SendNotification();
2749     application.Render();
2750     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2751
2752     Renderer        renderer = imageView.GetRendererAt(0);
2753     Shader          shader2  = renderer.GetShader();
2754     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2755     Property::Map*  map      = value.GetMap();
2756     DALI_TEST_CHECK(map);
2757
2758     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2759     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2760
2761     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2762     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2763   }
2764
2765   // Set a custom shader after setting a property map
2766   {
2767     Property::Map     properties;
2768     Property::Map     shader;
2769     const std::string vertexShader                    = "Foobar";
2770     const std::string fragmentShader                  = "Foobar";
2771     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2772     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2773
2774     properties[Visual::Property::SHADER] = shader;
2775
2776     Property::Map properties1;
2777     properties1[Visual::Property::TYPE]     = Visual::IMAGE;
2778     properties1[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2779
2780     ImageView imageView = ImageView::New();
2781     imageView.SetProperty(ImageView::Property::IMAGE, properties1);
2782     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2783
2784     application.GetScene().Add(imageView);
2785
2786     application.SendNotification();
2787     application.Render();
2788     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2789
2790     Renderer        renderer = imageView.GetRendererAt(0);
2791     Shader          shader2  = renderer.GetShader();
2792     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2793     Property::Map*  map      = value.GetMap();
2794     DALI_TEST_CHECK(map);
2795
2796     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2797     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2798
2799     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2800     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2801   }
2802
2803   // Set a custom shader before setting a property map
2804   {
2805     Property::Map     properties;
2806     Property::Map     shader;
2807     const std::string vertexShader                    = "Foobar";
2808     const std::string fragmentShader                  = "Foobar";
2809     shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2810     shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2811
2812     properties[Visual::Property::SHADER] = shader;
2813
2814     Property::Map properties1;
2815     properties1[Visual::Property::TYPE]     = Visual::IMAGE;
2816     properties1[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2817
2818     ImageView imageView = ImageView::New();
2819     imageView.SetProperty(ImageView::Property::IMAGE, properties);
2820     imageView.SetProperty(ImageView::Property::IMAGE, properties1);
2821
2822     application.GetScene().Add(imageView);
2823
2824     application.SendNotification();
2825     application.Render();
2826     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2827
2828     Renderer        renderer = imageView.GetRendererAt(0);
2829     Shader          shader2  = renderer.GetShader();
2830     Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2831     Property::Map*  map      = value.GetMap();
2832     DALI_TEST_CHECK(map);
2833
2834     Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2835     DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2836
2837     Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2838     DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2839   }
2840
2841   END_TEST;
2842 }
2843
2844 namespace
2845 {
2846 static int gFailCounter = 0;
2847 const int  MAX_RETRIES(3);
2848
2849 void ReloadImage(ImageView imageView)
2850 {
2851   Property::Map imageImmediateLoadingMap;
2852   imageImmediateLoadingMap[ImageVisual::Property::URL]         = "Non-existant-image.jpg";
2853   imageImmediateLoadingMap[ImageVisual::Property::LOAD_POLICY] = ImageVisual::LoadPolicy::IMMEDIATE;
2854
2855   tet_infoline("Immediate load an image");
2856   imageView.SetProperty(ImageView::Property::IMAGE, imageImmediateLoadingMap);
2857 }
2858
2859 void ResourceFailedReload(Control control)
2860 {
2861   gFailCounter++;
2862 }
2863 } // namespace
2864
2865 int UtcDaliImageViewReloadFailedOnResourceReadySignal(void)
2866 {
2867   tet_infoline("Test reloading failed image from within signal handler.");
2868
2869   ToolkitTestApplication application;
2870
2871   gFailCounter = 0;
2872
2873   ImageView imageView = ImageView::New();
2874   imageView.ResourceReadySignal().Connect(&ResourceFailedReload);
2875   DALI_TEST_EQUALS(gFailCounter, 0, TEST_LOCATION);
2876   ReloadImage(imageView);
2877
2878   // loading started, this waits for the loader thread to complete
2879   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2880   DALI_TEST_EQUALS(gFailCounter, 1, TEST_LOCATION);
2881
2882   ReloadImage(imageView);
2883   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2884   DALI_TEST_EQUALS(gFailCounter, 2, TEST_LOCATION);
2885
2886   ReloadImage(imageView);
2887   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2888   DALI_TEST_EQUALS(gFailCounter, 3, TEST_LOCATION);
2889
2890   END_TEST;
2891 }
2892
2893 int UtcDaliImageViewLoadRemoteSVG(void)
2894 {
2895   tet_infoline("Test load from a remote server.");
2896
2897   ToolkitTestApplication application;
2898
2899   {
2900     Toolkit::ImageView imageView;
2901     imageView = Toolkit::ImageView::New();
2902     imageView.SetImage("https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg");
2903     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2904     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2905     imageView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
2906     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2907
2908     application.GetScene().Add(imageView);
2909
2910     DALI_TEST_CHECK(imageView);
2911
2912     DALI_TEST_EQUALS(imageView.GetRendererCount(), 0u, TEST_LOCATION);
2913
2914     application.SendNotification();
2915
2916     // Wait for loading & rasterization
2917     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2918
2919     application.SendNotification();
2920     application.Render();
2921
2922     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
2923   }
2924
2925   // Without size set
2926   {
2927     Toolkit::ImageView imageView;
2928     imageView = Toolkit::ImageView::New();
2929     imageView.SetImage("https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/check.svg");
2930     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2931     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2932     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2933
2934     application.GetScene().Add(imageView);
2935
2936     DALI_TEST_CHECK(imageView);
2937
2938     DALI_TEST_EQUALS(imageView.GetRendererCount(), 0u, TEST_LOCATION);
2939
2940     application.SendNotification();
2941
2942     // Wait for loading & rasterization
2943     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2944
2945     application.SendNotification();
2946     application.Render();
2947
2948     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
2949   }
2950
2951   END_TEST;
2952 }
2953
2954 int UtcDaliImageViewLoadRemoteLottie(void)
2955 {
2956   tet_infoline("Test load from a remote server. (Note we don't support real download now. Just for line coverage)");
2957
2958   ToolkitTestApplication application;
2959
2960   {
2961     Toolkit::ImageView imageView;
2962     imageView = Toolkit::ImageView::New();
2963     imageView.SetImage("https://lottie.json");
2964     imageView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
2965     imageView.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
2966     imageView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
2967     imageView.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
2968
2969     application.GetScene().Add(imageView);
2970
2971     DALI_TEST_CHECK(imageView);
2972
2973     application.SendNotification();
2974     application.Render();
2975
2976     // Do not check anything for here.
2977   }
2978
2979   END_TEST;
2980 }
2981
2982 int UtcDaliImageViewSyncSVGLoading(void)
2983 {
2984   ToolkitTestApplication application;
2985
2986   tet_infoline("ImageView Testing SVG image sync loading");
2987
2988   {
2989     ImageView imageView = ImageView::New();
2990
2991     // Sync loading is used
2992     Property::Map syncLoadingMap;
2993     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
2994     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
2995     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, true);
2996     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
2997
2998     application.GetScene().Add(imageView);
2999     DALI_TEST_CHECK(imageView);
3000
3001     application.SendNotification();
3002     Vector3 naturalSize = imageView.GetNaturalSize();
3003
3004     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3005     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3006   }
3007   END_TEST;
3008 }
3009
3010 int UtcDaliImageViewSyncSVGLoading02(void)
3011 {
3012   ToolkitTestApplication application;
3013
3014   tet_infoline("ImageView Testing SVG image sync loading");
3015
3016   {
3017     ImageView imageView = ImageView::New();
3018
3019     // Sync loading is used
3020     Property::Map syncLoadingMap;
3021     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3022     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3023     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, true);
3024     syncLoadingMap.Insert(DevelVisual::Property::VISUAL_FITTING_MODE, Toolkit::DevelVisual::FIT_KEEP_ASPECT_RATIO);
3025     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
3026     imageView.ResourceReadySignal().Connect(&OnResourceReadySignalSVG);
3027
3028     application.GetScene().Add(imageView);
3029     DALI_TEST_CHECK(imageView);
3030
3031     application.SendNotification();
3032     application.Render();
3033
3034     // Check whether Image Visual transforms on ImageVieiw::OnRelayout()
3035     Toolkit::Internal::Control& controlImpl = Toolkit::Internal::GetImplementation(imageView);
3036     Toolkit::Visual::Base       imageVisual = DevelControl::GetVisual(controlImpl, ImageView::Property::IMAGE);
3037     Property::Map               resultMap;
3038     imageVisual.CreatePropertyMap(resultMap);
3039
3040     Property::Value* transformValue = resultMap.Find(Visual::Property::TRANSFORM);
3041     DALI_TEST_CHECK(transformValue);
3042     Property::Map* retMap = transformValue->GetMap();
3043     DALI_TEST_CHECK(retMap);
3044
3045     // Image Visual should be positioned depending on ImageView's padding
3046     DALI_TEST_EQUALS(retMap->Find(Visual::Transform::Property::SIZE)->Get<Vector2>(), Vector2(100, 100), TEST_LOCATION);
3047
3048     Vector3 naturalSize = imageView.GetNaturalSize();
3049     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3050     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3051   }
3052   END_TEST;
3053 }
3054
3055 int UtcDaliImageViewAsyncSVGLoading(void)
3056 {
3057   ToolkitTestApplication application;
3058
3059   tet_infoline("ImageView Testing SVG image async loading");
3060
3061   {
3062     ImageView imageView = ImageView::New();
3063
3064     // Async loading is used - default value of SYNCHRONOUS_LOADING is false.
3065     Property::Map propertyMap;
3066     propertyMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3067     propertyMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3068     imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
3069
3070     application.GetScene().Add(imageView);
3071     DALI_TEST_CHECK(imageView);
3072
3073     application.SendNotification();
3074
3075     // Wait for loading
3076     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3077
3078     application.SendNotification();
3079     application.Render(16);
3080
3081     Vector3 naturalSize = imageView.GetNaturalSize();
3082     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3083     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3084   }
3085   END_TEST;
3086 }
3087
3088 int UtcDaliImageViewSVGLoadingSyncSetInvalidValue(void)
3089 {
3090   ToolkitTestApplication application;
3091
3092   tet_infoline("ImageView Testing SVG image async loading");
3093
3094   // Sync loading
3095   {
3096     ImageView imageView = ImageView::New();
3097
3098     // Sync loading is used
3099     Property::Map syncLoadingMap;
3100     syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
3101     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
3102
3103     // Check to set invalid value
3104     // The SYNCHRONOUS_LOADING property must be set to the bool value.
3105     // Check if error log is outputted when setting other value like string.
3106     // Even if the wrong value is set, the image will be shown normally, and the synchronous value should be the default value(false).
3107     syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, std::to_string(5));
3108     imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
3109
3110     application.GetScene().Add(imageView);
3111     DALI_TEST_CHECK(imageView);
3112
3113     application.SendNotification();
3114
3115     // Wait for loading
3116     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3117
3118     application.SendNotification();
3119     application.Render(16);
3120
3121     Vector3 naturalSize = imageView.GetNaturalSize();
3122     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3123     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3124
3125     Property::Value value = imageView.GetProperty(ImageView::Property::IMAGE);
3126     Property::Map*  map   = value.GetMap();
3127     DALI_TEST_CHECK(map);
3128
3129     Property::Value* sync = map->Find(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING);
3130     DALI_TEST_CHECK(sync);
3131     DALI_TEST_EQUALS(false, sync->Get<bool>(), TEST_LOCATION);
3132   }
3133   END_TEST;
3134 }
3135
3136 int UtcDaliImageViewSvgLoadingFailureLocalFile(void)
3137 {
3138   // Local svg file - invalid file path
3139   {
3140     ToolkitTestApplication application;
3141
3142     TestGlAbstraction& gl           = application.GetGlAbstraction();
3143     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3144     textureTrace.Enable(true);
3145
3146     gResourceReadySignalFired = false;
3147
3148     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/foo.svg");
3149     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3150     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3151
3152     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3153
3154     application.GetScene().Add(imageView);
3155
3156     application.SendNotification();
3157
3158     // loading started, this waits for the loader thread - load
3159     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3160
3161     application.SendNotification();
3162     application.Render(16);
3163
3164     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3165     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3166     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3167
3168     // Should be shown a broken image
3169     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3170     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3171   }
3172
3173   // Local svg file - invalid file path without size set
3174   {
3175     ToolkitTestApplication application;
3176
3177     TestGlAbstraction& gl           = application.GetGlAbstraction();
3178     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3179     textureTrace.Enable(true);
3180
3181     gResourceReadySignalFired = false;
3182     textureTrace.Reset();
3183
3184     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/foo.svg");
3185     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3186
3187     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3188
3189     application.GetScene().Add(imageView);
3190
3191     application.SendNotification();
3192
3193     // loading started, this waits for the loader thread - load & rasterize
3194     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3195
3196     application.SendNotification();
3197     application.Render(16);
3198
3199     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3200     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3201     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3202
3203     // Should be shown a broken image
3204     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3205     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3206   }
3207
3208   // Local svg file - invalid file
3209   {
3210     ToolkitTestApplication application;
3211
3212     TestGlAbstraction& gl           = application.GetGlAbstraction();
3213     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3214     textureTrace.Enable(true);
3215
3216     gResourceReadySignalFired = false;
3217     textureTrace.Reset();
3218
3219     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/invalid.svg");
3220     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3221     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3222
3223     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3224
3225     application.GetScene().Add(imageView);
3226
3227     application.SendNotification();
3228
3229     // loading started, this waits for the loader thread - load & rasterize
3230     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3231
3232     application.SendNotification();
3233     application.Render(16);
3234
3235     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3236     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3237     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3238
3239     // Should be shown a broken image
3240     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3241     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3242   }
3243
3244   END_TEST;
3245 }
3246
3247 int UtcDaliImageViewSvgLoadingFailureRemoteFile01(void)
3248 {
3249   // Remote svg file
3250   {
3251     ToolkitTestApplication application;
3252
3253     TestGlAbstraction& gl           = application.GetGlAbstraction();
3254     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3255     textureTrace.Enable(true);
3256
3257     gResourceReadySignalFired = false;
3258
3259     ImageView imageView = ImageView::New("https://127.0.0.1/foobar.svg");
3260     imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3261     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3262
3263     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3264
3265     application.GetScene().Add(imageView);
3266
3267     application.SendNotification();
3268
3269     // loading started, this waits for the loader thread - load & rasterize
3270     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3271
3272     application.SendNotification();
3273     application.Render(16);
3274
3275     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3276     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3277     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3278
3279     // Should be shown a broken image
3280     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3281     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3282   }
3283
3284   END_TEST;
3285 }
3286
3287 int UtcDaliImageViewSvgLoadingFailureRemoteFile02(void)
3288 {
3289   // Remote svg file without size set
3290   {
3291     ToolkitTestApplication application;
3292
3293     TestGlAbstraction& gl           = application.GetGlAbstraction();
3294     TraceCallStack&    textureTrace = gl.GetTextureTrace();
3295     textureTrace.Enable(true);
3296
3297     gResourceReadySignalFired = false;
3298
3299     ImageView imageView = ImageView::New("https://127.0.0.1/foobar.svg");
3300     imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3301
3302     DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3303
3304     application.GetScene().Add(imageView);
3305
3306     application.SendNotification();
3307
3308     // loading started, this waits for the loader thread - load & rasterize
3309     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3310
3311     application.SendNotification();
3312     application.Render(16);
3313
3314     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3315     DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3316     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3317
3318     // Should be shown a broken image
3319     DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3320     DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3321   }
3322
3323   END_TEST;
3324 }
3325
3326 int UtcDaliImageViewSvgRasterizationFailure(void)
3327 {
3328   ToolkitTestApplication application;
3329
3330   gResourceReadySignalFired = false;
3331
3332   TestGlAbstraction& gl           = application.GetGlAbstraction();
3333   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3334   textureTrace.Enable(true);
3335
3336   ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/invalid1.svg");
3337   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3338   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
3339
3340   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
3341
3342   application.GetScene().Add(imageView);
3343
3344   application.SendNotification();
3345
3346   // Wait for loading & rasterization
3347   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3348
3349   application.SendNotification();
3350   application.Render(16);
3351
3352   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
3353   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
3354   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
3355
3356   // Should be shown a broken image
3357   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
3358   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
3359
3360   END_TEST;
3361 }
3362
3363 int UtcDaliImageViewSvgChageSize(void)
3364 {
3365   ToolkitTestApplication application;
3366
3367   TestGlAbstraction& gl           = application.GetGlAbstraction();
3368   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3369   textureTrace.Enable(true);
3370
3371   ImageView imageView = ImageView::New(TEST_SVG_FILE_NAME);
3372   application.GetScene().Add(imageView);
3373
3374   application.SendNotification();
3375
3376   // Wait for loading & rasterization
3377   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3378
3379   application.SendNotification();
3380   application.Render(16);
3381
3382   DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
3383
3384   // Change actor size, then rasterization should be done again
3385   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3386
3387   application.SendNotification();
3388
3389   // Wait for rasterization
3390   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3391
3392   application.SendNotification();
3393   application.Render(16);
3394
3395   // We should not load the file again.
3396   DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
3397
3398   END_TEST;
3399 }
3400
3401 int UtcDaliImageViewSvgAtlasing(void)
3402 {
3403   ToolkitTestApplication application;
3404
3405   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
3406   callStack.Reset();
3407   callStack.Enable(true);
3408
3409   Property::Map propertyMap;
3410   propertyMap["url"]      = TEST_SVG_FILE_NAME;
3411   propertyMap["atlasing"] = true;
3412
3413   ImageView imageView = ImageView::New();
3414   imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
3415   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3416   application.GetScene().Add(imageView);
3417
3418   application.SendNotification();
3419
3420   // Wait for loading & rasterization
3421   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3422
3423   application.SendNotification();
3424   application.Render(16);
3425
3426   // use atlas
3427   TraceCallStack::NamedParams params1;
3428   params1["width"] << 100;
3429   params1["height"] << 100;
3430   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexSubImage2D", params1), true, TEST_LOCATION);
3431
3432   imageView.SetProperty(Actor::Property::SIZE, Vector2(600.f, 600.f));
3433
3434   application.SendNotification();
3435
3436   // Wait for rasterization
3437   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3438
3439   callStack.Reset();
3440
3441   application.SendNotification();
3442   application.Render(16);
3443
3444   // not use atlas
3445   TraceCallStack::NamedParams params2;
3446   params2["width"] << 600;
3447   params2["height"] << 600;
3448   DALI_TEST_EQUALS(callStack.FindMethodAndParams("TexImage2D", params2), true, TEST_LOCATION);
3449
3450   END_TEST;
3451 }
3452
3453 int UtcDaliImageViewTVGLoading(void)
3454 {
3455   ToolkitTestApplication application;
3456
3457   tet_infoline("ImageView Testing TVG image loading");
3458
3459   {
3460     ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/test.tvg");
3461     application.GetScene().Add(imageView);
3462     DALI_TEST_CHECK(imageView);
3463
3464     application.SendNotification();
3465
3466     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3467
3468     application.SendNotification();
3469     application.Render(16);
3470
3471     Vector3 naturalSize = imageView.GetNaturalSize();
3472
3473     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
3474     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
3475   }
3476   END_TEST;
3477 }
3478
3479 int UtcDaliImageViewSvgDesiredSize01(void)
3480 {
3481   ToolkitTestApplication application;
3482
3483   TestGlAbstraction& gl           = application.GetGlAbstraction();
3484   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3485   textureTrace.Enable(true);
3486
3487   int       desiredWidth = 100, desiredHeight = 150;
3488   ImageView imageView = ImageView::New(TEST_SVG_FILE_NAME, ImageDimensions(desiredWidth, desiredHeight));
3489
3490   application.GetScene().Add(imageView);
3491
3492   application.SendNotification();
3493
3494   // Wait for loading & rasterization
3495   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3496
3497   application.SendNotification();
3498   application.Render(16);
3499
3500   {
3501     std::stringstream out;
3502     out << GL_TEXTURE_2D << ", " << 0u << ", " << desiredWidth << ", " << desiredHeight;
3503     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
3504   }
3505
3506   END_TEST;
3507 }
3508
3509 int UtcDaliImageViewSvgDesiredSize02(void)
3510 {
3511   ToolkitTestApplication application;
3512
3513   TestGlAbstraction& gl           = application.GetGlAbstraction();
3514   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3515   textureTrace.Enable(true);
3516
3517   int       desiredWidth = 150, desiredHeight = 100;
3518   ImageView imageView                   = ImageView::New();
3519   imageView[ImageView::Property::IMAGE] = Property::Map().Add("url", TEST_SVG_FILE_NAME).Add("desiredWidth", desiredWidth).Add("desiredHeight", desiredHeight);
3520   application.GetScene().Add(imageView);
3521
3522   application.SendNotification();
3523
3524   // Wait for loading & rasterization
3525   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
3526
3527   application.SendNotification();
3528   application.Render(16);
3529
3530   {
3531     std::stringstream out;
3532     out << GL_TEXTURE_2D << ", " << 0u << ", " << desiredWidth << ", " << desiredHeight;
3533     DALI_TEST_CHECK(textureTrace.FindMethodAndParams("TexImage2D", out.str().c_str()));
3534   }
3535
3536   END_TEST;
3537 }
3538
3539 int UtcDaliImageViewImageLoadFailure01(void)
3540 {
3541   ToolkitTestApplication application;
3542
3543   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3544   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
3545   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
3546   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3547
3548   std::string brokenUrl;
3549   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3550   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_S, brokenUrl, TEST_LOCATION);
3551
3552   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3553   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_M, brokenUrl, TEST_LOCATION);
3554
3555   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3556   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3557
3558   ImageView imageView = ImageView::New("invalidUrl.png");
3559   imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3560
3561   application.GetScene().Add(imageView);
3562   application.SendNotification();
3563   application.Render(16);
3564
3565   // loading started, this waits for the loader thread
3566   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3567
3568   END_TEST;
3569 }
3570
3571 int UtcDaliImageViewImageLoadFailure02(void)
3572 {
3573   ToolkitTestApplication application;
3574
3575   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3576   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_DEFAULT);
3577   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
3578   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3579
3580   std::string brokenUrl;
3581   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3582   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_DEFAULT, brokenUrl, TEST_LOCATION);
3583
3584   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3585   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_M, brokenUrl, TEST_LOCATION);
3586
3587   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3588   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3589
3590   ImageView imageView = ImageView::New("invalidUrl.png");
3591   imageView.SetProperty(Actor::Property::SIZE, Vector2(30.f, 30.f));
3592   application.GetScene().Add(imageView);
3593   application.SendNotification();
3594   application.Render(16);
3595
3596   // loading started, this waits for the loader thread
3597   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3598
3599   END_TEST;
3600 }
3601
3602 int UtcDaliImageViewImageLoadFailure03(void)
3603 {
3604   ToolkitTestApplication application;
3605
3606   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3607   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_01);
3608   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_02);
3609
3610   std::string brokenUrl;
3611   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3612   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_01, brokenUrl, TEST_LOCATION);
3613
3614   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL);
3615   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_02, brokenUrl, TEST_LOCATION);
3616
3617   ImageView imageView = ImageView::New("invalidUrl.png");
3618   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3619   application.GetScene().Add(imageView);
3620   application.SendNotification();
3621   application.Render(16);
3622
3623   // loading started, this waits for the loader thread
3624   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3625
3626   END_TEST;
3627 }
3628
3629 int UtcDaliImageViewImageLoadFailure04(void)
3630 {
3631   ToolkitTestApplication application;
3632
3633   ImageView imageView = ImageView::New("invalidUrl.png");
3634   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3635   application.GetScene().Add(imageView);
3636   application.SendNotification();
3637   application.Render(16);
3638
3639   // loading started, this waits for the loader thread
3640   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3641
3642   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
3643   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
3644   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, "invalidBroken.png");
3645   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
3646
3647   ImageView imageView2 = ImageView::New("invalidUrl.png");
3648   imageView2.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3649   application.GetScene().Add(imageView2);
3650
3651   std::string brokenUrl;
3652   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL);
3653   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_S, brokenUrl, TEST_LOCATION);
3654
3655   brokenUrl = DevelStyleManager::GetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE);
3656   DALI_TEST_EQUALS(TEST_BROKEN_IMAGE_L, brokenUrl, TEST_LOCATION);
3657
3658   application.SendNotification();
3659   application.Render(16);
3660
3661   // loading started, this waits for the loader thread
3662   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3663
3664   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, "invalidBroken.9.png");
3665
3666   ImageView imageView3 = ImageView::New("invalidUrl.png");
3667   imageView3.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
3668   application.GetScene().Add(imageView3);
3669
3670   application.SendNotification();
3671   application.Render(16);
3672
3673   // loading started, this waits for the loader thread
3674   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3675
3676   END_TEST;
3677 }
3678
3679 namespace
3680 {
3681 static int gResourceReadySignalCounter = 0;
3682
3683 void OnResourceReadySignal01(Control control)
3684 {
3685   gResourceReadySignalCounter++;
3686
3687   if(control.GetVisualResourceStatus(ImageView::Property::IMAGE) == Visual::ResourceStatus::READY)
3688   {
3689     if(gResourceReadySignalCounter == 1)
3690     {
3691       // Set image twice
3692       // It makes the first new visual be deleted immediately
3693       ImageView::DownCast(control).SetImage(gImage_34_RGBA);
3694       ImageView::DownCast(control).SetImage(gImage_34_RGBA);
3695     }
3696   }
3697   else if(control.GetVisualResourceStatus(ImageView::Property::IMAGE) == Visual::ResourceStatus::FAILED)
3698   {
3699     // Make the resource ready immediately
3700     control[ImageView::Property::IMAGE] = gImage_600_RGB;
3701   }
3702 }
3703
3704 void OnResourceReadySignal02(Control control)
3705 {
3706   if(++gResourceReadySignalCounter == 1)
3707   {
3708     // It makes the first new visual be deleted immediately
3709     // The first image will not be loaded.
3710     control[ImageView::Property::IMAGE] = Property::Map().Add(ImageVisual::Property::URL, gImage_600_RGB).Add(ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER);
3711     control[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3712   }
3713 }
3714
3715 ImageView gImageView1;
3716 ImageView gImageView2;
3717 ImageView gImageView3;
3718 ImageView gImageView4;
3719
3720 void OnResourceReadySignal03(Control control)
3721 {
3722   if(gResourceReadySignalCounter == 0)
3723   {
3724     // Queue loading
3725     // 1. Use cached image, then LoadComplete will be called right after OnResourceReadySignal03.
3726     gImageView2[ImageView::Property::IMAGE] = gImage_34_RGBA;
3727
3728     // 2. Load a new image
3729     gImageView3[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3730
3731     // 3. Use the new image again
3732     gImageView1[ImageView::Property::IMAGE] = TEST_IMAGE_1;
3733     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal03);
3734   }
3735   else if(gResourceReadySignalCounter == 1)
3736   {
3737     // This is called from TextureManager::ProcessQueuedTextures().
3738     gImageView1.Unparent();
3739     gImageView1.Reset();
3740   }
3741   gResourceReadySignalCounter++;
3742 }
3743
3744 void OnSimpleResourceReadySignal(Control control)
3745 {
3746   // simply increate counter
3747   gResourceReadySignalCounter++;
3748 }
3749
3750 int gResourceReadySignal04ComesOrder = 0;
3751
3752 void OnResourceReadySignal04(Control control)
3753 {
3754   gResourceReadySignalCounter++;
3755   tet_printf("rc %d\n", gResourceReadySignalCounter);
3756   if(gResourceReadySignalCounter == 1)
3757   {
3758     auto scene = gImageView1.GetParent();
3759
3760     // Request load something
3761     // We hope this request result is return later than gImageView2.
3762     gImageView3 = ImageView::New(TEST_IMAGE_1);
3763     gImageView3.ResourceReadySignal().Connect(&OnResourceReadySignal04);
3764     scene.Add(gImageView3);
3765     gImageView4 = ImageView::New(TEST_IMAGE_2);
3766     gImageView4.ResourceReadySignal().Connect(&OnResourceReadySignal04);
3767     scene.Add(gImageView4);
3768
3769     if(control == gImageView1)
3770     {
3771       gResourceReadySignal04ComesOrder = 1;
3772     }
3773     else
3774     {
3775       gResourceReadySignal04ComesOrder = 2;
3776     }
3777   }
3778   if(gResourceReadySignalCounter == 2)
3779   {
3780     if(gResourceReadySignal04ComesOrder == 1 && control == gImageView2)
3781     {
3782       // Scene off first one.
3783       gImageView1.Unparent();
3784
3785       // Scene off second one.
3786       gImageView2.Unparent();
3787     }
3788     else if(gResourceReadySignal04ComesOrder == 2 && control == gImageView1)
3789     {
3790       // Scene off first one.
3791       gImageView2.Unparent();
3792
3793       // Scene off second one.
3794       gImageView1.Unparent();
3795     }
3796     else
3797     {
3798       // We can't check that this utc fail case. just pass always when we come here.
3799       gResourceReadySignal04ComesOrder = -1;
3800     }
3801
3802     // If we don't seperate index of FreeList area
3803     // and if we don't queue remove during obversing,
3804     // cache index become something invalid data.
3805     // In this case, some strange observer can be called.
3806     // For example, gImageView4.LoadComplete will be called.
3807   }
3808 }
3809
3810 void OnResourceReadySignal05(Control control)
3811 {
3812   gResourceReadySignalCounter++;
3813
3814   // Request load with same image
3815   // NOTE : The url must not be same as gImageView1
3816   const int viewCount = 4;
3817   for(int i = 0; i < viewCount; ++i)
3818   {
3819     gImageView1.Add(ImageView::New("invalid2.jpg"));
3820   }
3821 }
3822
3823 int gResourceReadySignal06ComesOrder = 0;
3824
3825 void OnResourceReadySignal06(Control control)
3826 {
3827   gResourceReadySignalCounter++;
3828   if(gResourceReadySignalCounter == 1)
3829   {
3830     auto scene = gImageView1.GetParent();
3831
3832     // Request load something
3833     // We hope this request result is return later than gImageView2.
3834
3835     Property::Map map1;
3836     map1[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_1;
3837     map1[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
3838
3839     gImageView3 = ImageView::New();
3840     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3841     gImageView3.ResourceReadySignal().Connect(&OnResourceReadySignal06);
3842
3843     Property::Map map2;
3844     map2[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_2;
3845     map2[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_S;
3846     gImageView4                                          = ImageView::New();
3847     gImageView4.SetProperty(Toolkit::ImageView::Property::IMAGE, map2);
3848     gImageView4.ResourceReadySignal().Connect(&OnResourceReadySignal06);
3849
3850     if(control == gImageView1)
3851     {
3852       gResourceReadySignal06ComesOrder = 1;
3853     }
3854     else
3855     {
3856       gResourceReadySignal06ComesOrder = 2;
3857     }
3858   }
3859   if(gResourceReadySignalCounter == 2)
3860   {
3861     if(gResourceReadySignal06ComesOrder == 1 && control == gImageView2)
3862     {
3863       // Scene off first one.
3864       gImageView1.Unparent();
3865
3866       // Scene off second one.
3867       gImageView2.Unparent();
3868     }
3869     else if(gResourceReadySignal06ComesOrder == 2 && control == gImageView1)
3870     {
3871       // Scene off first one.
3872       gImageView2.Unparent();
3873
3874       // Scene off second one.
3875       gImageView1.Unparent();
3876     }
3877     else
3878     {
3879       // We can't check that this utc fail case. just pass always when we come here.
3880       gResourceReadySignal06ComesOrder = -1;
3881     }
3882
3883     // If we don't seperate index of FreeList area
3884     // and if we don't queue remove during obversing,
3885     // cache index become something invalid data.
3886     // In this case, some strange observer can be called.
3887     // For example, gImageView4.LoadComplete will be called.
3888   }
3889 }
3890
3891 void OnResourceReadySignal07(Control control)
3892 {
3893   gResourceReadySignalCounter++;
3894   // Load masked image
3895   tet_printf("rc %d %d\n", gResourceReadySignalCounter, static_cast<bool>(gImageView2));
3896
3897   if(!gImageView2)
3898   {
3899     auto scene = gImageView1.GetParent();
3900
3901     Property::Map map1;
3902     map1[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_1;
3903     map1[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = TEST_BROKEN_IMAGE_DEFAULT;
3904
3905     gImageView2 = ImageView::New();
3906     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3907     gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal07);
3908
3909     scene.Add(gImageView2);
3910   }
3911 }
3912
3913 void OnResourceReadySignal08(Control control)
3914 {
3915   gResourceReadySignalCounter++;
3916
3917   if(gImageView1)
3918   {
3919     gImageView1.Unparent();
3920     gImageView1.Reset();
3921   }
3922   if(gImageView2)
3923   {
3924     gImageView2.Unparent();
3925     gImageView2.Reset();
3926   }
3927 }
3928
3929 std::size_t gResourceReadySignal09Emitted = false;
3930
3931 void OnResourceReadySignal09(Control control)
3932 {
3933   gResourceReadySignalCounter++;
3934
3935   if(gImageView1 && !gResourceReadySignal09Emitted)
3936   {
3937     gResourceReadySignal09Emitted = true;
3938     gImageView1.ResourceReadySignal().Disconnect(&OnResourceReadySignal09);
3939
3940     // Try to load cached invalid nine patch image. It will request load now.
3941     gImageView1.SetImage(TEST_INVALID_NPATCH_FILE_NAME_01);
3942     gImageView2.SetImage(TEST_INVALID_NPATCH_FILE_NAME_01);
3943
3944     // Destroy all visuals immediatly.
3945     gImageView1.Unparent();
3946     gImageView1.Reset();
3947     gImageView2.Unparent();
3948     gImageView2.Reset();
3949   }
3950 }
3951 constexpr int gResourceReadySignal10MaxCounter = 5;
3952
3953 void OnResourceReadySignal10(Control control)
3954 {
3955   gResourceReadySignalCounter++;
3956
3957   tet_printf("OnResourceReadySignal10 comes!\n");
3958   if(gResourceReadySignalCounter < gResourceReadySignal10MaxCounter)
3959   {
3960     tet_printf("OnResourceReadySignal10 Set image\n");
3961     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
3962     tet_printf("OnResourceReadySignal10 Set image done\n");
3963   }
3964 }
3965
3966 void OnResourceReadySignal11(Control control)
3967 {
3968   gResourceReadySignalCounter++;
3969
3970   if(!gImageView2)
3971   {
3972     auto scene = gImageView1.GetParent();
3973
3974     // Try to load animated image visual here which is already cached, and then ignore forcely.
3975
3976     Property::Map map1;
3977     map1[Toolkit::ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
3978
3979     gImageView2 = ImageView::New();
3980     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3981
3982     gImageView3 = ImageView::New();
3983     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map1);
3984
3985     scene.Add(gImageView2);
3986     gImageView2.Unparent();
3987
3988     scene.Add(gImageView3);
3989     gImageView3.Unparent();
3990     gImageView3.Reset(); // Destroy visual
3991   }
3992 }
3993
3994 } // namespace
3995
3996 int UtcDaliImageViewSetImageOnResourceReadySignal01(void)
3997 {
3998   tet_infoline("Test setting image from within signal handler.");
3999
4000   ToolkitTestApplication application;
4001
4002   gResourceReadySignalCounter = 0;
4003
4004   ImageView imageView = ImageView::New(gImage_34_RGBA);
4005   imageView.ResourceReadySignal().Connect(&OnResourceReadySignal01);
4006
4007   application.GetScene().Add(imageView);
4008
4009   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4010
4011   application.SendNotification();
4012   application.Render();
4013
4014   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4015
4016   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4017
4018   // Create a new ImageView to cache the image
4019   ImageView imageView1 = ImageView::New(gImage_600_RGB);
4020   application.GetScene().Add(imageView1);
4021
4022   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4023
4024   application.SendNotification();
4025   application.Render();
4026
4027   // Reset count
4028   gResourceReadySignalCounter = 0;
4029
4030   imageView[ImageView::Property::IMAGE] = "invalid.jpg";
4031
4032   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4033
4034   application.SendNotification();
4035   application.Render();
4036
4037   // Run idle callback
4038   application.RunIdles();
4039
4040   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4041
4042   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4043
4044   END_TEST;
4045 }
4046
4047 int UtcDaliImageViewSetImageOnResourceReadySignal02(void)
4048 {
4049   tet_infoline("Test setting image from within signal handler.");
4050
4051   ToolkitTestApplication application;
4052
4053   gResourceReadySignalCounter = 0;
4054
4055   ImageView imageView = ImageView::New(gImage_34_RGBA);
4056   imageView.ResourceReadySignal().Connect(&OnResourceReadySignal02);
4057
4058   application.GetScene().Add(imageView);
4059
4060   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4061
4062   application.SendNotification();
4063   application.Render();
4064
4065   // Wait for loading an image
4066   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4067
4068   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4069
4070   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
4071
4072   END_TEST;
4073 }
4074
4075 int UtcDaliImageViewSetImageOnResourceReadySignal03(void)
4076 {
4077   tet_infoline("Test setting image from within signal handler.");
4078
4079   ToolkitTestApplication application;
4080
4081   gResourceReadySignalCounter = 0;
4082
4083   gImageView1 = ImageView::New(gImage_34_RGBA);
4084   application.GetScene().Add(gImageView1);
4085
4086   // Wait for loading
4087   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4088
4089   gImageView2 = ImageView::New(gImage_600_RGB);
4090   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal03);
4091   application.GetScene().Add(gImageView2);
4092
4093   gImageView3 = ImageView::New();
4094   application.GetScene().Add(gImageView3);
4095
4096   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4097
4098   application.SendNotification();
4099   application.Render();
4100
4101   END_TEST;
4102 }
4103
4104 int UtcDaliImageViewOnResourceReadySignalWithBrokenAlphaMask01(void)
4105 {
4106   tet_infoline("Test signal handler when image / mask image is broken.");
4107
4108   ToolkitTestApplication application;
4109
4110   auto TestResourceReadyUrl = [&application](int eventTriggerCount, bool isSynchronous, const std::string& url, const std::string& mask, const char* location) {
4111     gResourceReadySignalCounter = 0;
4112
4113     Property::Map map;
4114     map[Toolkit::ImageVisual::Property::URL] = url;
4115     if(!mask.empty())
4116     {
4117       map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = mask;
4118     }
4119     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = isSynchronous;
4120
4121     ImageView imageView                            = ImageView::New();
4122     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4123     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4124     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4125
4126     application.GetScene().Add(imageView);
4127     application.SendNotification();
4128     application.Render();
4129
4130     if(!isSynchronous)
4131     {
4132       // Wait for loading
4133       DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(eventTriggerCount), true, location);
4134     }
4135     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4136     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4137
4138     imageView.Unparent();
4139   };
4140
4141   for(int synchronous = 0; synchronous <= 1; synchronous++)
4142   {
4143     tet_printf("Test normal case (sync:%d)\n", synchronous);
4144     TestResourceReadyUrl(1, synchronous, gImage_600_RGB, "", TEST_LOCATION);
4145     TestResourceReadyUrl(3, synchronous, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION); // 3 event trigger required : 2 image load + 1 apply mask
4146
4147     tet_printf("Test broken image case (sync:%d)\n", synchronous);
4148     TestResourceReadyUrl(1, synchronous, "invalid.jpg", "", TEST_LOCATION);
4149     TestResourceReadyUrl(2, synchronous, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION);
4150
4151     tet_printf("Test broken mask image case (sync:%d)\n", synchronous);
4152     TestResourceReadyUrl(2, synchronous, gImage_600_RGB, "invalid.png", TEST_LOCATION);
4153
4154     tet_printf("Test broken both image, mask image case (sync:%d)\n", synchronous);
4155     TestResourceReadyUrl(2, synchronous, "invalid.jpg", "invalid.png", TEST_LOCATION);
4156   }
4157
4158   END_TEST;
4159 }
4160
4161 int UtcDaliImageViewOnResourceReadySignalWithBrokenAlphaMask02(void)
4162 {
4163   tet_infoline("Test signal handler when image try to use cached-and-broken mask image.");
4164
4165   ToolkitTestApplication application;
4166
4167   gResourceReadySignalCounter = 0;
4168
4169   auto TestBrokenMaskResourceReadyUrl = [&application](const std::string& url, const char* location) {
4170     Property::Map map;
4171     map[Toolkit::ImageVisual::Property::URL] = url;
4172     // Use invalid mask url
4173     map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = "invalid.png";
4174
4175     ImageView imageView                            = ImageView::New();
4176     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4177     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4178     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4179
4180     application.GetScene().Add(imageView);
4181
4182     // Don't unparent imageView, for keep the cache.
4183   };
4184
4185   // Use more than 4 images (The number of LocalImageLoadThread)
4186   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};
4187
4188   int expectResourceReadySignalCounter = 0;
4189
4190   for(auto& url : testUrlList)
4191   {
4192     TestBrokenMaskResourceReadyUrl(url, TEST_LOCATION);
4193     expectResourceReadySignalCounter++;
4194   }
4195
4196   // Remain 1 signal due to we use #URL + 1 mask image.
4197   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(expectResourceReadySignalCounter + 1), true, TEST_LOCATION);
4198   application.SendNotification();
4199   application.Render();
4200   DALI_TEST_EQUALS(gResourceReadySignalCounter, expectResourceReadySignalCounter, TEST_LOCATION);
4201
4202   END_TEST;
4203 }
4204
4205 int UtcDaliImageViewCheckVariousCaseSendOnResourceReadySignal(void)
4206 {
4207   tet_infoline("Test signal handler various case.");
4208
4209   auto TestResourceReadyUrl = [](int eventTriggerCount, bool isSynchronous, bool loadSuccess, const std::string& url, const std::string& mask, const char* location) {
4210     ToolkitTestApplication application;
4211
4212     gResourceReadySignalCounter = 0;
4213
4214     Property::Map map;
4215     map[Toolkit::ImageVisual::Property::URL] = url;
4216     if(!mask.empty())
4217     {
4218       map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = mask;
4219     }
4220     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = isSynchronous;
4221
4222     ImageView imageView                            = ImageView::New();
4223     imageView[Toolkit::ImageView::Property::IMAGE] = map;
4224     imageView[Actor::Property::SIZE]               = Vector2(100.0f, 200.0f);
4225     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4226
4227     application.GetScene().Add(imageView);
4228     application.SendNotification();
4229     application.Render();
4230
4231     // Wait for loading
4232     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(eventTriggerCount), true, location);
4233
4234     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4235     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4236     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(Toolkit::ImageView::Property::IMAGE), loadSuccess ? Toolkit::Visual::ResourceStatus::READY : Toolkit::Visual::ResourceStatus::FAILED, location);
4237
4238     imageView.Unparent();
4239   };
4240
4241   auto TestAuxiliaryResourceReadyUrl = [](bool isSynchronous, bool loadSuccess, const std::string& url, const std::string& auxiliaryUrl, const char* location) {
4242     ToolkitTestApplication application;
4243
4244     gResourceReadySignalCounter = 0;
4245
4246     Property::Map map;
4247     map[Toolkit::ImageVisual::Property::URL]                        = url;
4248     map[Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE]       = auxiliaryUrl;
4249     map[Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA] = 0.5f;
4250     map[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING]        = isSynchronous;
4251
4252     ImageView imageView = ImageView::New();
4253     imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4254     imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
4255     imageView.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4256     application.GetScene().Add(imageView);
4257
4258     application.SendNotification();
4259     application.Render();
4260
4261     if(!isSynchronous)
4262     {
4263       // Wait for loading
4264       DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, location);
4265     }
4266
4267     tet_printf("test %s [sync:%d] signal fired\n", url.c_str(), isSynchronous ? 1 : 0);
4268     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, location);
4269     DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(Toolkit::ImageView::Property::IMAGE), loadSuccess ? Toolkit::Visual::ResourceStatus::READY : Toolkit::Visual::ResourceStatus::FAILED, TEST_LOCATION);
4270
4271     imageView.Unparent();
4272   };
4273
4274   // Case 1 : asynchronous loading
4275   tet_printf("Test invalid single simple image Asynchronous\n");
4276
4277   // Test normal case
4278   TestResourceReadyUrl(1, 0, 1, gImage_600_RGB, "", TEST_LOCATION);
4279   TestResourceReadyUrl(2, 0, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // load & rasterize
4280   TestResourceReadyUrl(1, 0, 1, TEST_BROKEN_IMAGE_L, "", TEST_LOCATION);
4281
4282   TestResourceReadyUrl(2, 0, 1, TEST_GIF_FILE_NAME, "", TEST_LOCATION);                   // 2 image loading - batch size
4283   TestResourceReadyUrl(2, 0, 1, TEST_ANIMATED_VECTOR_IMAGE_FILE_NAME, "", TEST_LOCATION); // load & rasterize
4284
4285   TestResourceReadyUrl(3, 0, 1, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION); // 2 image loading + 1 applymask
4286
4287   TestAuxiliaryResourceReadyUrl(0, 1, TEST_BROKEN_IMAGE_L, gImage_34_RGBA, TEST_LOCATION);
4288
4289   // Test broken case
4290   TestResourceReadyUrl(1, 0, 0, "invalid.jpg", "", TEST_LOCATION);
4291   TestResourceReadyUrl(1, 0, 0, "invalid.svg", "", TEST_LOCATION);
4292   TestResourceReadyUrl(1, 0, 0, "invalid.9.png", "", TEST_LOCATION);
4293   TestResourceReadyUrl(1, 0, 0, "invalid.gif", "", TEST_LOCATION);  // 1 image loading
4294   TestResourceReadyUrl(1, 0, 0, "invalid.json", "", TEST_LOCATION); // 0 rasterize
4295
4296   TestResourceReadyUrl(2, 0, 0, "invalid.jpg", "invalid.png", TEST_LOCATION);  // 2 image loading
4297   TestResourceReadyUrl(2, 0, 1, gImage_600_RGB, "invalid.png", TEST_LOCATION); // 2 image loading
4298   TestResourceReadyUrl(2, 0, 0, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION); // 2 image loading
4299
4300   TestAuxiliaryResourceReadyUrl(0, 0, "invalid.9.png", "invalid.png", TEST_LOCATION);
4301   TestAuxiliaryResourceReadyUrl(0, 1, TEST_BROKEN_IMAGE_L, "invalid.png", TEST_LOCATION);
4302   TestAuxiliaryResourceReadyUrl(0, 0, "invalid.9.png", gImage_34_RGBA, TEST_LOCATION);
4303
4304   // Case 2 : Synchronous loading
4305   tet_printf("Test invalid single simple image Synchronous\n");
4306
4307   // Test normal case
4308   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, "", TEST_LOCATION);
4309   TestResourceReadyUrl(0, 1, 1, TEST_SVG_FILE_NAME, "", TEST_LOCATION); // synchronous rasterize
4310   TestResourceReadyUrl(0, 1, 1, TEST_BROKEN_IMAGE_L, "", TEST_LOCATION);
4311
4312   TestResourceReadyUrl(1, 1, 1, TEST_GIF_FILE_NAME, "", TEST_LOCATION); // first frame image loading sync + second frame image loading async
4313
4314   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, gImage_34_RGBA, TEST_LOCATION);
4315
4316   TestAuxiliaryResourceReadyUrl(1, 1, TEST_BROKEN_IMAGE_L, gImage_34_RGBA, TEST_LOCATION);
4317
4318   // Test broken case
4319   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", "", TEST_LOCATION);
4320   TestResourceReadyUrl(0, 1, 0, "invalid.svg", "", TEST_LOCATION);
4321   TestResourceReadyUrl(0, 1, 0, "invalid.9.png", "", TEST_LOCATION);
4322   TestResourceReadyUrl(0, 1, 0, "invalid.gif", "", TEST_LOCATION);
4323
4324   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", "invalid.png", TEST_LOCATION);
4325   TestResourceReadyUrl(0, 1, 1, gImage_600_RGB, "invalid.png", TEST_LOCATION);
4326   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", gImage_34_RGBA, TEST_LOCATION);
4327
4328   TestAuxiliaryResourceReadyUrl(1, 0, "invalid.9.png", "invalid.png", TEST_LOCATION);
4329   TestAuxiliaryResourceReadyUrl(1, 1, TEST_BROKEN_IMAGE_L, "invalid.png", TEST_LOCATION);
4330   TestAuxiliaryResourceReadyUrl(1, 0, "invalid.9.png", gImage_34_RGBA, TEST_LOCATION);
4331
4332   END_TEST;
4333 }
4334
4335 int UtcDaliImageViewSetImageOnResourceReadySignal04(void)
4336 {
4337   tet_infoline("Test texturemanager's remove queue works well within signal handler.");
4338
4339   ToolkitTestApplication application;
4340
4341   gResourceReadySignalCounter      = 0;
4342   gResourceReadySignal04ComesOrder = 0;
4343
4344   gImageView1 = ImageView::New("invalid.jpg"); // request invalid image, to make loading failed fast.
4345   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal04);
4346   application.GetScene().Add(gImageView1);
4347
4348   gImageView2 = ImageView::New("invalid.png"); // request invalid image, to make loading failed fast.
4349   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal04);
4350   application.GetScene().Add(gImageView2);
4351
4352   application.SendNotification();
4353   application.Render();
4354
4355   tet_infoline("Try to load 2 invalid image");
4356
4357   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4358   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4359
4360   tet_infoline("load done");
4361
4362   // We can test this UTC only if gImageView1 and gImageView2 loaded done.
4363   if(gResourceReadySignal04ComesOrder == -1)
4364   {
4365     tet_infoline("Bad news.. gImageView3 or gImageView4 loaded faster than others. just skip this UTC");
4366   }
4367   else
4368   {
4369     // gImageView3 and gImageView4 load must not be successed yet.
4370     DALI_TEST_EQUALS(gImageView3.GetRendererCount(), 0u, TEST_LOCATION);
4371     DALI_TEST_EQUALS(gImageView4.GetRendererCount(), 0u, TEST_LOCATION);
4372
4373     application.SendNotification();
4374     application.Render();
4375
4376     tet_infoline("Try to load 2 valid image");
4377
4378     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4379     DALI_TEST_EQUALS(gResourceReadySignalCounter, 4, TEST_LOCATION);
4380
4381     tet_infoline("load done");
4382
4383     // gImageView3 and gImageView4 load must be successed now.
4384     DALI_TEST_EQUALS(gImageView3.GetRendererAt(0).GetTextures().GetTextureCount(), 1u, TEST_LOCATION);
4385     DALI_TEST_EQUALS(gImageView4.GetRendererAt(0).GetTextures().GetTextureCount(), 1u, TEST_LOCATION);
4386   }
4387
4388   END_TEST;
4389 }
4390 int UtcDaliImageViewSetImageOnResourceReadySignal05(void)
4391 {
4392   tet_infoline("Test multiple views with same image during ResourceReady load the image only 1 times");
4393
4394   ToolkitTestApplication application;
4395
4396   gResourceReadySignalCounter = 0;
4397
4398   gImageView1 = ImageView::New("invalid.jpg"); // request invalid image, to make loading failed fast.
4399   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal05);
4400   application.GetScene().Add(gImageView1);
4401
4402   application.SendNotification();
4403   application.Render();
4404
4405   tet_infoline("Try to load 1 invalid.jpg image");
4406   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4407   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4408
4409   tet_infoline("Try to load 1 invalid2.jpg image");
4410   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4411
4412   tet_infoline("Now we don't have any image to be loaded. Check event thread trigger failed.");
4413   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, 1), false, TEST_LOCATION);
4414
4415   gImageView1.Unparent();
4416   gImageView1.Reset();
4417
4418   END_TEST;
4419 }
4420 int UtcDaliImageViewSetImageOnResourceReadySignal06(void)
4421 {
4422   tet_infoline("Test texturemanager's remove image & mask queue works well within signal handler.");
4423
4424   ToolkitTestApplication application;
4425
4426   gResourceReadySignalCounter      = 0;
4427   gResourceReadySignal06ComesOrder = 0;
4428
4429   Property::Map map;
4430   map[Toolkit::ImageVisual::Property::URL]            = "invalid.jpg";
4431   map[Toolkit::ImageVisual::Property::ALPHA_MASK_URL] = "invalid.png";
4432
4433   gImageView1 = ImageView::New(); // request invalid image, to make loading failed fast.
4434   gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4435   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal06);
4436   application.GetScene().Add(gImageView1);
4437
4438   gImageView2 = ImageView::New(); // request invalid image, to make loading failed fast.
4439   gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4440   gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal06);
4441   application.GetScene().Add(gImageView2);
4442
4443   application.SendNotification();
4444   application.Render();
4445
4446   tet_infoline("Try to load 2 invalid image");
4447
4448   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4449   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4450
4451   tet_infoline("load done");
4452
4453   // We can test this UTC only if gImageView1 and gImageView2 loaded done.
4454   if(gResourceReadySignal06ComesOrder == -1)
4455   {
4456     tet_infoline("Bad news.. gImageView3 or gImageView4 loaded faster than others. just skip this UTC");
4457   }
4458   else
4459   {
4460     // gImageView3 and gImageView4 load must not be successed yet.
4461     DALI_TEST_EQUALS(gImageView3.GetRendererCount(), 0u, TEST_LOCATION);
4462     DALI_TEST_EQUALS(gImageView4.GetRendererCount(), 0u, TEST_LOCATION);
4463
4464     application.GetScene().Add(gImageView3);
4465     application.GetScene().Add(gImageView4);
4466     application.SendNotification();
4467     application.Render();
4468
4469     tet_infoline("Try to load 2 valid image");
4470
4471     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4472     DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4473
4474     tet_infoline("Note that resource ready should not come now.");
4475     tet_infoline("Try to load remained 2 valid image + apply masking");
4476
4477     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(4), true, TEST_LOCATION);
4478     DALI_TEST_EQUALS(gResourceReadySignalCounter, 4, TEST_LOCATION);
4479
4480     tet_infoline("Check all resource ready comes now.");
4481   }
4482   END_TEST;
4483 }
4484
4485 int UtcDaliImageViewSetImageOnResourceReadySignal07(void)
4486 {
4487   tet_infoline("Test texturemanager's remove image & mask queue works well within signal handler 02.");
4488
4489   ToolkitTestApplication application;
4490
4491   gResourceReadySignalCounter = 0;
4492
4493   Property::Map map;
4494   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
4495
4496   // Clear image view for clear test
4497
4498   if(gImageView1)
4499   {
4500     gImageView1.Reset();
4501   }
4502   if(gImageView2)
4503   {
4504     gImageView2.Reset();
4505   }
4506
4507   gImageView1 = ImageView::New();
4508   gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4509   gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal07);
4510   application.GetScene().Add(gImageView1);
4511
4512   application.SendNotification();
4513   application.Render();
4514
4515   // Load gImageView1
4516
4517   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4518   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4519
4520   tet_infoline("load image1 done");
4521
4522   // Load gImageView2 and mask
4523
4524   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
4525   DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4526
4527   // gImageView2 mask apply done
4528
4529   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4530   DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4531
4532   tet_infoline("load image2 done");
4533   END_TEST;
4534 }
4535
4536 int UtcDaliImageViewSetImageOnResourceReadySignal08(void)
4537 {
4538   tet_infoline("Test remove npatch images during resource ready");
4539
4540   ToolkitTestApplication application;
4541
4542   gResourceReadySignalCounter = 0;
4543
4544   Property::Map map;
4545   map[Toolkit::ImageVisual::Property::URL] = TEST_BROKEN_IMAGE_M;
4546
4547   // Clear image view for clear test
4548
4549   if(gImageView1)
4550   {
4551     gImageView1.Reset();
4552   }
4553   if(gImageView2)
4554   {
4555     gImageView2.Reset();
4556   }
4557
4558   // Case 1 : Remove all images during resource ready.
4559   try
4560   {
4561     gImageView1 = ImageView::New();
4562     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4563     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal08);
4564     application.GetScene().Add(gImageView1);
4565
4566     application.SendNotification();
4567     application.Render();
4568
4569     // Load gImageView1
4570     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4571     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4572
4573     application.SendNotification();
4574     application.Render();
4575
4576     DALI_TEST_CHECK(true);
4577   }
4578   catch(...)
4579   {
4580     // Exception should not happened
4581     DALI_TEST_CHECK(false);
4582   }
4583
4584   // Clear cache.
4585   application.SendNotification();
4586   application.Render();
4587
4588   gResourceReadySignalCounter = 0;
4589
4590   // Case 2 : Remove all images when we use cached resource.
4591   try
4592   {
4593     gImageView1 = ImageView::New();
4594     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4595     gImageView1.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4596     application.GetScene().Add(gImageView1);
4597
4598     application.SendNotification();
4599     application.Render();
4600
4601     // Load gImageView1
4602     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4603     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4604
4605     application.SendNotification();
4606     application.Render();
4607
4608     gImageView2 = ImageView::New();
4609     gImageView2.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4610     gImageView2.ResourceReadySignal().Connect(&OnResourceReadySignal08);
4611     application.GetScene().Add(gImageView2);
4612     DALI_TEST_EQUALS(gResourceReadySignalCounter, 2, TEST_LOCATION);
4613
4614     application.SendNotification();
4615     application.Render();
4616
4617     DALI_TEST_CHECK(true);
4618   }
4619   catch(...)
4620   {
4621     // Exception should not happened
4622     DALI_TEST_CHECK(false);
4623   }
4624   gResourceReadySignalCounter = 0;
4625
4626   // Clear image view for clear test
4627
4628   if(gImageView1)
4629   {
4630     gImageView1.Reset();
4631   }
4632   if(gImageView2)
4633   {
4634     gImageView2.Reset();
4635   }
4636
4637   END_TEST;
4638 }
4639
4640 int UtcDaliImageViewSetImageOnResourceReadySignal09(void)
4641 {
4642   tet_infoline("Test load invalid npatch images during invalid resource ready");
4643
4644   ToolkitTestApplication application;
4645
4646   gResourceReadySignalCounter = 0;
4647
4648   Property::Map map;
4649   map[Toolkit::ImageVisual::Property::URL] = TEST_INVALID_NPATCH_FILE_NAME_01;
4650
4651   // Clear image view for clear test
4652
4653   if(gImageView1)
4654   {
4655     gImageView1.Reset();
4656   }
4657   if(gImageView2)
4658   {
4659     gImageView2.Reset();
4660   }
4661   if(gImageView3)
4662   {
4663     gImageView3.Reset();
4664   }
4665
4666   // Dummy view with npatch image
4667   ImageView dummyView = ImageView::New(TEST_BROKEN_IMAGE_M);
4668   application.GetScene().Add(dummyView);
4669
4670   application.SendNotification();
4671   application.Render();
4672   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4673   application.SendNotification();
4674   application.Render();
4675
4676   // Case 1 : Reload images during resource ready.
4677   try
4678   {
4679     gResourceReadySignal09Emitted = false;
4680
4681     gImageView1 = ImageView::New();
4682     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4683     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal09);
4684     application.GetScene().Add(gImageView1);
4685
4686     gImageView2 = ImageView::New();
4687     application.GetScene().Add(gImageView2);
4688
4689     // Load TEST_INVALID_NPATCH_FILE_NAME_01
4690     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4691
4692     // Load TEST_INVALID_NPATCH_FILE_NAME_01 one more times.
4693     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4694
4695     application.SendNotification();
4696     application.Render();
4697
4698     DALI_TEST_CHECK(true);
4699   }
4700   catch(...)
4701   {
4702     // Exception should not happened
4703     DALI_TEST_CHECK(false);
4704   }
4705
4706   // Clear cache.
4707   application.SendNotification();
4708   application.Render();
4709
4710   gResourceReadySignalCounter = 0;
4711
4712   // Case 2 : Remove all images when we use cached resource.
4713   try
4714   {
4715     gResourceReadySignal09Emitted = false;
4716
4717     gImageView3 = ImageView::New();
4718     gImageView3.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4719     gImageView3.ResourceReadySignal().Connect(&OnSimpleResourceReadySignal);
4720     application.GetScene().Add(gImageView3);
4721
4722     gImageView2 = ImageView::New();
4723     application.GetScene().Add(gImageView2);
4724
4725     // Load gImageView2
4726     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4727
4728     gImageView1 = ImageView::New();
4729     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
4730     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal09);
4731     application.GetScene().Add(gImageView1);
4732
4733     // Load gImageView1
4734     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4735
4736     // Load TEST_INVALID_NPATCH_FILE_NAME_01 one more times.
4737     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4738
4739     application.SendNotification();
4740     application.Render();
4741
4742     DALI_TEST_CHECK(true);
4743   }
4744   catch(...)
4745   {
4746     // Exception should not happened
4747     DALI_TEST_CHECK(false);
4748   }
4749   gResourceReadySignalCounter = 0;
4750
4751   // Clear image view for clear test
4752
4753   if(gImageView1)
4754   {
4755     gImageView1.Reset();
4756   }
4757   if(gImageView2)
4758   {
4759     gImageView2.Reset();
4760   }
4761   if(gImageView3)
4762   {
4763     gImageView3.Reset();
4764   }
4765
4766   END_TEST;
4767 }
4768
4769 int UtcDaliImageViewSetImageOnResourceReadySignal10(void)
4770 {
4771   tet_infoline("Test ResourceReady signal comes more than 2 times.");
4772
4773   ToolkitTestApplication application;
4774
4775   gResourceReadySignalCounter = 0;
4776
4777   // Clear image view for clear test
4778
4779   if(gImageView1)
4780   {
4781     gImageView1.Reset();
4782   }
4783
4784   // Dummy view to cache image.
4785   ImageView dummyView = ImageView::New(gImage_34_RGBA);
4786   application.GetScene().Add(dummyView);
4787
4788   application.SendNotification();
4789   application.Render();
4790   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4791   application.SendNotification();
4792   application.Render();
4793
4794   try
4795   {
4796     gImageView1 = ImageView::New();
4797     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
4798     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal10);
4799     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4800
4801     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4802
4803     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready call too much.
4804
4805     for(int i = 0; i < gResourceReadySignal10MaxCounter; ++i)
4806     {
4807       tet_printf("RunIdles\n");
4808       // Executes the idle callbacks.
4809       application.RunIdles();
4810       application.SendNotification();
4811       application.Render();
4812       tet_printf("RunIdles done\n");
4813     }
4814     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4815
4816     DALI_TEST_EQUALS(gResourceReadySignalCounter, gResourceReadySignal10MaxCounter, TEST_LOCATION);
4817
4818     DALI_TEST_CHECK(true);
4819   }
4820   catch(...)
4821   {
4822     // Exception should not happened
4823     DALI_TEST_CHECK(false);
4824   }
4825
4826   // Clear cache.
4827   application.SendNotification();
4828   application.Render();
4829
4830   gResourceReadySignalCounter = 0;
4831
4832   gResourceReadySignalCounter = 0;
4833
4834   // Clear image view for clear test
4835
4836   if(gImageView1)
4837   {
4838     gImageView1.Reset();
4839   }
4840
4841   END_TEST;
4842 }
4843
4844 int UtcDaliImageViewSetImageOnResourceReadySignal10WhenAddIdleFailed(void)
4845 {
4846   tet_infoline("Test ResourceReady signal comes more than 2 times, but do not call again if AddIdle failed");
4847
4848   ToolkitTestApplication application;
4849
4850   gResourceReadySignalCounter = 0;
4851
4852   // Clear image view for clear test
4853
4854   if(gImageView1)
4855   {
4856     gImageView1.Reset();
4857   }
4858
4859   // Dummy view to cache image.
4860   ImageView dummyView = ImageView::New(gImage_34_RGBA);
4861   application.GetScene().Add(dummyView);
4862
4863   application.SendNotification();
4864   application.Render();
4865   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4866   application.SendNotification();
4867   application.Render();
4868
4869   // Make AddIdle failed.
4870   ToolkitApplication::ADD_IDLE_SUCCESS = false;
4871
4872   try
4873   {
4874     gImageView1 = ImageView::New();
4875     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, gImage_34_RGBA);
4876     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal10);
4877     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4878
4879     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4880
4881     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready call too much.
4882
4883     for(int i = 0; i < gResourceReadySignal10MaxCounter; ++i)
4884     {
4885       tet_printf("RunIdles\n");
4886       // Executes the idle callbacks.
4887       application.RunIdles();
4888       application.SendNotification();
4889       application.Render();
4890       tet_printf("RunIdles done\n");
4891     }
4892     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4893
4894     DALI_TEST_GREATER(gResourceReadySignal10MaxCounter, gResourceReadySignalCounter, TEST_LOCATION); // Check whether resource ready not called multiple times.
4895
4896     DALI_TEST_CHECK(true);
4897   }
4898   catch(...)
4899   {
4900     // Exception should not happened
4901     DALI_TEST_CHECK(false);
4902   }
4903
4904   ToolkitApplication::ADD_IDLE_SUCCESS = true;
4905
4906   // Clear cache.
4907   application.SendNotification();
4908   application.Render();
4909
4910   gResourceReadySignalCounter = 0;
4911
4912   gResourceReadySignalCounter = 0;
4913
4914   // Clear image view for clear test
4915
4916   if(gImageView1)
4917   {
4918     gImageView1.Reset();
4919   }
4920
4921   END_TEST;
4922 }
4923
4924 int UtcDaliImageViewSetImageOnResourceReadySignal11(void)
4925 {
4926   tet_infoline("Test ResourceReady Add AnimatedImageVisual and then Remove immediately.");
4927
4928   ToolkitTestApplication application;
4929
4930   gResourceReadySignalCounter = 0;
4931
4932   // Clear image view for clear test
4933
4934   if(gImageView1)
4935   {
4936     gImageView1.Reset();
4937   }
4938   if(gImageView2)
4939   {
4940     gImageView2.Reset();
4941   }
4942   if(gImageView3)
4943   {
4944     gImageView3.Reset();
4945   }
4946
4947   try
4948   {
4949     gImageView1 = ImageView::New();
4950     gImageView1.SetProperty(Toolkit::ImageView::Property::IMAGE, TEST_GIF_FILE_NAME);
4951     gImageView1.ResourceReadySignal().Connect(&OnResourceReadySignal11);
4952     application.GetScene().Add(gImageView1); // It will call resourceReady signal 1 time.
4953
4954     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4955
4956     DALI_TEST_EQUALS(gResourceReadySignalCounter, 0, TEST_LOCATION);
4957
4958     application.SendNotification();
4959     application.Render();
4960
4961     // Load gImageView1
4962     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
4963
4964     tet_printf("ResourceReady called %d times\n", gResourceReadySignalCounter);
4965
4966     DALI_TEST_EQUALS(gResourceReadySignalCounter, 1, TEST_LOCATION);
4967
4968     DALI_TEST_CHECK(true);
4969   }
4970   catch(...)
4971   {
4972     // Exception should not happened
4973     DALI_TEST_CHECK(false);
4974   }
4975
4976   // Clear cache.
4977   application.SendNotification();
4978   application.Render();
4979
4980   gResourceReadySignalCounter = 0;
4981
4982   // Clear image view for clear test
4983
4984   if(gImageView1)
4985   {
4986     gImageView1.Reset();
4987   }
4988   if(gImageView2)
4989   {
4990     gImageView2.Reset();
4991   }
4992   if(gImageView3)
4993   {
4994     gImageView3.Reset();
4995   }
4996
4997   END_TEST;
4998 }
4999
5000 int UtcDaliImageViewUseSameUrlWithAnimatedImageVisual(void)
5001 {
5002   tet_infoline("Test multiple views with same image in animated image visual");
5003   ToolkitTestApplication application;
5004
5005   gImageView1 = ImageView::New(TEST_WEBP_FILE_NAME);
5006   application.GetScene().Add(gImageView1);
5007
5008   tet_infoline("Remove imageView and Create new imageView with same url");
5009   application.GetScene().Remove(gImageView1);
5010   gImageView2 = ImageView::New(TEST_WEBP_FILE_NAME);
5011   application.GetScene().Add(gImageView2);
5012
5013   application.SendNotification();
5014   application.Render();
5015
5016   tet_infoline("Check the ImageView load image successfully");
5017   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5018   END_TEST;
5019 }
5020
5021 int UtcDaliImageViewNpatchImageCacheTest01(void)
5022 {
5023   tet_infoline("Test npatch image cached");
5024
5025   ToolkitTestApplication application;
5026   ImageView              imageView[2];
5027
5028   auto& gl = application.GetGlAbstraction();
5029   gl.EnableTextureCallTrace(true);
5030   auto& textureCallStack = gl.GetTextureTrace();
5031   textureCallStack.Enable(true);
5032   textureCallStack.EnableLogging(true);
5033
5034   auto TestNPatch = [&](int index, const std::string& nPatchImageUrl, const char* location) {
5035     if(imageView[index])
5036     {
5037       imageView[index].Unparent();
5038     }
5039
5040     // Ensure remove npatch cache if required.
5041     application.SendNotification();
5042     application.Render();
5043
5044     imageView[index] = ImageView::New(nPatchImageUrl);
5045     imageView[index].SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5046     application.GetScene().Add(imageView[index]);
5047   };
5048
5049   TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5050   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5051
5052   application.SendNotification();
5053   application.Render();
5054
5055   tet_printf("trace : \n%s\n", textureCallStack.GetTraceString().c_str());
5056
5057   // Check we gen only 1 textures
5058   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 1, TEST_LOCATION);
5059   textureCallStack.Reset();
5060
5061   // Let we use cached textures
5062   for(int i = 0; i < 10; i++)
5063   {
5064     TestNPatch(1, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5065     TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5066   }
5067
5068   application.SendNotification();
5069   application.Render();
5070   // Check we use cached npatch data so we don't generate new texture textures
5071   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 0, TEST_LOCATION);
5072
5073   // Clear all cached
5074   imageView[0].Unparent();
5075   imageView[0].Reset();
5076   imageView[1].Unparent();
5077   imageView[1].Reset();
5078
5079   application.SendNotification();
5080   application.Render();
5081
5082   textureCallStack.Reset();
5083   // Let we use deference textures
5084   TestNPatch(1, TEST_BROKEN_IMAGE_S, TEST_LOCATION);
5085   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5086
5087   application.SendNotification();
5088   application.Render();
5089   // Try to load multiple times.
5090   for(int i = 0; i < 3; i++)
5091   {
5092     TestNPatch(0, TEST_BROKEN_IMAGE_M, TEST_LOCATION);
5093     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5094     TestNPatch(1, TEST_BROKEN_IMAGE_S, TEST_LOCATION);
5095     DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5096   }
5097   application.SendNotification();
5098   application.Render();
5099
5100   imageView[0].Unparent();
5101   imageView[0].Reset();
5102   imageView[1].Unparent();
5103   imageView[1].Reset();
5104
5105   application.SendNotification();
5106   application.Render();
5107
5108   // Check memory leak
5109   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), textureCallStack.CountMethod("DeleteTextures"), TEST_LOCATION);
5110
5111   END_TEST;
5112 }
5113
5114 int UtcDaliImageViewNpatchImageCacheTest02(void)
5115 {
5116   tet_infoline("Test npatch image cached with border");
5117
5118   ToolkitTestApplication application;
5119   ImageView              imageView[2];
5120
5121   auto& gl = application.GetGlAbstraction();
5122   gl.EnableTextureCallTrace(true);
5123   auto& textureCallStack = gl.GetTextureTrace();
5124   textureCallStack.Enable(true);
5125   textureCallStack.EnableLogging(true);
5126
5127   auto TestBorderImage = [&](int index, const std::string& normalImageUrl, const Rect<int> border, const char* location) {
5128     Property::Map map;
5129     map[Toolkit::Visual::Property::TYPE]        = Toolkit::Visual::N_PATCH;
5130     map[Toolkit::ImageVisual::Property::URL]    = normalImageUrl;
5131     map[Toolkit::ImageVisual::Property::BORDER] = border;
5132
5133     imageView[index] = ImageView::New();
5134     imageView[index].SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5135     imageView[index].SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5136     application.GetScene().Add(imageView[index]);
5137   };
5138
5139   TestBorderImage(0, gImage_34_RGBA, Rect<int>(0, 0, 0, 0), TEST_LOCATION);
5140   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5141
5142   application.SendNotification();
5143   application.Render();
5144
5145   tet_printf("trace : \n%s\n", textureCallStack.GetTraceString().c_str());
5146
5147   // Check we gen only 1 textures
5148   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 1, TEST_LOCATION);
5149   textureCallStack.Reset();
5150
5151   // Let we use cached textures
5152   for(int i = 0; i < 10; i++)
5153   {
5154     TestBorderImage(0, gImage_34_RGBA, Rect<int>(i, i + 1, i + 2, i + 3), TEST_LOCATION);
5155     TestBorderImage(1, gImage_34_RGBA, Rect<int>(i + 1, i, i + 3, i + 2), TEST_LOCATION);
5156   }
5157
5158   application.SendNotification();
5159   application.Render();
5160
5161   // Check we use cached npatch data so we don't generate new texture textures
5162   DALI_TEST_EQUALS(textureCallStack.CountMethod("GenTextures"), 0, TEST_LOCATION);
5163
5164   END_TEST;
5165 }
5166
5167 int UtcDaliImageViewPlaceholderImage01(void)
5168 {
5169   tet_infoline("Test imageView use placeholder image");
5170
5171   ToolkitTestApplication application;
5172   Property::Map          map;
5173   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5174
5175   ImageView imageView = ImageView::New();
5176   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5177   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5178   application.GetScene().Add(imageView);
5179
5180   Property::Value value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5181   std::string     url;
5182   DALI_TEST_CHECK(value.Get(url));
5183   DALI_TEST_CHECK(url.empty());
5184   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5185
5186   application.SendNotification();
5187   application.Render();
5188
5189   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5190   DALI_TEST_CHECK(value.Get(url));
5191   DALI_TEST_CHECK(url == gImage_34_RGBA);
5192
5193   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5194   application.SendNotification();
5195   application.Render();
5196
5197   // Replace Image test
5198   map[Toolkit::ImageVisual::Property::URL]    = TEST_IMAGE_1;
5199   map[ImageView::Property::PLACEHOLDER_IMAGE] = gImage_34_RGBA;
5200   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5201   application.SendNotification();
5202   application.Render();
5203
5204   map[Toolkit::ImageVisual::Property::URL] = "";
5205   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5206   application.SendNotification();
5207   application.Render();
5208
5209   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_2;
5210   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5211   application.SendNotification();
5212   application.Render();
5213
5214   // Replace Image test2
5215   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5216   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5217   application.SendNotification();
5218   application.Render();
5219
5220   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_2;
5221   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5222   application.SendNotification();
5223   application.Render();
5224
5225   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5226   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5227   application.SendNotification();
5228   application.Render(900);
5229
5230   map[Toolkit::ImageVisual::Property::URL] = "";
5231   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5232   application.SendNotification();
5233   application.Render();
5234
5235   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5236   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5237   application.SendNotification();
5238   application.Render();
5239
5240   END_TEST;
5241 }
5242
5243 int UtcDaliImageViewPlaceholderImage02(void)
5244 {
5245   tet_infoline("Test imageView use placeholder image without resource ready");
5246
5247   ToolkitTestApplication application;
5248
5249   Property::Map map;
5250   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5251
5252   ImageView imageView = ImageView::New();
5253   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5254   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5255   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
5256   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5257   application.GetScene().Add(imageView);
5258
5259   Property::Value value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5260   std::string     url;
5261   DALI_TEST_CHECK(value.Get(url));
5262   DALI_TEST_CHECK(url.empty());
5263
5264   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5265   application.SendNotification();
5266   application.Render();
5267
5268   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5269
5270   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5271   DALI_TEST_CHECK(value.Get(url));
5272   DALI_TEST_CHECK(url == gImage_34_RGBA);
5273
5274   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5275   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5276
5277   gResourceReadySignalFired                = false;
5278   map[Toolkit::ImageVisual::Property::URL] = "";
5279   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5280   application.SendNotification();
5281   application.Render();
5282
5283   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5284   DALI_TEST_EQUALS(gResourceReadySignalFired, false, TEST_LOCATION);
5285
5286   END_TEST;
5287 }
5288
5289 int UtcDaliImageViewTransitionEffect01(void)
5290 {
5291   tet_infoline("Test imageView use transition effect");
5292
5293   ToolkitTestApplication application;
5294   Property::Map          map;
5295   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5296   map[Toolkit::Visual::Property::OPACITY]  = 0.9f;
5297
5298   ImageView imageView = ImageView::New();
5299   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5300   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5301   application.GetScene().Add(imageView);
5302
5303   Property::Value value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5304   bool            transition;
5305   DALI_TEST_CHECK(value.Get(transition));
5306   DALI_TEST_CHECK(transition == false);
5307   imageView.SetProperty(Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5308
5309   application.SendNotification();
5310   application.Render();
5311
5312   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5313   DALI_TEST_CHECK(value.Get(transition));
5314   DALI_TEST_CHECK(transition == true);
5315
5316   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5317   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5318   application.SendNotification();
5319   application.Render();
5320
5321   // Test transition effect with placeholder
5322   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5323   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5324   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5325   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5326   application.SendNotification();
5327   application.Render();
5328
5329   map[Toolkit::ImageVisual::Property::URL] = "";
5330   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5331   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5332   application.SendNotification();
5333   application.Render();
5334
5335   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5336   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5337   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5338   application.SendNotification();
5339   application.Render();
5340
5341   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5342   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5343   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5344   application.SendNotification();
5345
5346   map[Toolkit::ImageVisual::Property::URL] = "";
5347   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5348   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5349   application.SendNotification();
5350   application.Render();
5351
5352   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5353   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5354   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, "");
5355   application.SendNotification();
5356   application.Render();
5357
5358   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5359   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5360   application.SendNotification();
5361   application.Render();
5362
5363   map[Toolkit::ImageVisual::Property::URL] = "";
5364   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5365   application.SendNotification();
5366   application.Render();
5367
5368   // Test transition effect without placeholder
5369   map[Toolkit::ImageVisual::Property::URL] = TEST_IMAGE_1;
5370   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5371   application.SendNotification();
5372   application.Render();
5373
5374   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5375   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5376   application.SendNotification();
5377   application.Render();
5378
5379   map[Toolkit::ImageVisual::Property::URL] = "";
5380   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5381   application.SendNotification();
5382   application.Render();
5383
5384   map[Toolkit::ImageVisual::Property::URL] = gImage_600_RGB;
5385   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5386   application.SendNotification();
5387   application.Render();
5388
5389   imageView.SetImage(TEST_IMAGE_1);
5390   application.SendNotification();
5391   application.Render();
5392
5393   imageView.SetImage(gImage_600_RGB);
5394   application.SendNotification();
5395   application.Render(9000);
5396
5397   imageView.SetImage("");
5398   application.SendNotification();
5399   application.Render();
5400
5401   imageView.SetImage(TEST_IMAGE_1);
5402   application.SendNotification();
5403   application.Render();
5404
5405   // Clear all cached
5406   imageView.Unparent();
5407   imageView.Reset();
5408
5409   END_TEST;
5410 }
5411
5412 int UtcDaliImageViewTransitionEffect02(void)
5413 {
5414   tet_infoline("Test imageView use transition effect with replace image");
5415
5416   ToolkitTestApplication application;
5417
5418   Property::Map map;
5419
5420   ImageView imageView = ImageView::New();
5421   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5422   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5423   application.GetScene().Add(imageView);
5424
5425   Property::Value value;
5426   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5427   bool transition;
5428   DALI_TEST_CHECK(value.Get(transition));
5429   DALI_TEST_CHECK(transition == false);
5430   imageView.SetProperty(Toolkit::ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5431
5432   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5433   std::string url;
5434   DALI_TEST_CHECK(value.Get(url));
5435   DALI_TEST_CHECK(url.empty());
5436   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5437   application.SendNotification();
5438   application.Render();
5439
5440   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, "");
5441   application.SendNotification();
5442   application.Render();
5443
5444   imageView.SetProperty(Toolkit::ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5445   application.SendNotification();
5446   application.Render();
5447
5448   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5449   DALI_TEST_CHECK(value.Get(transition));
5450   DALI_TEST_CHECK(transition == true);
5451
5452   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5453   DALI_TEST_CHECK(value.Get(url));
5454   DALI_TEST_CHECK(url == gImage_34_RGBA);
5455
5456   imageView.SetProperty(Toolkit::ImageView::Property::IMAGE, map);
5457   application.SendNotification();
5458   application.Render();
5459
5460   // Clear all cached
5461   imageView.Unparent();
5462   imageView.Reset();
5463
5464   END_TEST;
5465 }
5466
5467 int UtcDaliImageViewTransitionEffect03(void)
5468 {
5469   tet_infoline("Test imageView use transition effect with placeholder");
5470
5471   ToolkitTestApplication application;
5472   Property::Map          map;
5473
5474   ImageView imageView = ImageView::New();
5475   imageView.SetImage("");
5476   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 200.0f));
5477   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5478   imageView.SetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT, true);
5479   application.GetScene().Add(imageView);
5480
5481   //DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5482
5483   application.SendNotification();
5484   application.Render(16);
5485
5486   tet_infoline("(1)");
5487   imageView.SetImage(gImage_600_RGB);
5488   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5489   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
5490   application.SendNotification();
5491   application.Render(16);
5492
5493   Property::Value value;
5494   value = imageView.GetProperty(ImageView::Property::ENABLE_TRANSITION_EFFECT);
5495   bool transition;
5496   DALI_TEST_CHECK(value.Get(transition));
5497   DALI_TEST_CHECK(transition == true);
5498
5499   value = imageView.GetProperty(ImageView::Property::PLACEHOLDER_IMAGE);
5500   std::string url;
5501   DALI_TEST_CHECK(value.Get(url));
5502   DALI_TEST_CHECK(url == gImage_34_RGBA);
5503
5504   imageView.SetImage("");
5505   application.SendNotification();
5506   application.Render(16);
5507
5508   imageView.SetImage(TEST_IMAGE_1);
5509   imageView.SetProperty(ImageView::Property::PLACEHOLDER_IMAGE, gImage_34_RGBA);
5510   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5511   application.SendNotification();
5512   application.Render(16);
5513
5514   // Clear all cached
5515   imageView.Unparent();
5516   imageView.Reset();
5517
5518   END_TEST;
5519 }
5520
5521 int UtcDaliImageViewImageLoadFailureAndReload01(void)
5522 {
5523   tet_infoline("Try to load invalid image first, and then reload after that image valid.");
5524   ToolkitTestApplication application;
5525
5526   gResourceReadySignalFired = false;
5527
5528   // Make overwritable image invalid first.
5529   OverwriteImage("");
5530
5531   ImageView imageView = ImageView::New(TEST_OVERWRITABLE_IMAGE_FILE_NAME);
5532   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
5533   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5534
5535   application.GetScene().Add(imageView);
5536   application.SendNotification();
5537   application.Render(16);
5538
5539   // loading started, this waits for the loader thread
5540   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5541
5542   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5543   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5544   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
5545
5546   gResourceReadySignalFired = false;
5547
5548   // Make overwritable image valid now.
5549   OverwriteImage(gImage_34_RGBA);
5550
5551   // Reload the image
5552   Property::Map attributes;
5553   DevelControl::DoAction(imageView, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
5554   application.SendNotification();
5555   application.Render(16);
5556
5557   // loading started, this waits for the loader thread
5558   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5559
5560   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5561   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5562   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5563
5564   // Make overwritable image invalid end of test (for clean).
5565   OverwriteImage("");
5566
5567   gResourceReadySignalFired = false;
5568
5569   END_TEST;
5570 }
5571
5572 int UtcDaliImageViewImageLoadFailureAndReload02(void)
5573 {
5574   tet_infoline("Try to load invalid image first, and then reload after that image valid.");
5575   tet_infoline("This case, broken image was n-patch. So we should check whether Geometry / Shader changed after reload");
5576   ToolkitTestApplication application;
5577
5578   Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
5579   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::SMALL, TEST_BROKEN_IMAGE_S);
5580   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::NORMAL, TEST_BROKEN_IMAGE_M);
5581   DevelStyleManager::SetBrokenImageUrl(styleManager, DevelStyleManager::BrokenImageType::LARGE, TEST_BROKEN_IMAGE_L);
5582
5583   gResourceReadySignalFired = false;
5584
5585   // Make overwritable image invalid first.
5586   OverwriteImage("");
5587
5588   ImageView imageView = ImageView::New(TEST_OVERWRITABLE_IMAGE_FILE_NAME);
5589   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
5590   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5591
5592   application.GetScene().Add(imageView);
5593   application.SendNotification();
5594   application.Render(16);
5595
5596   // loading started, this waits for the loader thread
5597   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5598
5599   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5600   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5601   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::FAILED, TEST_LOCATION);
5602
5603   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
5604   Geometry brokenGeometry = imageView.GetRendererAt(0u).GetGeometry();
5605   Shader   brokenShader   = imageView.GetRendererAt(0u).GetShader();
5606   DALI_TEST_CHECK(brokenGeometry);
5607   DALI_TEST_CHECK(brokenShader);
5608
5609   gResourceReadySignalFired = false;
5610
5611   // Make overwritable image valid now.
5612   OverwriteImage(gImage_34_RGBA);
5613
5614   // Reload the image
5615   Property::Map attributes;
5616   DevelControl::DoAction(imageView, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
5617   application.SendNotification();
5618   application.Render(16);
5619
5620   // loading started, this waits for the loader thread
5621   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5622
5623   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5624   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5625   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5626
5627   // Check whether we don't use n-patch shader and geometry in this case.
5628   DALI_TEST_EQUALS(imageView.GetRendererCount(), 1u, TEST_LOCATION);
5629   DALI_TEST_CHECK(brokenGeometry != imageView.GetRendererAt(0u).GetGeometry());
5630   DALI_TEST_CHECK(brokenShader != imageView.GetRendererAt(0u).GetShader());
5631
5632   // Make overwritable image invalid end of test (for clean).
5633   OverwriteImage("");
5634
5635   gResourceReadySignalFired = false;
5636
5637   END_TEST;
5638 }
5639
5640 int UtcDaliImageViewImageLoadSuccessAndReload01(void)
5641 {
5642   tet_infoline("Try to load valid image first, and then reload again. Check whether ResourceReady signal comes well");
5643   ToolkitTestApplication application;
5644
5645   gResourceReadySignalFired = false;
5646
5647   ImageView imageView = ImageView::New(gImage_34_RGBA);
5648   imageView.SetProperty(Actor::Property::SIZE, Vector2(100.f, 100.f));
5649   imageView.ResourceReadySignal().Connect(&ResourceReadySignal);
5650
5651   application.GetScene().Add(imageView);
5652   application.SendNotification();
5653   application.Render(16);
5654
5655   // loading started, this waits for the loader thread
5656   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5657
5658   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5659   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5660   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5661
5662   gResourceReadySignalFired = false;
5663
5664   // Reload the image
5665   Property::Map attributes;
5666   DevelControl::DoAction(imageView, ImageView::Property::IMAGE, DevelImageVisual::Action::RELOAD, attributes);
5667   application.SendNotification();
5668   application.Render(16);
5669
5670   DALI_TEST_EQUALS(gResourceReadySignalFired, false, TEST_LOCATION);
5671   DALI_TEST_EQUALS(imageView.IsResourceReady(), false, TEST_LOCATION);
5672   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::PREPARING, TEST_LOCATION);
5673
5674   // loading started, this waits for the loader thread
5675   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
5676
5677   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
5678   DALI_TEST_EQUALS(imageView.IsResourceReady(), true, TEST_LOCATION);
5679   DALI_TEST_EQUALS(imageView.GetVisualResourceStatus(ImageView::Property::IMAGE), Visual::ResourceStatus::READY, TEST_LOCATION);
5680
5681   gResourceReadySignalFired = false;
5682
5683   END_TEST;
5684 }