1 /* 2 * Copyright (c) 2023 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 #include <securec.h> 16 17 #include "gtest/gtest.h" 18 19 #define private public 20 #define protected public 21 #include "interfaces/inner_api/drawable_descriptor/drawable_descriptor.h" 22 #include "interfaces/inner_api/drawable_descriptor/image_converter.h" 23 #include "node_extened.h" 24 #include "native_drawable_descriptor.h" 25 26 #include "test/mock/core/pipeline/mock_pipeline_context.h" 27 28 using namespace testing; 29 using namespace testing::ext; 30 31 namespace OHOS::Ace { 32 namespace { 33 constexpr int32_t ID = 1; 34 const uint32_t DENSITY = 0; 35 const uint32_t ICONTYPE = 0; 36 const std::string PATH_NAME = ""; 37 } // namespace 38 class DrawableDescriptorTest : public testing::Test { 39 public: SetUpTestCase()40 static void SetUpTestCase() {}; TearDownTestCase()41 static void TearDownTestCase() {}; 42 }; 43 44 /** 45 * @tc.name: DrawableDescTest001 46 * @tc.desc: test DrawableDescriptor GetPixelMap when pixMap is empty; 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(DrawableDescriptorTest, DrawableDescTest001, TestSize.Level1) 50 { 51 Napi::DrawableDescriptor drawableDescriptor; 52 auto res = drawableDescriptor.GetPixelMap(); 53 EXPECT_EQ(res, nullptr); 54 ArkUI_DrawableDescriptor *drawDes = OH_ArkUI_CreateFromNapiDrawable(&drawableDescriptor); 55 EXPECT_EQ(drawDes->size, 0); 56 delete drawDes; 57 } 58 59 /** 60 * @tc.name: DrawableDescTest002 61 * @tc.desc: test LayeredDrawableDescriptor's member functions; 62 * @tc.type: FUNC 63 */ 64 HWTEST_F(DrawableDescriptorTest, DrawableDescTest002, TestSize.Level1) 65 { 66 /** 67 * @tc.steps: step1. create layeredDrawableDescriptor and call GetPixelMap when layeredPixelMap is empty 68 * @tc.expected: return nullptr 69 */ 70 std::unique_ptr<uint8_t[]> jsonBuf; 71 size_t len = 0; 72 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager()); 73 auto layeredDrawableDescriptor = Napi::LayeredDrawableDescriptor(std::move(jsonBuf), len, std::move(resourceMgr)); 74 auto res = layeredDrawableDescriptor.GetPixelMap(); 75 EXPECT_EQ(res, nullptr); 76 77 /** 78 * @tc.steps: step2. call GetForeground when foreground is empty 79 * @tc.expected: return nullptr 80 */ 81 auto res2 = layeredDrawableDescriptor.GetForeground(); 82 EXPECT_EQ(res2, nullptr); 83 84 /** 85 * @tc.steps: step3. call GetBackground when background is empty 86 * @tc.expected: return nullptr 87 */ 88 auto res3 = layeredDrawableDescriptor.GetBackground(); 89 EXPECT_EQ(res3, nullptr); 90 } 91 92 /** 93 * @tc.name: ImageConverterTest001 94 * @tc.desc: test ImageConverter's member functions; 95 * @tc.type: FUNC 96 */ 97 HWTEST_F(DrawableDescriptorTest, ImageConverterTest001, TestSize.Level1) 98 { 99 /** 100 * @tc.steps: step1. create imageConverter and call PixelFormatToSkColorType 101 * @tc.expected: return rightly 102 */ 103 Napi::ImageConverter imageConverter; 104 Media::PixelFormat pixelFormat = Media::PixelFormat::BGRA_8888; 105 auto res = imageConverter.PixelFormatToSkColorType(pixelFormat); 106 EXPECT_EQ(res, SkColorType::kBGRA_8888_SkColorType); 107 108 /** 109 * @tc.steps: step2. call AlphaTypeToSkAlphaType 110 * @tc.expected: return rightly 111 */ 112 Media::AlphaType alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE; 113 auto res2 = imageConverter.AlphaTypeToSkAlphaType(alphaType); 114 EXPECT_EQ(res2, SkAlphaType::kOpaque_SkAlphaType); 115 116 /** 117 * @tc.steps: step3. call BitmapToPixelMap 118 * @tc.expected: function exits normally 119 */ 120 Media::InitializationOptions opts; 121 SkBitmap skBitmap; 122 auto bitmap = std::make_shared<SkBitmap>(skBitmap); 123 ASSERT_NE(bitmap, nullptr); 124 auto res4 = imageConverter.BitmapToPixelMap(bitmap, opts); 125 EXPECT_EQ(res4, nullptr); 126 } 127 /** 128 * @tc.name: DrawableDescTest003 129 * @tc.desc: test LayeredDrawableDescriptor::GetMask() 130 * @tc.type: FUNC 131 */ 132 HWTEST_F(DrawableDescriptorTest, DrawableDescTest003, TestSize.Level1) 133 { 134 /** 135 * @tc.steps: step1. create layeredDrawableDescriptor and call GetMask when layeredPixelMap is empty 136 * @tc.expected: return nullptr 137 */ 138 std::unique_ptr<uint8_t[]> jsonBuf; 139 size_t len = 0; 140 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager()); 141 ASSERT_NE(resourceMgr, nullptr); 142 auto layeredDrawableDescriptor = Napi::LayeredDrawableDescriptor(std::move(jsonBuf), len, std::move(resourceMgr)); 143 auto res = layeredDrawableDescriptor.GetMask(); 144 EXPECT_EQ(res, nullptr); 145 /** 146 * @tc.steps: step2. call GetStaticMaskClipPath 147 * @tc.expected: return rightly 148 */ 149 auto str = layeredDrawableDescriptor.GetStaticMaskClipPath(); 150 EXPECT_EQ(str, PATH_NAME); 151 } 152 153 /** 154 * @tc.name: DrawableDescTest004 155 * @tc.desc: test DrawableDescriptorFactory::Create() 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(DrawableDescriptorTest, DrawableDescTest004, TestSize.Level1) 159 { 160 /** 161 * @tc.steps: step1. create DrawableDescriptorFactory and call create when RState is not success 162 * @tc.expected: return nullptr 163 */ 164 std::unique_ptr<uint8_t[]> jsonBuf; 165 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager()); 166 ASSERT_NE(resourceMgr, nullptr); 167 Napi::DrawableDescriptorFactory drawableDescriptorFactory; 168 Global::Resource::RState state(Global::Resource::INVALID_FORMAT); 169 Napi::DrawableDescriptor::DrawableType drawableType; 170 auto res = drawableDescriptorFactory.Create(ID, resourceMgr, state, drawableType, DENSITY); 171 EXPECT_EQ(res, nullptr); 172 173 auto res2 = drawableDescriptorFactory.Create(nullptr, resourceMgr, state, drawableType, DENSITY); 174 EXPECT_EQ(res2, nullptr); 175 std::tuple<int32_t, uint32_t, uint32_t> drawableInfo(ID, ICONTYPE, DENSITY); 176 auto res3 = drawableDescriptorFactory.Create(drawableInfo, resourceMgr, state, drawableType); 177 EXPECT_EQ(res3, nullptr); 178 179 std::tuple<const char *, uint32_t, uint32_t> drawableInfoName(nullptr, ICONTYPE, DENSITY); 180 auto res4 = drawableDescriptorFactory.Create(drawableInfoName, resourceMgr, state, drawableType); 181 EXPECT_EQ(res4, nullptr); 182 183 std::pair<std::unique_ptr<uint8_t[]>, size_t> foregroundInfo = { nullptr, 0 }; 184 std::pair<std::unique_ptr<uint8_t[]>, size_t> backgroundInfo = { nullptr, 0 }; 185 std::string path = "path"; 186 auto res5 = drawableDescriptorFactory.Create(foregroundInfo, backgroundInfo, path, drawableType, resourceMgr); 187 ASSERT_NE(res5, nullptr); 188 } 189 190 /** 191 * @tc.name: DrawableDescTest005 192 * @tc.desc: test LayeredDrawableDescriptor's member functions; 193 * @tc.type: FUNC 194 */ 195 HWTEST_F(DrawableDescriptorTest, DrawableDescTest005, TestSize.Level1) 196 { 197 /** 198 * @tc.steps: step1. create layeredDrawableDescriptor and call SetMaskPath 199 * @tc.expected:return path. 200 */ 201 std::unique_ptr<uint8_t[]> jsonBuf; 202 size_t len = 0; 203 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr; 204 std::string path = "path"; 205 uint32_t iconType = 1; 206 uint32_t density = 2; 207 auto layeredDrawableDescriptor = Napi::LayeredDrawableDescriptor( 208 std::move(jsonBuf), len, std::move(resourceMgr), path, iconType, density); 209 210 /** 211 * @tc.steps: step2. check 212 */ 213 EXPECT_EQ(layeredDrawableDescriptor.maskPath_, path); 214 EXPECT_EQ(layeredDrawableDescriptor.iconType_, iconType); 215 EXPECT_EQ(layeredDrawableDescriptor.density_, density); 216 } 217 218 /** 219 * @tc.name: DrawableDescTest006 220 * @tc.desc: test LayeredDrawableDescriptor's member functions; 221 * @tc.type: FUNC 222 */ 223 HWTEST_F(DrawableDescriptorTest, DrawableDescTest006, TestSize.Level1) 224 { 225 /** 226 * @tc.steps: step1. create layeredDrawableDescriptor and call SetMaskPath 227 * @tc.expected:return path. 228 */ 229 std::unique_ptr<uint8_t[]> jsonBuf; 230 size_t len = 0; 231 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr; 232 std::string path = "path"; 233 uint32_t iconType = 1; 234 uint32_t density = 2; 235 auto layeredDrawableDescriptor = 236 Napi::LayeredDrawableDescriptor(std::move(jsonBuf), len, std::move(resourceMgr), path, iconType, density); 237 238 /** 239 * @tc.steps: step2. check 240 */ 241 std::pair<std::unique_ptr<uint8_t[]>, size_t> foregroundInfo = { nullptr, 0 }; 242 std::pair<std::unique_ptr<uint8_t[]>, size_t> backgroundInfo = { nullptr, 0 }; 243 layeredDrawableDescriptor.InitLayeredParam(foregroundInfo, backgroundInfo); 244 245 /** 246 * @tc.steps: step2. check 247 */ 248 EXPECT_EQ(layeredDrawableDescriptor.foreground_, std::nullopt); 249 EXPECT_EQ(layeredDrawableDescriptor.background_, std::nullopt); 250 } 251 252 /** 253 * @tc.name: DrawableDescTest007 254 * @tc.desc: test DrawableDescriptor's member functions; 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(DrawableDescriptorTest, DrawableDescTest007, TestSize.Level1) 258 { 259 /** 260 * @tc.steps: step1. create DrawableDescriptor and call GetDrawableType() 261 * @tc.expected:return BASE. 262 */ 263 Napi::DrawableDescriptor drawableDescriptor; 264 auto res = drawableDescriptor.GetDrawableType(); 265 EXPECT_EQ(res, Napi::DrawableDescriptor::DrawableType::BASE); 266 } 267 268 /** 269 * @tc.name: DrawableDescTest008 270 * @tc.desc: test LayeredDrawableDescriptor's member functions; 271 * @tc.type: FUNC 272 */ 273 HWTEST_F(DrawableDescriptorTest, DrawableDescTest008, TestSize.Level1) 274 { 275 /** 276 * @tc.steps: step1. create layeredDrawableDescriptor and call GetDrawableType() 277 * @tc.expected:return LAYERED. 278 */ 279 std::unique_ptr<uint8_t[]> jsonBuf; 280 size_t len = 0; 281 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr; 282 std::string path = "path"; 283 uint32_t iconType = 1; 284 uint32_t density = 2; 285 auto layeredDrawableDescriptor = Napi::LayeredDrawableDescriptor( 286 std::move(jsonBuf), len, std::move(resourceMgr), path, iconType, density); 287 288 /** 289 * @tc.steps: step2. check 290 */ 291 auto res = layeredDrawableDescriptor.GetDrawableType(); 292 EXPECT_EQ(res, Napi::DrawableDescriptor::DrawableType::LAYERED); 293 } 294 295 /** 296 * @tc.name: DrawableDescTest009 297 * @tc.desc: test AnimatedDrawableDescriptor's member functions; 298 * @tc.type: FUNC 299 */ 300 HWTEST_F(DrawableDescriptorTest, DrawableDescTest009, TestSize.Level1) 301 { 302 /** 303 * @tc.steps: step1. create AnimatedDrawableDescriptor and call GetDrawableType() 304 * @tc.expected:return ANIMATED. 305 */ 306 std::vector<std::shared_ptr<Media::PixelMap>> pixelMaps; 307 int32_t duration = -1; 308 int32_t iterations = 2; 309 auto* animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 310 auto res = animatedDrawable->GetDrawableType(); 311 EXPECT_EQ(res, Napi::DrawableDescriptor::DrawableType::ANIMATED); 312 313 /** 314 * @tc.steps: step2. call GetPixelMap() 315 * @tc.expected:return nullptr. 316 */ 317 auto pixelMap = animatedDrawable->GetPixelMap(); 318 EXPECT_EQ(pixelMap, nullptr); 319 320 /** 321 * @tc.steps: step3. call GetPixelMapList() 322 * @tc.expected: pixelMaps.size(). 323 */ 324 auto pixelMapList = animatedDrawable->GetPixelMapList(); 325 EXPECT_EQ(pixelMapList.size(), pixelMaps.size()); 326 327 /** 328 * @tc.steps: step4. create AnimatedDrawableDescriptor and call GetDuration() 329 * @tc.expected:return 1000. 330 */ 331 duration = 1000; 332 iterations = 1; 333 animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 334 EXPECT_EQ(animatedDrawable->GetDuration(), 1000); 335 336 /** 337 * @tc.steps: step5. create AnimatedDrawableDescriptor and call GetIterations() 338 * @tc.expected:return 2. 339 */ 340 EXPECT_EQ(animatedDrawable->GetIterations(), 1); 341 342 /** 343 * @tc.steps: step6. create AnimatedDrawableDescriptor and call GetDuration() 344 * @tc.expected:return 0. 345 */ 346 duration = -1; 347 iterations = -2; 348 animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 349 EXPECT_EQ(animatedDrawable->GetDuration(), 0); 350 351 /** 352 * @tc.steps: step7. create AnimatedDrawableDescriptor and call GetIterations() 353 * @tc.expected:return 1. 354 */ 355 EXPECT_EQ(animatedDrawable->GetIterations(), 1); 356 } 357 358 /** 359 * @tc.name: DrawableDescTest0010 360 * @tc.desc: test LayeredDrawableDescriptor's member functions; 361 * @tc.type: FUNC 362 */ 363 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0010, TestSize.Level1) 364 { 365 /** 366 * @tc.steps: step1. create layeredDrawableDescriptor and init mask only 367 */ 368 std::shared_ptr<Global::Resource::ResourceManager> resMgr(Global::Resource::CreateResourceManager()); 369 auto layeredDrawable = Napi::LayeredDrawableDescriptor(); 370 /** 371 * @tc.steps: step2. init resource name and data 372 */ 373 layeredDrawable.InitialMask(resMgr); 374 /** 375 * @tc.steps: step2. check creating mask ok 376 */ 377 EXPECT_FALSE(layeredDrawable.GetDefaultMask()); 378 } 379 380 /** 381 * @tc.name: DrawableDescTest0011 382 * @tc.desc: test LayeredDrawableDescriptor's member functions; 383 * @tc.type: FUNC 384 */ 385 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0011, TestSize.Level1) 386 { 387 /** 388 * @tc.steps: step1. pixelMap param not exist in pixelMapDrawable 389 */ 390 std::shared_ptr<Global::Resource::ResourceManager> resMgr(Global::Resource::CreateResourceManager()); 391 auto layeredDrawable = Napi::LayeredDrawableDescriptor(); 392 /** 393 * @tc.steps: step2. init resource name and data 394 */ 395 layeredDrawable.InitialMask(resMgr); 396 /** 397 * @tc.steps: step3. update foreground into layeredDrawable 398 */ 399 std::shared_ptr<Media::PixelMap> foreground = std::make_shared<Media::PixelMap>(); 400 layeredDrawable.SetForeground(foreground); 401 layeredDrawable.layeredPixelMap_ = foreground; 402 auto composedResult = layeredDrawable.GetPixelMap(); 403 /** 404 * @tc.steps: step3. check pixelMap should not be null since this layeredDrawable is customized 405 */ 406 EXPECT_NE(composedResult, nullptr); 407 } 408 409 /** 410 * @tc.name: DrawableDescTest0012 411 * @tc.desc: test LayeredDrawableDescriptor's member functions; 412 * @tc.type: FUNC 413 */ 414 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0012, TestSize.Level1) 415 { 416 /** 417 * @tc.steps: step1. init drawble 418 */ 419 auto layeredDrawable = Napi::LayeredDrawableDescriptor(); 420 /** 421 * @tc.steps: step2. get pixelMap directly from layeredDrawable 422 */ 423 auto composedResult = layeredDrawable.GetPixelMap(); 424 /** 425 * @tc.steps: step3. check pixelMap should be null since this layeredDrawable is not customized 426 * therefore foreground, background does not exist when create 427 */ 428 EXPECT_EQ(composedResult, nullptr); 429 } 430 431 /** 432 * @tc.name: DrawableDescTest0013 433 * @tc.desc: test LayeredDrawableDescriptor's member functions; 434 * @tc.type: FUNC 435 */ 436 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0013, TestSize.Level1) 437 { 438 /** 439 * @tc.steps: step1. init layeredDrawble 440 */ 441 auto drawable = Napi::DrawableDescriptor(); 442 443 /** 444 * @tc.steps: step2. set pixelMap to drawable 445 */ 446 drawable.SetPixelMap(std::make_shared<Media::PixelMap>()); 447 /** 448 * @tc.steps: step3. check drawable has pixelMap 449 */ 450 EXPECT_TRUE(drawable.HasPixelMap()); 451 drawable.ResetPixelMap(); 452 EXPECT_FALSE(drawable.HasPixelMap()); 453 } 454 455 /** 456 * @tc.name: DrawableDescTest0014 457 * @tc.desc: test LayeredDrawableDescriptor's member functions; 458 * @tc.type: FUNC 459 */ 460 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0014, TestSize.Level1) 461 { 462 /** 463 * @tc.steps: step1. init layeredDrawble 464 */ 465 auto drawable = Napi::LayeredDrawableDescriptor(); 466 467 /** 468 * @tc.steps: step2. set param to layeredDrawable 469 */ 470 drawable.SetForeground(std::make_shared<Media::PixelMap>()); 471 drawable.SetBackground(std::make_shared<Media::PixelMap>()); 472 drawable.SetMask(std::make_shared<Media::PixelMap>()); 473 /** 474 * @tc.steps: step3. check layeredDrawable is customized 475 */ 476 EXPECT_TRUE(drawable.Customized()); 477 } 478 479 /** 480 * @tc.name: DrawableDescTest0015 481 * @tc.desc: test AnimatedDrawableDescriptor's member functions; 482 * @tc.type: FUNC 483 */ 484 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0015, TestSize.Level1) 485 { 486 /** 487 * @tc.steps: step1. create AnimatedDrawableDescriptor 488 * @tc.expected:return ANIMATED. 489 */ 490 std::vector<std::shared_ptr<Media::PixelMap>> pixelMaps; 491 int32_t duration = -1; 492 int32_t iterations = 2; 493 auto* animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 494 auto res = animatedDrawable->GetDrawableType(); 495 EXPECT_EQ(res, Napi::DrawableDescriptor::DrawableType::ANIMATED); 496 497 /** 498 * @tc.steps: step2. set value 499 */ 500 animatedDrawable->SetDuration(1000); 501 502 /** 503 * @tc.steps: step3. check duration should be the value set. 504 */ 505 EXPECT_EQ(animatedDrawable->GetDuration(), 1000); 506 } 507 508 /** 509 * @tc.name: DrawableDescTest0016 510 * @tc.desc: test AnimatedDrawableDescriptor's member functions; 511 * @tc.type: FUNC 512 */ 513 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0016, TestSize.Level1) 514 { 515 /** 516 * @tc.steps: step1. create AnimatedDrawableDescriptor 517 * @tc.expected:return ANIMATED. 518 */ 519 std::vector<std::shared_ptr<Media::PixelMap>> pixelMaps; 520 int32_t duration = -1; 521 int32_t iterations = 2; 522 auto* animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 523 auto res = animatedDrawable->GetDrawableType(); 524 EXPECT_EQ(res, Napi::DrawableDescriptor::DrawableType::ANIMATED); 525 526 /** 527 * @tc.steps: step2. set value 528 */ 529 animatedDrawable->SetIterations(1); 530 531 /** 532 * @tc.steps: step3. check duration should be the value set. 533 */ 534 EXPECT_EQ(animatedDrawable->GetIterations(), 1); 535 } 536 537 /** 538 * @tc.name: DrawableDescTest0017 539 * @tc.desc: test LayeredDrawableDescriptor's member functions; 540 * @tc.type: FUNC 541 */ 542 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0017, TestSize.Level1) 543 { 544 /** 545 * @tc.steps: step1. init layeredDrawable 546 */ 547 auto drawable = Napi::LayeredDrawableDescriptor(); 548 549 /** 550 * @tc.steps: step2. set param to layeredDrawable 551 */ 552 std::shared_ptr<Media::PixelMap> layeredPixelMap; 553 std::shared_ptr<Media::PixelMap> badgedPixelMap; 554 std::shared_ptr<Media::PixelMap> compositePixelMap; 555 bool ret = drawable.GetCompositePixelMapWithBadge(layeredPixelMap, badgedPixelMap, compositePixelMap); 556 /** 557 * @tc.steps: step3. check layeredDrawable result 558 */ 559 EXPECT_FALSE(ret); 560 } 561 562 /** 563 * @tc.name: DrawableDescTest0018 564 * @tc.desc: test LayeredDrawableDescriptor's member functions; 565 * @tc.type: FUNC 566 */ 567 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0018, TestSize.Level1) 568 { 569 auto drawable = Napi::LayeredDrawableDescriptor();; 570 const char* item = "item"; 571 Napi::DrawableItem resItem = drawable.PreGetDrawableItem(nullptr, item); 572 EXPECT_EQ(resItem.len_, 0); 573 const char* item1 = ""; 574 resItem = drawable.PreGetDrawableItem(nullptr, item1); 575 EXPECT_EQ(resItem.len_, 0); 576 } 577 578 /** 579 * @tc.name: DrawableDescTest0019 580 * @tc.desc: test LayeredDrawableDescriptor's member functions; 581 * @tc.type: FUNC 582 */ 583 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0019, TestSize.Level1) 584 { 585 auto drawable = Napi::LayeredDrawableDescriptor(); 586 const char* jsonBuf = "{\"background\":\"background\"}"; 587 drawable.len_ = strlen(jsonBuf) + 1; 588 drawable.jsonBuf_ = std::make_unique<uint8_t[]>(drawable.len_); 589 memcpy_s(drawable.jsonBuf_.get(), strlen(jsonBuf), jsonBuf, strlen(jsonBuf)); 590 auto ret = drawable.PreGetPixelMapFromJsonBuf(nullptr, true); 591 EXPECT_FALSE(ret); 592 } 593 594 /** 595 * @tc.name: DrawableDescTest0020 596 * @tc.desc: test LayeredDrawableDescriptor's member functions; 597 * @tc.type: FUNC 598 */ 599 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0020, TestSize.Level1) 600 { 601 auto drawable = Napi::LayeredDrawableDescriptor(); 602 const char* jsonBuf = "{\"foreground\": \"foreground\"}"; 603 drawable.len_ = strlen(jsonBuf) + 1; 604 drawable.jsonBuf_ = std::make_unique<uint8_t[]>(drawable.len_); 605 memcpy_s(drawable.jsonBuf_.get(), strlen(jsonBuf), jsonBuf, strlen(jsonBuf)); 606 auto ret = drawable.PreGetPixelMapFromJsonBuf(nullptr, false); 607 EXPECT_FALSE(ret); 608 } 609 610 /** 611 * @tc.name: DrawableDescTest0021 612 * @tc.desc: test LayeredDrawableDescriptor's member functions; 613 * @tc.type: FUNC 614 */ 615 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0021, TestSize.Level1) 616 { 617 auto drawable = Napi::LayeredDrawableDescriptor(); 618 auto ret = drawable.GetPixelMapFromBuffer(); 619 EXPECT_FALSE(ret); 620 } 621 622 /** 623 * @tc.name: DrawableDescTest0022 624 * @tc.desc: test LayeredDrawableDescriptor's member functions; 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0022, TestSize.Level1) 628 { 629 auto drawable = Napi::LayeredDrawableDescriptor(); 630 Napi::DrawableItem drawableItem; 631 drawableItem.state_ = Global::Resource::ERROR; 632 uint32_t errorCode = 0; 633 auto ret = drawable.CreateImageSource(drawableItem, errorCode); 634 EXPECT_TRUE(ret == nullptr); 635 drawableItem.state_ = Global::Resource::SUCCESS; 636 ret = drawable.CreateImageSource(drawableItem, errorCode); 637 EXPECT_TRUE(ret == nullptr); 638 } 639 640 /** 641 * @tc.name: DrawableDescTest0023 642 * @tc.desc: test LayeredDrawableDescriptor's member functions; 643 * @tc.type: FUNC 644 */ 645 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0023, TestSize.Level1) 646 { 647 auto drawable = Napi::LayeredDrawableDescriptor(); 648 drawable.backgroundItem_.state_ = Global::Resource::SUCCESS; 649 auto ret = drawable.GetPixelMapFromJsonBuf(true); 650 EXPECT_FALSE(ret); 651 } 652 653 /** 654 * @tc.name: DrawableDescTest0024 655 * @tc.desc: test LayeredDrawableDescriptor's member functions; 656 * @tc.type: FUNC 657 */ 658 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0024, TestSize.Level1) 659 { 660 auto drawable = Napi::LayeredDrawableDescriptor(); 661 drawable.maskPath_ = "/data/local/tmp/image/123.jpg"; 662 auto ret = drawable.GetMaskByPath(); 663 EXPECT_FALSE(ret); 664 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 665 drawable.mask_ = pixelMap; 666 ret = drawable.GetMaskByPath(); 667 EXPECT_FALSE(ret); 668 } 669 670 /** 671 * @tc.name: DrawableDescTest0025 672 * @tc.desc: test LayeredDrawableDescriptor's member functions; 673 * @tc.type: FUNC 674 */ 675 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0025, TestSize.Level1) 676 { 677 auto drawable = Napi::LayeredDrawableDescriptor(); 678 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager()); 679 auto ret = drawable.GetMaskByName(resourceMgr, "name"); 680 EXPECT_FALSE(ret); 681 } 682 683 /** 684 * @tc.name: DrawableDescTest0026 685 * @tc.desc: test LayeredDrawableDescriptor's member functions; 686 * @tc.type: FUNC 687 */ 688 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0026, TestSize.Level1) 689 { 690 auto drawable = Napi::LayeredDrawableDescriptor(); 691 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 692 drawable.foreground_ = pixelMap; 693 auto ret = drawable.GetForeground(); 694 EXPECT_FALSE(ret == nullptr); 695 } 696 697 /** 698 * @tc.name: DrawableDescTest0027 699 * @tc.desc: test LayeredDrawableDescriptor's member functions; 700 * @tc.type: FUNC 701 */ 702 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0027, TestSize.Level1) 703 { 704 auto drawable = Napi::LayeredDrawableDescriptor(); 705 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 706 drawable.background_ = pixelMap; 707 auto ret = drawable.GetBackground(); 708 EXPECT_FALSE(ret == nullptr); 709 } 710 711 /** 712 * @tc.name: DrawableDescTest0028 713 * @tc.desc: test LayeredDrawableDescriptor's member functions; 714 * @tc.type: FUNC 715 */ 716 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0028, TestSize.Level1) 717 { 718 auto drawable = Napi::LayeredDrawableDescriptor(); 719 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 720 drawable.mask_ = pixelMap; 721 auto ret = drawable.GetMask(); 722 EXPECT_FALSE(ret == nullptr); 723 } 724 725 /** 726 * @tc.name: DrawableDescTest0029 727 * @tc.desc: test LayeredDrawableDescriptor's member functions; 728 * @tc.type: FUNC 729 */ 730 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0029, TestSize.Level1) 731 { 732 auto drawable = Napi::LayeredDrawableDescriptor(); 733 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 734 drawable.layeredPixelMap_ = pixelMap; 735 auto ret = drawable.GetPixelMap(); 736 EXPECT_FALSE(ret == nullptr); 737 } 738 739 /** 740 * @tc.name: DrawableDescTest0030 741 * @tc.desc: test AnimatedDrawableDescriptor's member functions; 742 * @tc.type: FUNC 743 */ 744 HWTEST_F(DrawableDescriptorTest, DrawableDescTest0030, TestSize.Level1) 745 { 746 std::vector<std::shared_ptr<Media::PixelMap>> pixelMaps; 747 int32_t duration = -1; 748 int32_t iterations = 2; 749 auto* animatedDrawable = new Napi::AnimatedDrawableDescriptor(pixelMaps, duration, iterations); 750 auto ret = animatedDrawable->GetDuration(); 751 EXPECT_EQ(ret, 0); 752 animatedDrawable->duration_ = 10; 753 ret = animatedDrawable->GetDuration(); 754 EXPECT_EQ(ret, 10); 755 ret = animatedDrawable->GetIterations(); 756 EXPECT_EQ(ret, 2); 757 animatedDrawable->iterations_ = -10; 758 ret = animatedDrawable->GetIterations(); 759 EXPECT_EQ(ret, 1); 760 } 761 762 } // namespace OHOS::Ace 763