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

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 #include <dali-toolkit-test-suite-utils.h>
  18 #include <dali-toolkit/dali-toolkit.h>
  19 #include <dali/dali.h>
  20 #include <dali/devel-api/actors/actor-devel.h>
  21 #include <stdlib.h>
  22 #include <toolkit-event-thread-callback.h>
  23 #include <unistd.h>
  24
  25 using namespace Dali;
  26 using namespace Dali::Toolkit;
  27
  28 namespace
  29 {
  30 // resolution: 34*34, pixel format: RGBA8888
  31 static const char* gImage_34_RGBA = TEST_RESOURCE_DIR "/icon-edit.png";
  32 // resolution: 50*50, pixel format: RGBA8888
  33 static const char* gImage_50_RGBA = TEST_RESOURCE_DIR "/icon-delete.png";
  34 // resolution: 128*128, pixel format: RGB888
  35 static const char* gImage_128_RGB = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
  36
  37 // for testing the ImageLoadedSignal
  38 class ImageLoadedSignalVerifier : public ConnectionTracker
  39 {
  40 public:
  41   ImageLoadedSignalVerifier()
  42   : mCount(0)
  43   {
  44   }
  45
  46   virtual ~ImageLoadedSignalVerifier()
  47   {
  48   }
  49
  50   void ImageLoaded(uint32_t id, PixelData pixelData)
  51   {
  52     mIDs.push_back(id);
  53     mPixelDataList.push_back(pixelData);
  54     mCount++;
  55   }
  56
  57   int LoadedImageCount()
  58   {
  59     return mCount;
  60   }
  61
  62   bool Verify(uint32_t id, uint32_t width, uint32_t height)
  63   {
  64     int size = mIDs.size();
  65     for(int i = 0; i < size; i++)
  66     {
  67       if(mIDs[i] == id)
  68       {
  69         return mPixelDataList[i].GetWidth() == width && mPixelDataList[i].GetHeight() == height;
  70       }
  71     }
  72
  73     return false;
  74   }
  75
  76 private:
  77   int mCount;
  78
  79   std::vector<uint32_t>  mIDs;
  80   std::vector<PixelData> mPixelDataList;
  81 };
  82
  83 } // anonymous namespace
  84
  85 void dali_async_image_loader_startup(void)
  86 {
  87   test_return_value = TET_UNDEF;
  88 }
  89
  90 void dali_async_image_loader_cleanup(void)
  91 {
  92   test_return_value = TET_PASS;
  93 }
  94
  95 int UtcDaliImageAtlasNew01(void)
  96 {
  97   ToolkitTestApplication application;
  98
  99   //invoke default handle constructor
 100   AsyncImageLoader loader;
 101
 102   DALI_TEST_CHECK(!loader);
 103
 104   // initialise handle
 105   loader = AsyncImageLoader::New();
 106   DALI_TEST_CHECK(loader);
 107
 108   END_TEST;
 109 }
 110
 111 int UtcDaliAsyncImageLoaderCopyConstructor(void)
 112 {
 113   ToolkitTestApplication application;
 114
 115   AsyncImageLoader loader = AsyncImageLoader::New();
 116   DALI_TEST_CHECK(loader);
 117
 118   AsyncImageLoader loaderCopy(loader);
 119   DALI_TEST_CHECK(loaderCopy);
 120
 121   END_TEST;
 122 }
 123
 124 int UtcDaliAsyncImageLoaderMoveConstructor(void)
 125 {
 126   ToolkitTestApplication application;
 127
 128   AsyncImageLoader loader = AsyncImageLoader::New();
 129   DALI_TEST_CHECK(loader);
 130   DALI_TEST_EQUALS(1, loader.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 131
 132   AsyncImageLoader moved = std::move(loader);
 133   DALI_TEST_CHECK(moved);
 134   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 135   DALI_TEST_CHECK(!loader);
 136
 137   END_TEST;
 138 }
 139
 140 int UtcDaliAsyncImageLoaderAssignmentOperator(void)
 141 {
 142   ToolkitTestApplication application;
 143
 144   AsyncImageLoader loader = AsyncImageLoader::New();
 145   DALI_TEST_CHECK(loader);
 146
 147   AsyncImageLoader loader2;
 148   DALI_TEST_CHECK(!loader2);
 149
 150   loader2 = loader;
 151   DALI_TEST_CHECK(loader2);
 152   DALI_TEST_CHECK(loader == loader2); // the two handles are pointing to the same object.
 153
 154   END_TEST;
 155 }
 156
 157 int UtcDaliAsyncImageLoaderMoveAssignment(void)
 158 {
 159   ToolkitTestApplication application;
 160
 161   AsyncImageLoader loader = AsyncImageLoader::New();
 162   DALI_TEST_CHECK(loader);
 163   DALI_TEST_EQUALS(1, loader.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 164
 165   AsyncImageLoader moved;
 166   moved = std::move(loader);
 167   DALI_TEST_CHECK(moved);
 168   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 169   DALI_TEST_CHECK(!loader);
 170
 171   END_TEST;
 172 }
 173
 174 int UtcDaliAsyncImageLoaderDownCastP(void)
 175 {
 176   ToolkitTestApplication application;
 177
 178   AsyncImageLoader asyncImageLoader = AsyncImageLoader::New();
 179   BaseHandle       object(asyncImageLoader);
 180
 181   AsyncImageLoader asyncImageLoader2 = AsyncImageLoader::DownCast(object);
 182
 183   DALI_TEST_CHECK(asyncImageLoader2);
 184
 185   END_TEST;
 186 }
 187
 188 int UtcDaliAsyncImageLoaderDownCastN(void)
 189 {
 190   ToolkitTestApplication application;
 191
 192   BaseHandle       unInitializedObject;
 193   AsyncImageLoader asyncImageLoader = AsyncImageLoader::DownCast(unInitializedObject);
 194
 195   DALI_TEST_CHECK(!asyncImageLoader);
 196
 197   END_TEST;
 198 }
 199
 200 int UtcDaliAsyncImageLoaderLoadAndLoadedSignal(void)
 201 {
 202   ToolkitTestApplication application;
 203
 204   AsyncImageLoader          loader = AsyncImageLoader::New();
 205   ImageLoadedSignalVerifier loadedSignalVerifier;
 206
 207   loader.ImageLoadedSignal().Connect(&loadedSignalVerifier, &ImageLoadedSignalVerifier::ImageLoaded);
 208
 209   loader.Load(gImage_34_RGBA);
 210   uint32_t id02 = loader.Load(gImage_50_RGBA, ImageDimensions(25, 25));
 211   uint32_t id03 = loader.Load(gImage_128_RGB, ImageDimensions(100, 100), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, true);
 212
 213   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
 214
 215   application.SendNotification();
 216   application.Render();
 217
 218   DALI_TEST_CHECK(loadedSignalVerifier.LoadedImageCount() == 3);
 219   DALI_TEST_CHECK(loadedSignalVerifier.Verify(id02, 25, 25));
 220   DALI_TEST_CHECK(loadedSignalVerifier.Verify(id03, 100, 100));
 221
 222   END_TEST;
 223 }
 224
 225 // Note: This is not an ideal test, but we cannot guarantee we can call Cancel() before the image has finished loading.
 226 int UtcDaliAsyncImageLoaderCancel(void)
 227 {
 228   ToolkitTestApplication application;
 229
 230   AsyncImageLoader          loader = AsyncImageLoader::New();
 231   ImageLoadedSignalVerifier loadedSignalVerifier;
 232
 233   loader.ImageLoadedSignal().Connect(&loadedSignalVerifier, &ImageLoadedSignalVerifier::ImageLoaded);
 234
 235   uint32_t id01 = loader.Load(gImage_34_RGBA, ImageDimensions(34, 34));
 236   uint32_t id02 = loader.Load(gImage_50_RGBA, ImageDimensions(25, 25));
 237   uint32_t id03 = loader.Load(gImage_128_RGB, ImageDimensions(100, 100), FittingMode::SCALE_TO_FILL, SamplingMode::BOX_THEN_LINEAR, true);
 238
 239   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
 240
 241   application.SendNotification();
 242   application.Render();
 243
 244   DALI_TEST_CHECK(loadedSignalVerifier.LoadedImageCount() == 3);
 245
 246   DALI_TEST_CHECK(!loader.Cancel(id03)); // Cannot cancel a task that is already implemeted
 247
 248   DALI_TEST_CHECK(loadedSignalVerifier.Verify(id01, 34, 34));   // first image is loaded
 249   DALI_TEST_CHECK(loadedSignalVerifier.Verify(id02, 25, 25));   // second image is loaded
 250   DALI_TEST_CHECK(loadedSignalVerifier.Verify(id03, 100, 100)); // third image is loaded
 251
 252   END_TEST;
 253 }
 254
 255 int UtcDaliAsyncImageLoaderCancelAll(void)
 256 {
 257   ToolkitTestApplication application;
 258
 259   AsyncImageLoader loader = AsyncImageLoader::New();
 260
 261   // Test that it is safe to call CancelAll even there is no loading task requested.
 262   try
 263   {
 264     loader.CancelAll();
 265   }
 266   catch(Dali::DaliException& e)
 267   {
 268     DALI_TEST_ASSERT(e, "AsyncImageLoader::LoadAll", TEST_LOCATION);
 269   }
 270
 271   // Test that cancelling a non-existing loading task will return false
 272   uint32_t id = 1;
 273   DALI_TEST_CHECK(!(loader.Cancel(id)));
 274
 275   END_TEST;
 276 }