1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define protected public
17 #define private public
18
19 #include <cstddef>
20 #include <optional>
21 #include <vector>
22
23 #include "gtest/gtest.h"
24 #include "test/mock/base/mock_pixel_map.h"
25 #include "test/mock/core/common/mock_container.h"
26 #include "test/mock/core/common/mock_interaction_interface.h"
27 #include "test/mock/core/image_provider/mock_image_file_cache.cpp"
28 #include "test/mock/core/image_provider/mock_image_loader.h"
29 #include "test/mock/core/pipeline/mock_pipeline_context.h"
30
31 #include "base/geometry/ng/size_t.h"
32 #include "base/geometry/size.h"
33 #include "base/image/pixel_map.h"
34 #include "base/utils/system_properties.h"
35 #include "core/components/common/layout/constants.h"
36 #include "core/components_ng/image_provider/drawing_image_data.h"
37 #include "core/components_ng/image_provider/animated_image_object.h"
38 #include "core/components_ng/image_provider/image_data.h"
39 #include "core/components_ng/image_provider/image_loading_context.h"
40 #include "core/components_ng/image_provider/image_provider.h"
41 #include "core/components_ng/image_provider/image_state_manager.h"
42 #include "core/components_ng/image_provider/pixel_map_image_object.h"
43 #include "core/components_ng/image_provider/static_image_object.h"
44 #include "core/components_ng/render/canvas_image.h"
45 #include "core/components_ng/render/image_painter.h"
46 #include "core/image/image_cache.h"
47 #include "core/image/image_source_info.h"
48
49 using namespace testing;
50 using namespace testing::ext;
51
52 namespace {
53 const char* SRC_JPG = "file://data/data/com.example.test/res/exampleAlt.jpg";
54 const char* SRC_THUMBNAIL = "datashare:///media/9/thumbnail/300/300";
55 constexpr int32_t LENGTH_100 = 100;
56 constexpr int32_t LENGTH_65 = 65;
57 constexpr int32_t LENGTH_64 = 64;
58 constexpr int32_t LENGTH_63 = 63;
59 constexpr int32_t LENGTH_128 = 128;
60 constexpr uint64_t MAX_WAITING_TIME_FOR_TASKS = 1000; // 1000ms
61 int32_t callbackFlag = 0;
62 } // namespace
63
64 namespace OHOS::Ace::NG {
65 class ImageProviderTestNg : public testing::Test {
66 public:
67 static void SetUpTestSuite();
68 static void TearDownTestSuite();
69 static void WaitForAsyncTasks();
70
71 void SetUp() override;
72 void TearDown() override;
73 };
74
75 class MockImageData : public ImageData {
76 public:
77 MOCK_METHOD(size_t, GetSize, (), (const, override));
78 MOCK_METHOD(const void*, GetData, (), (const, override));
79 MOCK_METHOD(std::string, ToString, (), (const, override));
80 };
81
SetUpTestSuite()82 void ImageProviderTestNg::SetUpTestSuite()
83 {
84 MockPipelineContext::SetUp();
85 g_threads = std::vector<std::thread>();
86 }
87
SetUp()88 void ImageProviderTestNg::SetUp()
89 {
90 g_loader = AceType::MakeRefPtr<MockImageLoader>();
91 }
92
TearDown()93 void ImageProviderTestNg::TearDown()
94 {
95 g_loader = nullptr;
96 }
97
TearDownTestSuite()98 void ImageProviderTestNg::TearDownTestSuite()
99 {
100 MockPipelineContext::TearDown();
101 g_loader = nullptr;
102 }
103
104 // wait for load task to finish
WaitForAsyncTasks()105 void ImageProviderTestNg::WaitForAsyncTasks()
106 {
107 for (auto& thread : g_threads) {
108 thread.join();
109 }
110 g_threads.clear();
111 }
112
113 /**
114 * @tc.name: CreateFun001
115 * @tc.desc: Test CreateFun.
116 * @tc.type: FUNC
117 */
118 HWTEST_F(ImageProviderTestNg, CreateFunc001, TestSize.Level1)
119 {
120 auto src = ImageSourceInfo(SRC_JPG);
121 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
122 EXPECT_NE(ctx, nullptr);
123
124 auto src1 = ImageSourceInfo(SRC_JPG);
125 src1.srcType_ = SrcType::PIXMAP;
126 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
127 EXPECT_NE(ctx1, nullptr);
128 }
129
130 /**
131 * @tc.name: Destruction001
132 * @tc.desc: Test Destruction.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(ImageProviderTestNg, Destruction001, TestSize.Level1)
136 {
137 auto src = ImageSourceInfo(SRC_JPG);
138 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
139 EXPECT_NE(ctx, nullptr);
140 ctx->syncLoad_ = false;
141
142 auto src1 = ImageSourceInfo(SRC_JPG);
143 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
144 EXPECT_NE(ctx1, nullptr);
145
146 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx1);
147 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
148 EXPECT_NE(ctx, nullptr);
149 }
150
151 /**
152 * @tc.name: Destruction002
153 * @tc.desc: Test Destruction.
154 * @tc.type: FUNC
155 */
156 HWTEST_F(ImageProviderTestNg, Destruction002, TestSize.Level1)
157 {
158 auto src = ImageSourceInfo(SRC_JPG);
159 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
160 EXPECT_NE(ctx, nullptr);
161 ctx->syncLoad_ = false;
162
163 auto src1 = ImageSourceInfo(SRC_JPG);
164 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
165 EXPECT_NE(ctx1, nullptr);
166
167 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx1);
168 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
169 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(1000, 1000), nullptr);
170 EXPECT_NE(ctx, nullptr);
171 }
172
173 /**
174 * @tc.name: HandleCommand001
175 * @tc.desc: Test HandleCommand.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(ImageProviderTestNg, HandleCommand001, TestSize.Level1)
179 {
180 auto src = ImageSourceInfo(SRC_JPG);
181 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
182 EXPECT_NE(ctx, nullptr);
183 ctx->syncLoad_ = false;
184
185 auto src1 = ImageSourceInfo(SRC_JPG);
186 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
187 EXPECT_NE(ctx1, nullptr);
188
189 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx1);
190 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
191 EXPECT_NE(ctx, nullptr);
192
193 ctx->stateManager_->state_ = ImageLoadingState::LOAD_FAIL;
194 ctx->stateManager_->HandleCommand(ImageLoadingCommand::LOAD_FAIL);
195 EXPECT_NE(ctx, nullptr);
196
197 ctx->stateManager_->state_ = ImageLoadingState(-1);
198 ctx->stateManager_->HandleCommand(ImageLoadingCommand::LOAD_FAIL);
199 EXPECT_NE(ctx, nullptr);
200 }
201
202 /**
203 * @tc.name: NotifiersTest001
204 * @tc.desc: Test NotifiersTest.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(ImageProviderTestNg, NotifiersTest001, TestSize.Level1)
208 {
209 auto src = ImageSourceInfo(SRC_JPG);
210 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
211 EXPECT_NE(ctx, nullptr);
212
213 callbackFlag = 0;
__anon80a153220202(const ImageSourceInfo& src) 214 auto callback1 = [](const ImageSourceInfo& src) {
215 callbackFlag = 1;
216 return;
217 };
__anon80a153220302(const ImageSourceInfo& src) 218 auto callback2 = [](const ImageSourceInfo& src) {
219 callbackFlag = 2;
220 return;
221 };
__anon80a153220402(const ImageSourceInfo& src, const std::string& errorMsg, const ImageErrorInfo& errorInfo) 222 auto callback3 = [](const ImageSourceInfo& src, const std::string& errorMsg, const ImageErrorInfo& errorInfo) {
223 callbackFlag = 3;
224 return;
225 };
226 ctx->notifiers_ = LoadNotifier(std::move(callback1), std::move(callback2), std::move(callback3));
__anon80a153220502() 227 std::function<void()> func = []() {};
228 ctx->pendingMakeCanvasImageTask_ = func;
229 ctx->OnLoadFail();
230 EXPECT_EQ(callbackFlag, 3);
231 ctx->OnDataReady();
232 EXPECT_EQ(callbackFlag, 1);
233 ctx->OnLoadSuccess();
234 EXPECT_EQ(callbackFlag, 2);
235 }
236
237 /**
238 * @tc.name: ImageProviderTestNg001
239 * @tc.desc: Test ImageProvider Synchronous CreateImageObj failure
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg001, TestSize.Level1)
243 {
244 EXPECT_CALL(*g_loader, LoadImageData).Times(1);
245 auto src = ImageSourceInfo(SRC_JPG);
246 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
247 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
248 ctx->LoadImageData();
249
250 EXPECT_EQ(ctx->syncLoad_, true);
251 EXPECT_EQ(ctx->imageObj_, nullptr);
252 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::DATA_LOADING);
253
254 auto src1 = ImageSourceInfo(SRC_JPG);
255 src1.srcType_ = SrcType::PIXMAP;
256 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
257 EXPECT_NE(ctx1, nullptr);
258 }
259
260 /**
261 * @tc.name: CalculateTargetSize001
262 * @tc.desc: Test CalculateTargetSize
263 * @tc.type: FUNC
264 */
265 HWTEST_F(ImageProviderTestNg, CalculateTargetSize001, TestSize.Level1)
266 {
267 auto src = ImageSourceInfo(SRC_JPG);
268 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
269 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
270
271 SizeF srcSize(1, 1);
272 SizeF dstSize(2, 2);
273 SizeF rawImageSize(3, 3);
274 auto size = ctx->CalculateTargetSize(srcSize, dstSize, rawImageSize);
275 EXPECT_EQ(size, rawImageSize);
276
277 auto context = PipelineContext::GetCurrentContext();
278 context.Reset();
279
280 srcSize.SetSizeT(SizeF(-1, -1));
281 size = ctx->CalculateTargetSize(srcSize, dstSize, rawImageSize);
282 EXPECT_EQ(size, rawImageSize);
283
284 srcSize.SetSizeT(SizeF(4, 4));
285 size = ctx->CalculateTargetSize(srcSize, dstSize, rawImageSize);
286 EXPECT_EQ(size, SizeF(1.5, 1.5));
287
288 srcSize.SetSizeT(SizeF(4, 1));
289 size = ctx->CalculateTargetSize(srcSize, dstSize, rawImageSize);
290 EXPECT_EQ(size, rawImageSize);
291
292 srcSize.SetSizeT(SizeF(1, 4));
293 size = ctx->CalculateTargetSize(srcSize, dstSize, rawImageSize);
294 EXPECT_EQ(size, rawImageSize);
295 }
296
297 /**
298 * @tc.name: SourceSizeTest001
299 * @tc.desc: Test SourceSizeTest
300 * @tc.type: FUNC
301 */
302 HWTEST_F(ImageProviderTestNg, SourceSizeTest001, TestSize.Level1)
303 {
304 auto src = ImageSourceInfo(SRC_JPG);
305 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
306 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
307
308 ctx->sourceSizePtr_.reset(new SizeF(1, 1));
309 auto size = ctx->GetSourceSize();
310 EXPECT_EQ(size.value(), *ctx->sourceSizePtr_.get());
311
312 ctx->sourceSizePtr_.reset(new SizeF(-1, 1));
313 size = ctx->GetSourceSize();
314 EXPECT_EQ(size, std::nullopt);
315
316 ctx->sourceSizePtr_.reset(new SizeF(1, -1));
317 size = ctx->GetSourceSize();
318 EXPECT_EQ(size, std::nullopt);
319
320 ctx->sourceSizePtr_.reset(new SizeF(-1, -1));
321 size = ctx->GetSourceSize();
322 EXPECT_EQ(size, std::nullopt);
323
324 ctx->sourceSizePtr_ = nullptr;
325 ctx->SetSourceSize(std::nullopt);
326 EXPECT_EQ(ctx->sourceSizePtr_, nullptr);
327
328 ctx->SetSourceSize(SizeF(1, 1));
329 EXPECT_EQ(*ctx->sourceSizePtr_.get(), SizeF(1, 1));
330 }
331
332 /**
333 * @tc.name: GetImageSize001
334 * @tc.desc: Test GetImageSize
335 * @tc.type: FUNC
336 */
337 HWTEST_F(ImageProviderTestNg, GetImageSize001, TestSize.Level1)
338 {
339 auto src = ImageSourceInfo(SRC_JPG);
340 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
341 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
342 auto size = ctx->GetImageSize();
343 EXPECT_EQ(size, SizeF(-1, -1));
344
345 ctx->imageObj_ =
346 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
347 size = ctx->GetImageSize();
348 EXPECT_EQ(size, SizeF(LENGTH_128, LENGTH_128));
349 }
350
351 /**
352 * @tc.name: GetImageSize003
353 * @tc.desc: Test GetImageSize
354 * @tc.type: FUNC
355 */
356 HWTEST_F(ImageProviderTestNg, GetImageSize003, TestSize.Level1)
357 {
358 auto src = ImageSourceInfo(SRC_JPG);
359 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
360 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
361 auto size = ctx->GetImageSize();
362 EXPECT_EQ(size, SizeF(-1, -1));
363
364 ctx->imageObj_ =
365 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_63, LENGTH_128), nullptr);
366 ctx->GetImageObject()->SetOrientation(ImageRotateOrientation::RIGHT_MIRRORED);
367 size = ctx->GetImageSize();
368 EXPECT_EQ(size, SizeF(LENGTH_128, LENGTH_63));
369 }
370
371 /**
372 * @tc.name: GetImageSize004
373 * @tc.desc: Test GetImageSize
374 * @tc.type: FUNC
375 */
376 HWTEST_F(ImageProviderTestNg, GetImageSize004, TestSize.Level1)
377 {
378 auto src = ImageSourceInfo(SRC_JPG);
379 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
380 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
381 auto size = ctx->GetImageSize();
382 EXPECT_EQ(size, SizeF(-1, -1));
383
384 ctx->imageObj_ =
385 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_63, LENGTH_128), nullptr);
386 ctx->GetImageObject()->SetOrientation(ImageRotateOrientation::LEFT_MIRRORED);
387 size = ctx->GetImageSize();
388 EXPECT_EQ(size, SizeF(LENGTH_128, LENGTH_63));
389 }
390
391 /**
392 * @tc.name: GetImageSize006
393 * @tc.desc: Test GetImageSize
394 * @tc.type: FUNC
395 */
396 HWTEST_F(ImageProviderTestNg, GetImageSize006, TestSize.Level1)
397 {
398 auto src = ImageSourceInfo(SRC_JPG);
399 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
400 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
401 auto size = ctx->GetImageSize();
402 EXPECT_EQ(size, SizeF(-1, -1));
403
404 ctx->imageObj_ =
405 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_63, LENGTH_128), nullptr);
406 ctx->GetImageObject()->SetOrientation(ImageRotateOrientation::UP_MIRRORED);
407 size = ctx->GetImageSize();
408 EXPECT_EQ(size, SizeF(LENGTH_63, LENGTH_128));
409 }
410
411 /**
412 * @tc.name: GetImageSize007
413 * @tc.desc: Test GetImageSize
414 * @tc.type: FUNC
415 */
416 HWTEST_F(ImageProviderTestNg, GetImageSize007, TestSize.Level1)
417 {
418 auto src = ImageSourceInfo(SRC_JPG);
419 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
420 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
421 auto size = ctx->GetImageSize();
422 EXPECT_EQ(size, SizeF(-1, -1));
423
424 ctx->imageObj_ =
425 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_63, LENGTH_128), nullptr);
426 ctx->GetImageObject()->SetOrientation(ImageRotateOrientation::DOWN_MIRRORED);
427 size = ctx->GetImageSize();
428 EXPECT_EQ(size, SizeF(LENGTH_63, LENGTH_128));
429 }
430
431 /**
432 * @tc.name: MakeCanvasImageIfNeed001
433 * @tc.desc: Test MakeCanvasImageIfNeed
434 * @tc.type: FUNC
435 */
436 HWTEST_F(ImageProviderTestNg, MakeCanvasImageIfNeed001, TestSize.Level1)
437 {
438 auto src = ImageSourceInfo(SRC_JPG);
439 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
440 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
441
442 std::vector<ImageFit> imageFitCases = { ImageFit::COVER, ImageFit::FILL };
443 std::vector<std::optional<SizeF>> sourceSizeCases = { std::make_optional(SizeF(1, 1)),
444 std::make_optional(SizeF(2, 2)) };
445 ctx->SetSourceSize(SizeF(1, 1));
446
447 for (int i = 0; i < 2; ++i) {
448 for (int j = 0; j < 2; ++j) {
449 for (int k = 0; k < 2; ++k) {
450 if (i == 0 && j == 0 && k == 0) {
451 ctx->dstSize_ = SizeF(1, 1);
452 auto ret = ctx->MakeCanvasImageIfNeed(SizeF(1, 1), i, imageFitCases[j], sourceSizeCases[k]);
453 EXPECT_TRUE(ret);
454 } else {
455 ctx->dstSize_ = SizeF();
456 auto ret = ctx->MakeCanvasImageIfNeed(SizeF(4, 4), i, imageFitCases[j], sourceSizeCases[k]);
457 EXPECT_TRUE(ret);
458 }
459 }
460 }
461 }
462 }
463
464 /**
465 * @tc.name: ImageProviderTestNg002
466 * @tc.desc: Test ImageProvider merging repeated tasks
467 * @tc.type: FUNC
468 */
469 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg002, TestSize.Level1)
470 {
471 EXPECT_CALL(*g_loader, LoadImageData).Times(1);
472 auto src = ImageSourceInfo(SRC_JPG);
473 // create 20 repeated tasks
474 std::vector<RefPtr<ImageLoadingContext>> contexts(20);
475 for (auto& ctx : contexts) {
476 ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), false);
477 ctx->LoadImageData();
478 }
479 // check task map
480 {
481 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
482 return;
483 }
484 // Adopt the already acquired lock
485 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
486 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)1);
487 EXPECT_EQ(ImageProvider::tasks_[src.GetKey()].ctxs_.size(), (size_t)20);
488 }
489 // wait for load task to finish
490 WaitForAsyncTasks();
491 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
492 return;
493 }
494 // Adopt the already acquired lock
495 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
496 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)0);
497 }
498
499 /**
500 * @tc.name: ImageProviderTestNg003
501 * @tc.desc: Test ImageProvider load thumbnail
502 * @tc.type: FUNC
503 */
504 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg003, TestSize.Level1)
505 {
506 auto src = ImageSourceInfo(SRC_THUMBNAIL);
507
508 EXPECT_CALL(*g_loader, LoadDecodedImageData).Times(1);
509 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
510 ctx->LoadImageData();
511 }
512
513 /**
514 * @tc.name: ImageProviderTestNg004
515 * @tc.desc: Test ImageProvider load success
516 * @tc.type: FUNC
517 */
518 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg004, TestSize.Level1)
519 {
520 auto src = ImageSourceInfo(SRC_THUMBNAIL);
521
522 EXPECT_CALL(*g_loader, LoadDecodedImageData).Times(1);
523 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr));
524 ctx->LoadImageData();
525 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::DATA_LOADING);
526
527 WaitForAsyncTasks();
528
529 // mock data loading succeeded
530 ctx->stateManager_->state_ = ImageLoadingState::DATA_LOADING;
531 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
532 SizeF size(LENGTH_100, LENGTH_100);
533 ctx->DataReadyCallback(AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size));
534 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::DATA_READY);
535 EXPECT_TRUE(ctx->NeedAlt());
536 EXPECT_EQ(ctx->GetImageSize(), size);
537 }
538
539 /**
540 * @tc.name: ImageProviderTestNg005
541 * @tc.desc: Test ImageProvider resize condition
542 * @tc.type: FUNC
543 */
544 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg005, TestSize.Level1)
545 {
546 auto ctx =
547 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
548 ctx->stateManager_->state_ = ImageLoadingState::DATA_READY;
549 ctx->imageObj_ =
550 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
551 SizeF dstSize(LENGTH_100, LENGTH_100);
__anon80a153220602() 552 std::function<void()> func = []() {};
553 ctx->pendingMakeCanvasImageTask_ = func;
554 auto res = ctx->MakeCanvasImageIfNeed(dstSize, true, ImageFit::COVER);
555 EXPECT_TRUE(res);
556 EXPECT_EQ(ctx->dstSize_, SizeF(LENGTH_100, LENGTH_100));
557 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::LOAD_SUCCESS);
558
559 // call MakeCanvasSize with dstSize in the same level
560 res = ctx->MakeCanvasImageIfNeed(SizeF(LENGTH_65, LENGTH_65), true, ImageFit::COVER);
561 EXPECT_FALSE(res);
562 EXPECT_EQ(ctx->sizeLevel_, LENGTH_128);
563
564 res = ctx->MakeCanvasImageIfNeed(SizeF(LENGTH_128, LENGTH_128), true, ImageFit::COVER);
565 EXPECT_FALSE(res);
566
567 res = ctx->MakeCanvasImageIfNeed(SizeF(LENGTH_64, LENGTH_64), true, ImageFit::COVER);
568 EXPECT_TRUE(res);
569 EXPECT_EQ(ctx->sizeLevel_, LENGTH_64);
570
571 res = ctx->MakeCanvasImageIfNeed(SizeF(LENGTH_63, LENGTH_63), true, ImageFit::COVER);
572 EXPECT_FALSE(res);
573 EXPECT_EQ(ctx->sizeLevel_, LENGTH_64);
574 }
575
576 /**
577 * @tc.name: ImageProviderTestNg006
578 * @tc.desc: Test BuildImageObject and frame count check
579 * @tc.type: FUNC
580 */
581 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg006, TestSize.Level1)
582 {
583 auto src = ImageSourceInfo(SRC_JPG);
584 ImageErrorInfo errorInfo;
585 EXPECT_FALSE(ImageProvider::BuildImageObject(src, errorInfo, nullptr));
586
587 auto data = AceType::MakeRefPtr<DrawingImageData>(nullptr, 0);
588 auto imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
589 EXPECT_TRUE(AceType::DynamicCast<StaticImageObject>(imageObject));
590
591 data = AceType::MakeRefPtr<DrawingImageData>(nullptr, 2);
592 imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
593 EXPECT_TRUE(AceType::DynamicCast<AnimatedImageObject>(imageObject));
594
595 // thumbnail src with mismatched data
596 src = ImageSourceInfo(SRC_THUMBNAIL);
597 EXPECT_FALSE(ImageProvider::BuildImageObject(src, errorInfo, data));
598 }
599
600 /**
601 * @tc.name: ImageProviderTestNg007
602 * @tc.desc: Test Cancel task
603 * @tc.type: FUNC
604 */
605 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg007, TestSize.Level1)
606 {
607 EXPECT_CALL(*g_loader, LoadImageData).Times(1);
608 auto src = ImageSourceInfo(SRC_JPG);
609 // create 2 repeated tasks
610 std::vector<RefPtr<ImageLoadingContext>> contexts(2);
611 for (auto& ctx : contexts) {
612 ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr));
613 ctx->LoadImageData();
614 }
615 {
616 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
617 return;
618 }
619 // Adopt the already acquired lock
620 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
621 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)1);
622 auto it = ImageProvider::tasks_.find(src.GetKey());
623 EXPECT_NE(it, ImageProvider::tasks_.end());
624 // set impl_ to false to force successful cancellation
625 it->second.bgTask_.impl_ = nullptr;
626 }
627
628 for (auto& ctx : contexts) {
629 // nullify ctx to trigger task cancel
630 ctx = nullptr;
631 }
632 // check task is successfully canceled
633 {
634 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
635 return;
636 }
637 // Adopt the already acquired lock
638 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
639 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)0);
640 }
641 WaitForAsyncTasks();
642 {
643 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
644 return;
645 }
646 // Adopt the already acquired lock
647 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
648 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)0);
649 }
650 }
651
652 /**
653 * @tc.name: GetImageSize005
654 * @tc.desc: Test GetImageSize
655 * @tc.type: FUNC
656 */
657 HWTEST_F(ImageProviderTestNg, GetImageSize005, TestSize.Level1)
658 {
659 auto src = ImageSourceInfo(SRC_JPG);
660 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
661 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
662 auto size = ctx->GetImageSize();
663 EXPECT_EQ(size, SizeF(-1, -1));
664
665 ctx->imageObj_ =
666 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_63, LENGTH_128), nullptr);
667 ctx->GetImageObject()->SetOrientation(ImageRotateOrientation::LEFT);
668 size = ctx->GetImageSize();
669 EXPECT_EQ(size, SizeF(LENGTH_128, LENGTH_63));
670 }
671
672 /**
673 * @tc.name: RoundUp001
674 * @tc.desc: Test RoundUp with invalid input (infinite loop)
675 * @tc.type: FUNC
676 */
677 HWTEST_F(ImageProviderTestNg, RoundUp001, TestSize.Level1)
678 {
679 auto ctx =
680 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
681 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(-1, -1), nullptr);
682 EXPECT_EQ(ctx->RoundUp(-1), -1);
683
684 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(0, 0), nullptr);
685 EXPECT_EQ(ctx->RoundUp(0), -1);
686
687 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(-1, -1), nullptr);
688 EXPECT_EQ(ctx->RoundUp(0), -1);
689
690 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(0, 0), nullptr);
691 EXPECT_EQ(ctx->RoundUp(-1), -1);
692
693 ctx->imageObj_ =
694 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
695 EXPECT_EQ(ctx->RoundUp(0), -1);
696
697 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(0, 0), nullptr);
698 EXPECT_EQ(ctx->RoundUp(LENGTH_128), -1);
699 }
700
701 /**
702 * @tc.name: TargetSize001
703 * @tc.desc: Test calculating targetSize
704 * @tc.type: FUNC
705 */
706 HWTEST_F(ImageProviderTestNg, TargetSize001, TestSize.Level1)
707 {
708 auto ctx =
709 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
710 ctx->dstSize_ = SizeF(200, 200);
711 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(1000, 1000), nullptr);
712 ctx->imageFit_ = ImageFit::NONE;
713 ctx->sourceSizePtr_ = std::make_unique<SizeF>(50, 50);
714 ctx->OnMakeCanvasImage();
715 // canvasKey contains targetSize info
716 EXPECT_EQ(ctx->dstRect_.GetSize(), SizeF(50, 50));
717
718 ctx->imageFit_ = ImageFit::SCALE_DOWN;
719 ctx->OnMakeCanvasImage();
720 EXPECT_EQ(ctx->dstRect_.GetSize(), SizeF(50, 50));
721 }
722
723 /**
724 * @tc.name: NotifiersTest002
725 * @tc.desc: Test NotifiersTest.
726 * @tc.type: FUNC
727 */
728 HWTEST_F(ImageProviderTestNg, NotifiersTest002, TestSize.Level1)
729 {
730 /**
731 * @tc.steps: step1. Construction parameters
732 * @tc.expected: ImageSourceInfo.
733 */
734 auto src = ImageSourceInfo(SRC_JPG);
735 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
736 EXPECT_NE(ctx, nullptr);
737
738 callbackFlag = 0;
__anon80a153220702(const ImageSourceInfo& src) 739 auto callback1 = [](const ImageSourceInfo& src) {
740 callbackFlag = 1;
741 return;
742 };
__anon80a153220802(const ImageSourceInfo& src) 743 auto callback2 = [](const ImageSourceInfo& src) {
744 callbackFlag = 2;
745 return;
746 };
__anon80a153220902(const ImageSourceInfo& src, const std::string& errorMsg, const ImageErrorInfo& errorInfo) 747 auto callback3 = [](const ImageSourceInfo& src, const std::string& errorMsg, const ImageErrorInfo& errorInfo) {
748 callbackFlag = 3;
749 return;
750 };
751 /**
752 * @tc.steps: step2. Manage notification tasks for loading data
753 * @tc.expected: LoadNotifier.
754 */
755 ctx->notifiers_ = LoadNotifier(std::move(callback1), std::move(callback2), std::move(callback3));
__anon80a153220a02() 756 std::function<void()> func = []() {};
757 ctx->pendingMakeCanvasImageTask_ = func;
758 /**
759 * @tc.steps: step3. Cleaning or resetting with image loading.
760 * @tc.expected: OnUnloaded.
761 */
762 ctx->OnUnloaded();
763 ctx->OnLoadFail();
764 EXPECT_EQ(callbackFlag, 3);
765 ctx->OnDataReady();
766 EXPECT_EQ(callbackFlag, 1);
767 ctx->OnLoadSuccess();
768 EXPECT_EQ(callbackFlag, 2);
769 }
770
771 /**
772 * @tc.name: MakeCanvasImage
773 * @tc.desc: Test MakeCanvasImage
774 * @tc.type: FUNC
775 */
776 HWTEST_F(ImageProviderTestNg, MakeCanvasImage, TestSize.Level1)
777 {
778 auto src = ImageSourceInfo(SRC_THUMBNAIL);
779 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
780 SizeF size(LENGTH_100, LENGTH_100);
781 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
782 auto pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
783 pixmapObj->MakeCanvasImage(ctx, size, true, true);
784 EXPECT_NE(ctx->canvasImage_, nullptr);
785
786 pixmap = nullptr;
787 pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
788 pixmapObj->MakeCanvasImage(ctx, size, true, true);
789 EXPECT_NE(ctx->canvasImage_, nullptr);
790 }
791
792 /**
793 * @tc.name: CreatePixmap
794 * @tc.desc: Test CreatePixmap
795 * @tc.type: FUNC
796 */
797 HWTEST_F(ImageProviderTestNg, CreatePixmap, TestSize.Level1)
798 {
799 auto src = ImageSourceInfo(SRC_JPG);
800 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
801 auto data = AceType::MakeRefPtr<PixmapData>(pixmap);
802 EXPECT_NE(PixelMapImageObject::Create(src, data), nullptr);
803 }
804
805 /**
806 * @tc.name: TargetSize002
807 * @tc.desc: Test calculating targetSize
808 * @tc.type: FUNC
809 */
810 HWTEST_F(ImageProviderTestNg, TargetSize002, TestSize.Level1)
811 {
812 /**
813 * @tc.steps1: Construction parameters
814 */
815 RefPtr<NG::CanvasImage> canvasImage;
816 NG::ImagePainter imagePainter(canvasImage);
817 NG::RectF srcRect_;
818 NG::RectF dstRect_;
819 NG::SizeF rawpicsize { 1, 1 };
820 NG::SizeF dstsize { 1, 1 };
821 auto ctx =
822 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
823 ctx->dstSize_ = SizeF(200, 200);
824 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(-1.0, -1.0), nullptr);
825 ctx->imageFit_ = ImageFit::NONE;
826
827 /**
828 * @tc.steps2: If userDefinedSize is true.SizeF(1, 1).
829 * @tc.expected:EXPECT_EQ(size.value(), *ctx->sourceSizePtr_.get()).
830 */
831 ctx->sourceSizePtr_.reset(new SizeF(1, 1));
832 auto size = ctx->GetSourceSize();
833 EXPECT_EQ(size.value(), *ctx->sourceSizePtr_.get());
834
835 /**
836 * @tc.steps3: callback ApplyImageFit when ImageFit::NONE.
837 */
838 imagePainter.ApplyImageFit(ImageFit::NONE, rawpicsize, dstsize, srcRect_, dstRect_);
839 NG::SizeF srcSize(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height()));
840 auto testSize = Alignment::GetAlignPosition(dstsize, srcSize, Alignment::CENTER);
841 EXPECT_EQ(testSize.GetX(), 0);
842 EXPECT_EQ(testSize.GetY(), 0);
843 auto imageSize = ctx->GetImageSize();
844 EXPECT_EQ(imageSize, SizeF(-1.0, -1.0));
845 bool autoResize = true;
846 bool isPixelMapResource = (SrcType::DATA_ABILITY_DECODED == ctx->GetSourceInfo().GetSrcType());
847 ctx->ResizableCalcDstSize();
848
849 /**
850 * @tc.steps4: callback ApplyImageFit when ImageFit::COVER.
851 */
852 ctx->imageFit_ = ImageFit::COVER;
853 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_);
854 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
855 EXPECT_EQ(testSize1.GetX(), 0);
856 EXPECT_EQ(testSize1.GetY(), 0);
857 ctx->ResizableCalcDstSize();
858 EXPECT_EQ(imageSize, SizeF(-1.0, -1.0));
859 EXPECT_TRUE(autoResize);
860 EXPECT_FALSE(isPixelMapResource);
861 }
862
863 /**
864 * @tc.name: ImageProviderTestNg008
865 * @tc.desc: Test ImageProvider
866 * @tc.type: FUNC
867 */
868 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg008, TestSize.Level1)
869 {
870 /**
871 * @tc.steps: step1. Construction parameters
872 * @tc.expected: ImageSourceInfo.
873 */
874 auto src = ImageSourceInfo(SRC_JPG);
875 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
876 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
877
878 /**
879 * @tc.steps: step2. Information related to building and managing image loading
880 */
881 ctx->GetDstRect();
882 ctx->GetSrcRect();
883 ctx->MoveCanvasImage();
884 ctx->GetFrameCount();
885
886 EXPECT_EQ(ctx->syncLoad_, true);
887 EXPECT_EQ(ctx->imageObj_, nullptr);
888
889 auto src1 = ImageSourceInfo(SRC_JPG);
890 src1.srcType_ = SrcType::PIXMAP;
891 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
892 EXPECT_NE(ctx1, nullptr);
893 }
894
895 /**
896 * @tc.name: TargetSize003
897 * @tc.desc: Test calculating targetSize
898 * @tc.type: FUNC
899 */
900 HWTEST_F(ImageProviderTestNg, TargetSize003, TestSize.Level1)
901 {
902 /**
903 * @tc.steps1: Construction parameters
904 */
905 RefPtr<NG::CanvasImage> canvasImage;
906 NG::ImagePainter imagePainter(canvasImage);
907 NG::RectF srcRect_;
908 NG::RectF dstRect_;
909 NG::SizeF rawpicsize { 1, 1 };
910 NG::SizeF dstsize { 1, 1 };
911 auto ctx =
912 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
913 ctx->dstSize_ = SizeF(200, 200);
914 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(-1.0, -1.0), nullptr);
915 ctx->imageFit_ = ImageFit::NONE;
916
917 /**
918 * @tc.steps2: If userDefinedSize is false.Width() <= 0.0.Height() <= 0.0.
919 * @tc.expected: std::nullopt.
920 */
921 ctx->sourceSizePtr_.reset(new SizeF(-1, 1));
922 auto size = ctx->GetSourceSize();
923 EXPECT_EQ(size, std::nullopt);
924
925 /**
926 * @tc.steps3: callback ApplyImageFit when ImageFit::NONE.
927 */
928 imagePainter.ApplyImageFit(ImageFit::NONE, rawpicsize, dstsize, srcRect_, dstRect_);
929 NG::SizeF srcSize(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height()));
930 auto testSize = Alignment::GetAlignPosition(dstsize, srcSize, Alignment::CENTER);
931 EXPECT_EQ(testSize.GetX(), 0);
932 EXPECT_EQ(testSize.GetY(), 0);
933 auto imageSize = ctx->GetImageSize();
934 EXPECT_EQ(imageSize, SizeF(-1.0, -1.0));
935 bool autoResize = true;
936 bool isPixelMapResource = (SrcType::DATA_ABILITY_DECODED == ctx->GetSourceInfo().GetSrcType());
937 ctx->ResizableCalcDstSize();
938
939 /**
940 * @tc.steps4: callback ApplyImageFit when ImageFit::COVER.
941 */
942 ctx->imageFit_ = ImageFit::COVER;
943 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_);
944 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
945 EXPECT_EQ(testSize1.GetX(), 0);
946 EXPECT_EQ(testSize1.GetY(), 0);
947 ctx->ResizableCalcDstSize();
948 EXPECT_EQ(imageSize, SizeF(-1.0, -1.0));
949 EXPECT_TRUE(autoResize);
950 EXPECT_FALSE(isPixelMapResource);
951 }
952
953 /**
954 * @tc.name: HandleCommand002
955 * @tc.desc: Test HandleCommand.
956 * @tc.type: FUNC
957 */
958 HWTEST_F(ImageProviderTestNg, HandleCommand002, TestSize.Level1)
959 {
960 auto src = ImageSourceInfo(SRC_JPG);
961 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
962 ctx->syncLoad_ = true;
963 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(AceType::WeakClaim(AceType::RawPtr(ctx)));
964 stateManager->HandleCommandByUnloadedState(ImageLoadingCommand::LOAD_DATA);
965 EXPECT_EQ(stateManager->state_, ImageLoadingState::DATA_LOADING);
966
967 stateManager->HandleCommandByUnloadedState(ImageLoadingCommand::RESET_STATE);
968 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
969
970 stateManager->HandleCommandByUnloadedState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
971 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
972 }
973
974 /**
975 * @tc.name: HandleCommand003
976 * @tc.desc: Test HandleCommand.
977 * @tc.type: FUNC
978 */
979 HWTEST_F(ImageProviderTestNg, HandleCommand003, TestSize.Level1)
980 {
981 auto src = ImageSourceInfo(SRC_JPG);
982 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
983 ctx->syncLoad_ = true;
984 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(ctx);
985 stateManager->HandleCommandByDataLoadingState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
986 EXPECT_EQ(stateManager->state_, ImageLoadingState::DATA_READY);
987
988 stateManager->HandleCommandByDataLoadingState(ImageLoadingCommand::LOAD_FAIL);
989 EXPECT_EQ(stateManager->state_, ImageLoadingState::LOAD_FAIL);
990
991 stateManager->HandleCommandByDataLoadingState(ImageLoadingCommand::RESET_STATE);
992 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
993
994 stateManager->HandleCommandByDataLoadingState(ImageLoadingCommand::RETRY_LOADING);
995 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
996 }
997
998 /**
999 * @tc.name: HandleCommand004
1000 * @tc.desc: Test HandleCommand.
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(ImageProviderTestNg, HandleCommand004, TestSize.Level1)
1004 {
1005 auto src = ImageSourceInfo(SRC_JPG);
1006 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1007 ctx->syncLoad_ = true;
1008 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(ctx);
1009 stateManager->HandleCommandByDataReadyState(ImageLoadingCommand::MAKE_CANVAS_IMAGE);
1010 EXPECT_EQ(stateManager->state_, ImageLoadingState::MAKE_CANVAS_IMAGE);
1011
1012 stateManager->HandleCommandByDataReadyState(ImageLoadingCommand::RESET_STATE);
1013 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1014
1015 stateManager->HandleCommandByDataReadyState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
1016 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1017 }
1018
1019 /**
1020 * @tc.name: HandleCommand005
1021 * @tc.desc: Test HandleCommand.
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(ImageProviderTestNg, HandleCommand005, TestSize.Level1)
1025 {
1026 auto src = ImageSourceInfo(SRC_JPG);
1027 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1028 ctx->syncLoad_ = true;
1029 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(ctx);
1030
1031 stateManager->HandleCommandByMakeCanvasImageState(ImageLoadingCommand::LOAD_FAIL);
1032 EXPECT_EQ(stateManager->state_, ImageLoadingState::LOAD_FAIL);
1033
1034 stateManager->HandleCommandByMakeCanvasImageState(ImageLoadingCommand::RESET_STATE);
1035 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1036
1037 stateManager->HandleCommandByMakeCanvasImageState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
1038 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1039 }
1040
1041 /**
1042 * @tc.name: HandleCommand006
1043 * @tc.desc: Test HandleCommand.
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(ImageProviderTestNg, HandleCommand006, TestSize.Level1)
1047 {
1048 auto src = ImageSourceInfo(SRC_JPG);
1049 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1050 ctx->syncLoad_ = true;
1051 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(ctx);
1052 stateManager->HandleCommandByLoadSuccessState(ImageLoadingCommand::MAKE_CANVAS_IMAGE);
1053 EXPECT_EQ(stateManager->state_, ImageLoadingState::MAKE_CANVAS_IMAGE);
1054
1055 stateManager->HandleCommandByLoadSuccessState(ImageLoadingCommand::RESET_STATE);
1056 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1057
1058 stateManager->HandleCommandByLoadSuccessState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
1059 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1060 }
1061
1062 /**
1063 * @tc.name: HandleCommand007
1064 * @tc.desc: Test HandleCommand.
1065 * @tc.type: FUNC
1066 */
1067 HWTEST_F(ImageProviderTestNg, HandleCommand007, TestSize.Level1)
1068 {
1069 auto src = ImageSourceInfo(SRC_JPG);
1070 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1071 ctx->syncLoad_ = true;
1072 auto stateManager = AceType::MakeRefPtr<ImageStateManager>(ctx);
1073
1074 stateManager->HandleCommandByLoadFailState(ImageLoadingCommand::RESET_STATE);
1075 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1076
1077 stateManager->HandleCommandByLoadFailState(ImageLoadingCommand::LOAD_DATA_SUCCESS);
1078 EXPECT_EQ(stateManager->state_, ImageLoadingState::UNLOADED);
1079 }
1080
1081 /**
1082 * @tc.name: GetCurrentLoadingState001
1083 * @tc.desc: Test GetCurrentLoadingState
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState001, TestSize.Level1)
1087 {
1088 auto src = ImageSourceInfo(SRC_JPG);
1089 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1090 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1091 ctx->GetCurrentLoadingState();
1092
1093 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1094 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
1095 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::MAKE_CANVAS_IMAGE);
1096
1097 ctx->stateManager_->state_ = ImageLoadingState::LOAD_FAIL;
1098 ctx->stateManager_->HandleCommand(ImageLoadingCommand::LOAD_FAIL);
1099 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::LOAD_FAIL);
1100 }
1101
1102 /**
1103 * @tc.name: GetCurrentLoadingState002
1104 * @tc.desc: Test GetCurrentLoadingState
1105 * @tc.type: FUNC
1106 */
1107 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState002, TestSize.Level1)
1108 {
1109 auto src = ImageSourceInfo(SRC_JPG);
1110 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1111 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1112
1113 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1114 ctx->stateManager_->state_ = ImageLoadingState::DATA_LOADING;
1115 ctx->GetCurrentLoadingState();
1116 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::DATA_LOADING);
1117 }
1118
1119 /**
1120 * @tc.name: GetCurrentLoadingState003
1121 * @tc.desc: Test GetCurrentLoadingState
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState003, TestSize.Level1)
1125 {
1126 auto src = ImageSourceInfo(SRC_JPG);
1127 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1128 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1129
1130 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1131 ctx->stateManager_->state_ = ImageLoadingState::DATA_READY;
1132 ctx->GetCurrentLoadingState();
1133 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::DATA_READY);
1134 }
1135
1136 /**
1137 * @tc.name: GetCurrentLoadingState004
1138 * @tc.desc: Test GetCurrentLoadingState
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState004, TestSize.Level1)
1142 {
1143 auto src = ImageSourceInfo(SRC_JPG);
1144 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1145 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1146
1147 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1148 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
1149 ctx->GetCurrentLoadingState();
1150 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::MAKE_CANVAS_IMAGE);
1151 }
1152
1153 /**
1154 * @tc.name: GetCurrentLoadingState005
1155 * @tc.desc: Test GetCurrentLoadingState
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState005, TestSize.Level1)
1159 {
1160 auto src = ImageSourceInfo(SRC_JPG);
1161 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1162 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1163
1164 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1165 ctx->stateManager_->state_ = ImageLoadingState::LOAD_SUCCESS;
1166 ctx->GetCurrentLoadingState();
1167 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::LOAD_SUCCESS);
1168 }
1169
1170 /**
1171 * @tc.name: GetCurrentLoadingState006
1172 * @tc.desc: Test GetCurrentLoadingState
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(ImageProviderTestNg, GetCurrentLoadingState006, TestSize.Level1)
1176 {
1177 auto src = ImageSourceInfo(SRC_JPG);
1178 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1179 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
1180
1181 ctx->stateManager_ = AceType::MakeRefPtr<ImageStateManager>(ctx);
1182 ctx->stateManager_->state_ = ImageLoadingState::LOAD_FAIL;
1183 ctx->GetCurrentLoadingState();
1184 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::LOAD_FAIL);
1185 }
1186
1187 /**
1188 * @tc.name: GetFrameCount001
1189 * @tc.desc: Test GetFrameCount
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(ImageProviderTestNg, GetFrameCount001, TestSize.Level1)
1193 {
1194 auto src = ImageSourceInfo(SRC_JPG);
1195 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1196
1197 ctx->GetFrameCount();
1198 EXPECT_EQ(ctx->imageObj_, nullptr);
1199
1200 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(1000, 1000), nullptr);
1201 ctx->GetFrameCount();
1202 EXPECT_NE(ctx->imageObj_, nullptr);
1203 }
1204
1205 /**
1206 * @tc.name: CallbackAfterMeasureIfNeed001
1207 * @tc.desc: Test CallbackAfterMeasureIfNeed
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(ImageProviderTestNg, CallbackAfterMeasureIfNeed001, TestSize.Level1)
1211 {
1212 auto src = ImageSourceInfo(SRC_JPG);
1213 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1214
1215 ctx->needErrorCallBack_ = false;
1216 ctx->CallbackAfterMeasureIfNeed();
1217
1218 ctx->needErrorCallBack_ = true;
1219 ctx->CallbackAfterMeasureIfNeed();
1220 EXPECT_EQ(ctx->needErrorCallBack_, false);
1221 }
1222
1223 /**
1224 * @tc.name: CallbackAfterMeasureIfNeed002
1225 * @tc.desc: Test CallbackAfterMeasureIfNeed
1226 * @tc.type: FUNC
1227 */
1228 HWTEST_F(ImageProviderTestNg, CallbackAfterMeasureIfNeed002, TestSize.Level1)
1229 {
1230 auto src = ImageSourceInfo(SRC_JPG);
1231 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1232
1233 ctx->needErrorCallBack_ = false;
1234 ctx->needDataReadyCallBack_ = false;
1235 ctx->CallbackAfterMeasureIfNeed();
1236
1237 ctx->needDataReadyCallBack_ = true;
1238 ctx->CallbackAfterMeasureIfNeed();
1239 EXPECT_EQ(ctx->needDataReadyCallBack_, false);
1240 }
1241
1242 /**
1243 * @tc.name: FailCallback001
1244 * @tc.desc: Test FailCallback
1245 * @tc.type: FUNC
1246 */
1247 HWTEST_F(ImageProviderTestNg, FailCallback001, TestSize.Level1)
1248 {
1249 auto src = ImageSourceInfo(SRC_JPG);
1250 src.srcType_ = SrcType::NETWORK;
1251 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1252
1253 ctx->measureFinish_ = true;
1254 ctx->FailCallback("test error");
1255 EXPECT_EQ(ctx->needErrorCallBack_, false);
1256 }
1257
1258 /**
1259 * @tc.name: FailCallback002
1260 * @tc.desc: Test FailCallback
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(ImageProviderTestNg, FailCallback002, TestSize.Level1)
1264 {
1265 auto src = ImageSourceInfo(SRC_JPG);
1266 src.srcType_ = SrcType::MEMORY;
1267 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1268
1269 ctx->measureFinish_ = false;
1270 ctx->FailCallback("test error");
1271 EXPECT_EQ(ctx->Downloadable(), false);
1272 }
1273
1274 /**
1275 * @tc.name: DataReadyCallback001
1276 * @tc.desc: Test DataReadyCallback
1277 * @tc.type: FUNC
1278 */
1279 HWTEST_F(ImageProviderTestNg, DataReadyCallback001, TestSize.Level1)
1280 {
1281 auto src = ImageSourceInfo(SRC_JPG);
1282 src.srcType_ = SrcType::NETWORK;
1283 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1284
1285 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1286 SizeF size(LENGTH_100, LENGTH_100);
1287 ctx->measureFinish_ = true;
1288
1289 ctx->DataReadyCallback(AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size));
1290 EXPECT_EQ(ctx->GetImageSize(), size);
1291 }
1292
1293 /**
1294 * @tc.name: ResizableCalcDstSize001
1295 * @tc.desc: Test ResizableCalcDstSize
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(ImageProviderTestNg, ResizableCalcDstSize001, TestSize.Level1)
1299 {
1300 auto src = ImageSourceInfo(SRC_JPG);
1301 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1302
1303 ctx->autoResize_ = true;
1304 bool isPixelMapResource = (SrcType::DATA_ABILITY_DECODED == ctx->GetSourceInfo().GetSrcType());
1305 ctx->ResizableCalcDstSize();
1306 EXPECT_FALSE(isPixelMapResource);
1307 }
1308
1309 /**
1310 * @tc.name: ResizableCalcDstSize002
1311 * @tc.desc: Test ResizableCalcDstSize
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(ImageProviderTestNg, ResizableCalcDstSize002, TestSize.Level1)
1315 {
1316 auto src = ImageSourceInfo(SRC_JPG);
1317 src.srcType_ = SrcType::DATA_ABILITY_DECODED;
1318 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1319
1320 ctx->autoResize_ = false;
1321 bool isPixelMapResource = (SrcType::DATA_ABILITY_DECODED == ctx->GetSourceInfo().GetSrcType());
1322 ctx->ResizableCalcDstSize();
1323 EXPECT_TRUE(isPixelMapResource);
1324 }
1325
1326 /**
1327 * @tc.name: DownloadOnProgress001
1328 * @tc.desc: Test DownloadOnProgress
1329 * @tc.type: FUNC
1330 */
1331 HWTEST_F(ImageProviderTestNg, DownloadOnProgress001, TestSize.Level1)
1332 {
1333 uint32_t dlNow = 0;
1334 uint32_t dlTotal = 0;
1335 auto src = ImageSourceInfo(SRC_JPG);
1336 src.srcType_ = SrcType::DATA_ABILITY_DECODED;
1337 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1338
__anon80a153220b02(const uint32_t& dlNow, const uint32_t& dlTotal) 1339 ctx->onProgressCallback_ = [](const uint32_t& dlNow, const uint32_t& dlTotal) {};
1340 ctx->DownloadOnProgress(dlNow, dlTotal);
1341
1342 ctx->onProgressCallback_ = nullptr;
1343 bool isPixelMapResource = (SrcType::DATA_ABILITY == ctx->GetSourceInfo().GetSrcType());
1344 ctx->DownloadOnProgress(dlNow, dlTotal);
1345 EXPECT_FALSE(isPixelMapResource);
1346 }
1347
1348 /**
1349 * @tc.name: MakeCanvasImageIfNeed002
1350 * @tc.desc: Test MakeCanvasImageIfNeed
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(ImageProviderTestNg, MakeCanvasImageIfNeed002, TestSize.Level1)
1354 {
1355 auto src = ImageSourceInfo(SRC_JPG);
1356 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1357 ctx->stateManager_->state_ = ImageLoadingState::MAKE_CANVAS_IMAGE;
1358 SizeF dstSize(LENGTH_100, LENGTH_100);
__anon80a153220c02() 1359 std::function<void()> func = []() {};
1360 ctx->pendingMakeCanvasImageTask_ = func;
1361 auto res = ctx->MakeCanvasImageIfNeed(dstSize, true, ImageFit::COVER);
1362 EXPECT_TRUE(res);
1363 }
1364
1365 /**
1366 * @tc.name: MakeCanvasImage001
1367 * @tc.desc: Test MakeCanvasImage
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(ImageProviderTestNg, MakeCanvasImage001, TestSize.Level1)
1371 {
1372 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1373 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1374 EXPECT_NE(ctx, nullptr);
1375
1376 SizeF size(LENGTH_100, LENGTH_100);
1377 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1378 auto pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
1379 EXPECT_NE(pixmapObj, nullptr);
1380
1381 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1382 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN));
1383
1384 pixmapObj->MakeCanvasImage(ctx, size, true, true);
1385 EXPECT_NE(ctx->canvasImage_, nullptr);
1386
1387 pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
1388 EXPECT_NE(pixmapObj, nullptr);
1389
1390 pixmapObj->MakeCanvasImage(ctx, size, true, false);
1391 EXPECT_NE(ctx->canvasImage_, nullptr);
1392
1393 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1394
1395 pixmapObj->MakeCanvasImage(ctx, size, true, false);
1396 EXPECT_NE(ctx->canvasImage_, nullptr);
1397 }
1398
1399 /**
1400 * @tc.name: CreatePixmap001
1401 * @tc.desc: Test PixelMapImageObject Create
1402 * @tc.type: FUNC
1403 */
1404 HWTEST_F(ImageProviderTestNg, CreatePixmap001, TestSize.Level1)
1405 {
1406 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1407
1408 SizeF size(LENGTH_100, LENGTH_100);
1409 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1410 auto pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
1411 EXPECT_NE(pixmapObj, nullptr);
1412
1413 pixmap = nullptr;
1414 auto data = AceType::MakeRefPtr<PixmapData>(pixmap);
1415 EXPECT_NE(data, nullptr);
1416
1417 auto pixelMapImageObject = pixmapObj->Create(src, data);
1418 EXPECT_EQ(pixelMapImageObject, nullptr);
1419 }
1420
1421 /**
1422 * @tc.name: ImageLoadingContext001
1423 * @tc.desc: Test ImageLoadingContext.
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(ImageProviderTestNg, ImageLoadingContext001, TestSize.Level1)
1427 {
1428 auto src = ImageSourceInfo(SRC_JPG);
1429 src.srcType_ = SrcType::NETWORK;
1430
1431 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1432 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN));
1433
1434 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1435 EXPECT_NE(ctx, nullptr);
1436
1437 auto src1 = ImageSourceInfo(SRC_JPG);
1438 src1.srcType_ = SrcType::PIXMAP;
1439
1440 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src1, LoadNotifier(nullptr, nullptr, nullptr), true);
1441 EXPECT_NE(ctx1, nullptr);
1442
1443 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1444
1445 EXPECT_TRUE(ctx1->syncLoad_);
1446 }
1447
1448 /**
1449 * @tc.name: OnMakeCanvasImage001
1450 * @tc.desc: Test OnMakeCanvasImage
1451 * @tc.type: FUNC
1452 */
1453 HWTEST_F(ImageProviderTestNg, OnMakeCanvasImage001, TestSize.Level1)
1454 {
1455 auto src = ImageSourceInfo(SRC_JPG);
1456 src.srcType_ = SrcType::PIXMAP;
1457
1458 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1459 EXPECT_NE(ctx, nullptr);
1460
1461 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(1000, 1000), nullptr);
1462 EXPECT_NE(ctx->imageObj_, nullptr);
1463
1464 ctx->imageFit_ = ImageFit::NONE;
1465 ctx->sourceSizePtr_ = nullptr;
1466 ctx->dstSize_ = SizeF(200, 200);
1467 ctx->autoResize_ = false;
1468
1469 ctx->OnMakeCanvasImage();
1470 EXPECT_FALSE(ctx->GetSourceSize());
1471 EXPECT_EQ(ctx->dstRect_.Height(), 200);
1472 }
1473
1474 /**
1475 * @tc.name: OnMakeCanvasImage002
1476 * @tc.desc: Test OnMakeCanvasImage
1477 * @tc.type: FUNC
1478 */
1479 HWTEST_F(ImageProviderTestNg, OnMakeCanvasImage002, TestSize.Level1)
1480 {
1481 auto src = ImageSourceInfo(SRC_JPG);
1482 src.srcType_ = SrcType::DATA_ABILITY_DECODED;
1483
1484 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1485 EXPECT_NE(ctx, nullptr);
1486
1487 ctx->imageObj_ = AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(1000, 1000), nullptr);
1488 EXPECT_NE(ctx->imageObj_, nullptr);
1489
1490 ctx->sourceSizePtr_ = nullptr;
1491 ctx->dstSize_ = SizeF(200, 200);
1492 ctx->autoResize_ = false;
1493
1494 ctx->OnMakeCanvasImage();
1495 EXPECT_FALSE(ctx->GetSourceSize());
1496 EXPECT_EQ(ctx->dstRect_.Height(), 200);
1497
1498 ctx->autoResize_ = true;
1499 ctx->OnMakeCanvasImage();
1500 EXPECT_FALSE(ctx->GetSourceSize());
1501 EXPECT_EQ(ctx->dstRect_.Height(), 200);
1502 }
1503
1504 /**
1505 * @tc.name: ResizableCalcDstSize003
1506 * @tc.desc: Test ResizableCalcDstSize
1507 * @tc.type: FUNC
1508 */
1509 HWTEST_F(ImageProviderTestNg, ResizableCalcDstSize003, TestSize.Level1)
1510 {
1511 auto src = ImageSourceInfo(SRC_JPG);
1512 src.srcType_ = SrcType::DATA_ABILITY_DECODED;
1513
1514 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1515 EXPECT_NE(ctx, nullptr);
1516
1517 ctx->sourceSizePtr_ = nullptr;
1518 ctx->dstSize_ = SizeF(200, 200);
1519
1520 ctx->ResizableCalcDstSize();
1521 EXPECT_EQ(ctx->GetSourceInfo().GetSrcType(), SrcType::DATA_ABILITY_DECODED);
1522 }
1523
1524 /**
1525 * @tc.name: ResizableCalcDstSize004
1526 * @tc.desc: Test ResizableCalcDstSize
1527 * @tc.type: FUNC
1528 */
1529 HWTEST_F(ImageProviderTestNg, ResizableCalcDstSize004, TestSize.Level1)
1530 {
1531 auto src = ImageSourceInfo(SRC_JPG);
1532 src.srcType_ = SrcType::PIXMAP;
1533
1534 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1535 EXPECT_NE(ctx, nullptr);
1536
1537 ctx->sourceSizePtr_ = nullptr;
1538 ctx->dstSize_ = SizeF(200, 200);
1539 ctx->autoResize_ = false;
1540
1541 ctx->ResizableCalcDstSize();
1542 EXPECT_EQ(ctx->GetSourceInfo().GetSrcType(), SrcType::PIXMAP);
1543 }
1544
1545 /**
1546 * @tc.name: MakeCanvasImageIfNeed003
1547 * @tc.desc: Test MakeCanvasImageIfNeed
1548 * @tc.type: FUNC
1549 */
1550 HWTEST_F(ImageProviderTestNg, MakeCanvasImageIfNeed003, TestSize.Level1)
1551 {
1552 auto ctx =
1553 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
1554 EXPECT_NE(ctx, nullptr);
1555
1556 ctx->imageObj_ =
1557 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
1558 EXPECT_NE(ctx->imageObj_, nullptr);
1559
1560 SizeF dstSize(LENGTH_100, LENGTH_100);
__anon80a153220d02() 1561 std::function<void()> func = []() {};
1562 ctx->pendingMakeCanvasImageTask_ = func;
1563 ctx->stateManager_->state_ = ImageLoadingState::DATA_READY;
1564
1565 auto res = ctx->MakeCanvasImageIfNeed(dstSize, true, ImageFit::COVER);
1566 EXPECT_TRUE(res);
1567 EXPECT_EQ(ctx->dstSize_, SizeF(LENGTH_100, LENGTH_100));
1568 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::LOAD_SUCCESS);
1569
1570 res = ctx->MakeCanvasImageIfNeed(SizeF(LENGTH_65, LENGTH_65), true, ImageFit::COVER, std::nullopt, true);
1571 EXPECT_FALSE(res);
1572 EXPECT_EQ(ctx->sizeLevel_, LENGTH_128);
1573 }
1574
1575 /**
1576 * @tc.name: MakeCanvasImageIfNeed004
1577 * @tc.desc: Test MakeCanvasImageIfNeed when firstLoadImage_ is false
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(ImageProviderTestNg, MakeCanvasImageIfNeed004, TestSize.Level1)
1581 {
1582 auto ctx =
1583 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
1584 EXPECT_NE(ctx, nullptr);
1585
1586 ctx->imageObj_ =
1587 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
1588 EXPECT_NE(ctx->imageObj_, nullptr);
1589
1590 SizeF dstSize(LENGTH_100, LENGTH_100);
__anon80a153220e02() 1591 std::function<void()> func = []() {};
1592 ctx->pendingMakeCanvasImageTask_ = func;
1593 ctx->firstLoadImage_ = false;
1594 ctx->stateManager_->state_ = ImageLoadingState::DATA_READY;
1595
1596 auto res = ctx->MakeCanvasImageIfNeed(dstSize, true, ImageFit::COVER);
1597 EXPECT_TRUE(res);
1598 EXPECT_EQ(ctx->dstSize_, SizeF(LENGTH_100, LENGTH_100));
1599 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::LOAD_SUCCESS);
1600 }
1601
1602 /**
1603 * @tc.name: GetImageSize002
1604 * @tc.desc: Test GetImageSize
1605 * @tc.type: FUNC
1606 */
1607 HWTEST_F(ImageProviderTestNg, GetImageSize002, TestSize.Level1)
1608 {
1609 auto ctx =
1610 AceType::MakeRefPtr<ImageLoadingContext>(ImageSourceInfo(), LoadNotifier(nullptr, nullptr, nullptr), true);
1611 EXPECT_NE(ctx, nullptr);
1612
1613 ctx->imageObj_ =
1614 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
1615 EXPECT_NE(ctx->imageObj_, nullptr);
1616
1617 ctx->imageObj_->SetOrientation(ImageRotateOrientation::LEFT);
1618 auto imageSize = ctx->GetImageSize();
1619 EXPECT_EQ(imageSize, SizeF(LENGTH_128, LENGTH_128));
1620
1621 ctx->imageObj_->SetOrientation(ImageRotateOrientation::RIGHT);
1622 imageSize = ctx->GetImageSize();
1623 EXPECT_EQ(imageSize, SizeF(LENGTH_128, LENGTH_128));
1624 }
1625
1626 /**
1627 * @tc.name: PrepareImageData001
1628 * @tc.desc: Test PrepareImageData
1629 * @tc.type: FUNC
1630 */
1631 HWTEST_F(ImageProviderTestNg, PrepareImageData001, TestSize.Level1)
1632 {
1633 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1634 EXPECT_NE(imageProvider, nullptr);
1635
1636 auto src = ImageSourceInfo(SRC_JPG);
1637 ImageErrorInfo errorInfo;
1638 EXPECT_FALSE(ImageProvider::BuildImageObject(src, errorInfo, nullptr));
1639 auto data = AceType::MakeRefPtr<DrawingImageData>(nullptr, 0);
1640 auto imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
1641
1642 auto lock = imageObject->GetPrepareImageDataLock();
1643 lock.__owns_ = false;
1644
1645 EXPECT_FALSE(imageProvider->PrepareImageData(imageObject));
1646 }
1647
1648 /**
1649 * @tc.name: PrepareImageData002
1650 * @tc.desc: Test PrepareImageData
1651 * @tc.type: FUNC
1652 */
1653 HWTEST_F(ImageProviderTestNg, PrepareImageData002, TestSize.Level1)
1654 {
1655 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1656 EXPECT_NE(imageProvider, nullptr);
1657
1658 auto src = ImageSourceInfo(SRC_JPG);
1659 ImageErrorInfo errorInfo;
1660 EXPECT_FALSE(ImageProvider::BuildImageObject(src, errorInfo, nullptr));
1661 auto data = AceType::MakeRefPtr<DrawingImageData>(nullptr, 0);
1662 auto imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
1663 imageObject->data_ = nullptr;
1664
1665 MockContainer::SetUp();
1666 auto container = MockContainer::Current();
1667
1668 EXPECT_FALSE(imageProvider->PrepareImageData(imageObject));
1669 }
1670
1671 /**
1672 * @tc.name: PrepareImageData003
1673 * @tc.desc: Test PrepareImageData
1674 * @tc.type: FUNC
1675 */
1676 HWTEST_F(ImageProviderTestNg, PrepareImageData003, TestSize.Level1)
1677 {
1678 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1679 EXPECT_NE(imageProvider, nullptr);
1680
1681 auto src = ImageSourceInfo(SRC_JPG);
1682 ImageErrorInfo errorInfo;
1683 EXPECT_FALSE(ImageProvider::BuildImageObject(src, errorInfo, nullptr));
1684 auto data = AceType::MakeRefPtr<DrawingImageData>(nullptr, 0);
1685 auto imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
1686 imageObject->data_ = nullptr;
1687
1688 MockContainer::SetUp();
1689 auto container = MockContainer::Current();
1690 g_loader = nullptr;
1691 container->pipelineContext_ = PipelineBase::GetCurrentContext();
1692
1693 EXPECT_FALSE(imageProvider->PrepareImageData(imageObject));
1694 }
1695
1696 /**
1697 * @tc.name: CreateImageObjHelper001
1698 * @tc.desc: Test CreateImageObjHelper
1699 * @tc.type: FUNC
1700 */
1701 HWTEST_F(ImageProviderTestNg, CreateImageObjHelper001, TestSize.Level1)
1702 {
1703 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1704 EXPECT_NE(imageProvider, nullptr);
1705
1706 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1707 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr));
1708 ctx->LoadImageData();
1709 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::DATA_LOADING);
1710 g_loader = nullptr;
1711
1712 WaitForAsyncTasks();
1713
1714 EXPECT_EQ(ctx->errorMsg_, "Failed to create image loader.");
1715 }
1716
1717 /**
1718 * @tc.name: CreateImageObjHelper002
1719 * @tc.desc: Test CreateImageObjHelper
1720 * @tc.type: FUNC
1721 */
1722 HWTEST_F(ImageProviderTestNg, CreateImageObjHelper002, TestSize.Level1)
1723 {
1724 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1725 EXPECT_NE(imageProvider, nullptr);
1726
1727 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1728 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr));
1729 ctx->LoadImageData();
1730 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::DATA_LOADING);
1731
1732 MockContainer::SetUp();
1733 auto container = MockContainer::Current();
1734 auto data = AceType::MakeRefPtr<MockImageData>();
1735 EXPECT_CALL(*g_loader, LoadDecodedImageData(testing::_, testing::_, testing::_)).WillOnce(testing::Return(data));
1736 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1737 src.pixmap_ = pixmap;
1738
1739 WaitForAsyncTasks();
1740
1741 EXPECT_EQ(ctx->errorMsg_, "Failed to build image object");
1742 }
1743
1744 /**
1745 * @tc.name: CreateImageObjHelper003
1746 * @tc.desc: Test CreateImageObjHelper
1747 * @tc.type: FUNC
1748 */
1749 HWTEST_F(ImageProviderTestNg, CreateImageObjHelper003, TestSize.Level1)
1750 {
1751 auto imageProvider = AceType::MakeRefPtr<ImageProvider>();
1752 EXPECT_NE(imageProvider, nullptr);
1753
1754 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1755 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr));
1756 ctx->LoadImageData();
1757 EXPECT_EQ(ctx->stateManager_->state_, ImageLoadingState::DATA_LOADING);
1758
1759 MockContainer::SetUp();
1760 auto container = MockContainer::Current();
1761
1762 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1763 src.pixmap_ = pixmap;
1764 auto data = AceType::MakeRefPtr<PixmapData>(pixmap);
1765 EXPECT_CALL(*g_loader, LoadDecodedImageData(testing::_, testing::_, testing::_)).WillOnce(testing::Return(data));
1766
1767 ImageErrorInfo errorInfo;
1768 auto imageObject = ImageProvider::BuildImageObject(src, errorInfo, data);
1769
1770 EXPECT_CALL(*pixmap, GetWidth()).Times(1);
1771 EXPECT_CALL(*pixmap, GetHeight()).Times(1);
1772
1773 WaitForAsyncTasks();
1774
1775 EXPECT_EQ(ctx->errorMsg_, "");
1776 }
1777
1778 /**
1779 * @tc.name: ImageProviderFailCallback001
1780 * @tc.desc: Test ImageProvider FailCallback
1781 * @tc.type: FUNC
1782 */
1783 HWTEST_F(ImageProviderTestNg, ImageProviderFailCallback001, TestSize.Level1)
1784 {
1785 auto src = ImageSourceInfo();
1786 // Create multiple ImageLoadingContext instances associated with the same ImageSourceInfo.
1787 // The LoadNotifier parameters are set to nullptr, meaning no callback is registered.
1788 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1789 EXPECT_NE(ctx1, nullptr);
1790
1791 auto ctx2 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1792 EXPECT_NE(ctx2, nullptr);
1793
1794 auto ctx3 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1795 EXPECT_NE(ctx3, nullptr);
1796
1797 // Register weak references of these ImageLoadingContext instances in ImageProvider's task management.
1798 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx1));
1799 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx2));
1800 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx3));
1801
1802 ctx2 = nullptr;
1803
1804 // Define the error message.
1805 auto errorMsg = "error";
1806 // Define the error information.
1807 ImageErrorInfo errorInfo;
1808
1809 // Invoke FailCallback to trigger the failure callback.
1810 // Expected behavior: ctx1 and ctx3 should update their error messages.
1811 ImageProvider::FailCallback(src.GetKey(), errorMsg, errorInfo, true);
1812
1813 // Verify that ctx1 and ctx3 have correctly received the error message.
1814 EXPECT_EQ(ctx1->errorMsg_, errorMsg);
1815 EXPECT_EQ(ctx2, nullptr);
1816 EXPECT_EQ(ctx3->errorMsg_, errorMsg);
1817 }
1818
1819 /**
1820 * @tc.name: ImageProviderFailCallback002
1821 * @tc.desc: Test ImageProvider FailCallback
1822 * @tc.type: FUNC
1823 */
1824 HWTEST_F(ImageProviderTestNg, ImageProviderFailCallback002, TestSize.Level1)
1825 {
1826 auto src = ImageSourceInfo();
1827 // Create multiple ImageLoadingContext instances associated with the same ImageSourceInfo.
1828 // The LoadNotifier parameters are set to nullptr, meaning no callback is registered.
1829 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1830 EXPECT_NE(ctx1, nullptr);
1831
1832 auto ctx2 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1833 EXPECT_NE(ctx2, nullptr);
1834
1835 auto ctx3 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1836 EXPECT_NE(ctx3, nullptr);
1837
1838 auto ctx4 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1839 EXPECT_NE(ctx3, nullptr);
1840
1841 // Register weak references of these ImageLoadingContext instances in ImageProvider's task management.
1842 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx1));
1843 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx2));
1844 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx3));
1845 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx4));
1846
1847 ctx2 = nullptr;
1848 ctx3 = nullptr;
1849
1850 // Define the error message.
1851 auto errorMsg = "error";
1852 // Define the error information.
1853 ImageErrorInfo errorInfo;
1854
1855 // Invoke FailCallback to trigger the failure callback.
1856 // Expected behavior: ctx1 and ctx3 should update their error messages.
1857 ImageProvider::FailCallback(src.GetKey(), errorMsg, errorInfo, true);
1858
1859 // Verify that ctx1 and ctx4 have correctly received the error message.
1860 EXPECT_EQ(ctx1->errorMsg_, errorMsg);
1861 EXPECT_EQ(ctx2, nullptr);
1862 EXPECT_EQ(ctx3, nullptr);
1863 EXPECT_EQ(ctx4->errorMsg_, errorMsg);
1864 }
1865
1866 /**
1867 * @tc.name: ImageProviderFailCallback003
1868 * @tc.desc: Test ImageProvider FailCallback
1869 * @tc.type: FUNC
1870 */
1871 HWTEST_F(ImageProviderTestNg, ImageProviderFailCallback003, TestSize.Level1)
1872 {
1873 auto src = ImageSourceInfo();
1874 // Create multiple ImageLoadingContext instances associated with the same ImageSourceInfo.
1875 // The LoadNotifier parameters are set to nullptr, meaning no callback is registered.
1876 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1877 EXPECT_NE(ctx1, nullptr);
1878
1879 auto ctx2 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1880 EXPECT_NE(ctx2, nullptr);
1881
1882 auto ctx3 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1883 EXPECT_NE(ctx3, nullptr);
1884
1885 auto ctx4 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1886 EXPECT_NE(ctx3, nullptr);
1887
1888 // Register weak references of these ImageLoadingContext instances in ImageProvider's task management.
1889 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx1));
1890 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx2));
1891 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx3));
1892 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx4));
1893
1894 // Define the error message.
1895 auto errorMsg = "error";
1896 ImageErrorInfo errorInfo;
1897
1898 // Invoke FailCallback to trigger the failure callback.
1899 // Expected behavior: all ctx should update their error messages.
1900 ImageProvider::FailCallback(src.GetKey(), errorMsg, errorInfo, true);
1901
1902 // Verify that all ctx have correctly received the error message.
1903 EXPECT_EQ(ctx1->errorMsg_, errorMsg);
1904 EXPECT_EQ(ctx2->errorMsg_, errorMsg);
1905 EXPECT_EQ(ctx3->errorMsg_, errorMsg);
1906 EXPECT_EQ(ctx4->errorMsg_, errorMsg);
1907 }
1908
1909 /**
1910 * @tc.name: ImageProviderCancelTask001
1911 * @tc.desc: Test ImageProvider::CancelTask with multiple contexts; only one is removed
1912 * @tc.type: FUNC
1913 */
1914 HWTEST_F(ImageProviderTestNg, ImageProviderCancelTask001, TestSize.Level1)
1915 {
1916 ImageProvider::tasks_.clear();
1917 auto src = ImageSourceInfo();
1918
1919 // Create multiple ImageLoadingContext instances and register them under the same key
1920 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1921 EXPECT_NE(ctx1, nullptr);
1922 auto ctx2 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1923 EXPECT_NE(ctx2, nullptr);
1924
1925 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx1));
1926 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx2));
1927
1928 // CancelTask for ctx1 should return false since ctx2 is still waiting
1929 bool result1 = ImageProvider::CancelTask(src.GetKey(), WeakPtr(ctx1));
1930 EXPECT_FALSE(result1);
1931
1932 // CancelTask for ctx2 should return true as it's the last context
1933 bool result2 = ImageProvider::CancelTask(src.GetKey(), WeakPtr(ctx2));
1934 EXPECT_TRUE(result2);
1935 }
1936
1937 /**
1938 * @tc.name: StaticImageDecoder001
1939 * @tc.desc: Test MakeCanvasImage
1940 * @tc.type: FUNC
1941 */
1942 HWTEST_F(ImageProviderTestNg, StaticImageDecoder001, TestSize.Level1)
1943 {
1944 auto src = ImageSourceInfo(SRC_THUMBNAIL);
1945 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1946 EXPECT_NE(ctx, nullptr);
1947
1948 SizeF size(LENGTH_100, LENGTH_100);
1949 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
1950 auto pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
1951 EXPECT_NE(pixmapObj, nullptr);
1952
1953 pixmapObj->MakeCanvasImage(ctx, size, true, true);
1954 EXPECT_NE(ctx->canvasImage_, nullptr);
1955
1956 pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
1957 EXPECT_NE(pixmapObj, nullptr);
1958
1959 pixmapObj->MakeCanvasImage(ctx, size, true, false);
1960 EXPECT_NE(ctx->canvasImage_, nullptr);
1961
1962 pixmapObj->MakeCanvasImage(ctx, size, true, false);
1963 EXPECT_NE(ctx->canvasImage_, nullptr);
1964 }
1965
1966 /**
1967 * @tc.name: ImageProviderCancelTask002
1968 * @tc.desc: Test ImageProvider::CancelTask when context is not registered
1969 * @tc.type: FUNC
1970 */
1971 HWTEST_F(ImageProviderTestNg, ImageProviderCancelTask002, TestSize.Level1)
1972 {
1973 ImageProvider::tasks_.clear();
1974 auto src = ImageSourceInfo();
1975
1976 // Register one context
1977 auto ctx1 = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1978 EXPECT_NE(ctx1, nullptr);
1979 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx1));
1980
1981 // Create a context that is not registered
1982 auto ctxNotRegistered =
1983 AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
1984 EXPECT_NE(ctxNotRegistered, nullptr);
1985
1986 // Attempting to cancel an unregistered context should return false
1987 bool result = ImageProvider::CancelTask(src.GetKey(), WeakPtr(ctxNotRegistered));
1988 EXPECT_FALSE(result);
1989 }
1990
1991 /**
1992 * @tc.name: ImageProviderCancelTask003
1993 * @tc.desc: Test ImageProvider::CancelTask when key does not exist
1994 * @tc.type: FUNC
1995 */
1996 HWTEST_F(ImageProviderTestNg, ImageProviderCancelTask003, TestSize.Level1)
1997 {
1998 ImageProvider::tasks_.clear();
1999 auto src = ImageSourceInfo();
2000
2001 // Create a context but do not register it
2002 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
2003 EXPECT_NE(ctx, nullptr);
2004
2005 // Attempting to cancel with a non-existent key should return false
2006 bool result = ImageProvider::CancelTask("non_exist_key", WeakPtr(ctx));
2007 EXPECT_FALSE(result);
2008 }
2009
2010 /**
2011 * @tc.name: ImageProviderCancelTask004
2012 * @tc.desc: Test ImageProvider::CancelTask when only one context is registered
2013 * @tc.type: FUNC
2014 */
2015 HWTEST_F(ImageProviderTestNg, ImageProviderCancelTask004, TestSize.Level1)
2016 {
2017 ImageProvider::tasks_.clear();
2018 auto src = ImageSourceInfo();
2019
2020 // Register a single context
2021 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
2022 EXPECT_NE(ctx, nullptr);
2023 ImageProvider::RegisterTask(src.GetKey(), WeakPtr(ctx));
2024
2025 // CancelTask should return true and remove the entire task
2026 bool result = ImageProvider::CancelTask(src.GetKey(), WeakPtr(ctx));
2027 EXPECT_TRUE(result);
2028 }
2029
2030 /**
2031 * @tc.name: ImageProviderTestNg_EndTaskKeyCorrectness
2032 * @tc.desc: Verify that ImageProvider uses GetTaskKey() for registering and ending tasks.
2033 * @tc.type: FUNC
2034 */
2035 HWTEST_F(ImageProviderTestNg, ImageProviderTestNg_EndTaskKeyCorrectness, TestSize.Level1)
2036 {
2037 // Expect LoadImageData to be called only once, since repeated tasks should be merged.
2038 EXPECT_CALL(*g_loader, LoadImageData).Times(1);
2039
2040 auto src = ImageSourceInfo(SRC_JPG);
2041
2042 // Step 1: Create multiple ImageLoadingContext instances with the same image source.
2043 std::vector<RefPtr<ImageLoadingContext>> contexts(10);
2044 for (auto& ctx : contexts) {
2045 ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), false);
2046 ctx->LoadImageData(); // Triggers CreateImageObject and registers task.
2047 }
2048
2049 // Step 2: Verify that task was registered using the correct key and merged properly.
2050 {
2051 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
2052 EXPECT_TRUE(false) << "Failed to acquire mutex.";
2053 return;
2054 }
2055 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
2056
2057 // Use GetTaskKey() instead of GetKey() to check the task map.
2058 auto taskKey = src.GetTaskKey();
2059 auto it = ImageProvider::tasks_.find(taskKey);
2060 EXPECT_NE(it, ImageProvider::tasks_.end()); // Task should exist.
2061 EXPECT_EQ(it->second.ctxs_.size(), (size_t)10); // All contexts should be merged under the same task.
2062 auto errorKey = "non_exist_key";
2063 auto tmpIt = ImageProvider::tasks_.find(errorKey);
2064 EXPECT_EQ(tmpIt, ImageProvider::tasks_.end()); // errorTask shouldn't exist.
2065 }
2066
2067 // Step 3: Wait for the background loading task to finish, which will trigger EndTask().
2068 WaitForAsyncTasks();
2069
2070 // Step 4: Check that the task has been properly removed from the map after completion.
2071 {
2072 if (!ImageProvider::taskMtx_.try_lock_for(std::chrono::milliseconds(MAX_WAITING_TIME_FOR_TASKS))) {
2073 EXPECT_TRUE(false) << "Failed to acquire mutex after WaitForAsyncTasks.";
2074 return;
2075 }
2076 std::scoped_lock lock(std::adopt_lock, ImageProvider::taskMtx_);
2077 EXPECT_EQ(ImageProvider::tasks_.size(), (size_t)0); // The task map should be empty after cleanup.
2078 }
2079 }
2080
2081 /**
2082 * @tc.name: StaticImageMakeCanvasImage001
2083 * @tc.desc: Test MakeCanvasImage
2084 * @tc.type: FUNC
2085 */
2086 HWTEST_F(ImageProviderTestNg, StaticImageMakeCanvasImage001, TestSize.Level1)
2087 {
2088 auto src = ImageSourceInfo(SRC_THUMBNAIL);
2089 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
2090 EXPECT_NE(ctx, nullptr);
2091
2092 SizeF size(LENGTH_100, LENGTH_100);
2093 auto pixmap = AceType::MakeRefPtr<MockPixelMap>();
2094 auto pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
2095 EXPECT_NE(pixmapObj, nullptr);
2096
2097 pixmapObj->MakeCanvasImage(ctx, size, true, true);
2098 EXPECT_NE(ctx->canvasImage_, nullptr);
2099
2100 pixmapObj = AceType::MakeRefPtr<PixelMapImageObject>(pixmap, src, size);
2101 EXPECT_NE(pixmapObj, nullptr);
2102
2103 pixmapObj->MakeCanvasImage(ctx, size, true, false);
2104 EXPECT_NE(ctx->canvasImage_, nullptr);
2105
2106 pixmapObj->MakeCanvasImage(ctx, size, true, false);
2107 EXPECT_NE(ctx->canvasImage_, nullptr);
2108 }
2109
2110 /**
2111 * @tc.name: ImageFileSizeTest001
2112 * @tc.desc: Test ImageFileSize
2113 * @tc.type: FUNC
2114 */
2115 HWTEST_F(ImageProviderTestNg, ImageFileSizeTest001, TestSize.Level1)
2116 {
2117 auto src = ImageSourceInfo(SRC_JPG);
2118 auto ctx = AceType::MakeRefPtr<ImageLoadingContext>(src, LoadNotifier(nullptr, nullptr, nullptr), true);
2119 EXPECT_EQ(ctx->stateManager_->GetCurrentState(), ImageLoadingState::UNLOADED);
2120 auto size = ctx->GetImageSize();
2121 EXPECT_EQ(size, SizeF(-1, -1));
2122
2123 ctx->imageObj_ =
2124 AceType::MakeRefPtr<NG::StaticImageObject>(ImageSourceInfo(SRC_JPG), SizeF(LENGTH_128, LENGTH_128), nullptr);
2125 size = ctx->GetImageSize();
2126 EXPECT_EQ(size, SizeF(LENGTH_128, LENGTH_128));
2127 auto imageObj = ctx->imageObj_;
2128 EXPECT_NE(imageObj, nullptr);
2129 imageObj->SetImageFileSize(100);
2130 EXPECT_EQ(imageObj->GetImageFileSize(), 100);
2131 EXPECT_EQ(imageObj->GetImageDataSize(), 0);
2132 }
2133 } // namespace OHOS::Ace::NG
2134
