1 /*
2  * Copyright (C) 2022 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 #define private public
16 #define protected public
17 #include "wallpaper_service.h"
18 #undef private
19 #undef protected
20 
21 #include <gtest/gtest.h>
22 
23 #include <ctime>
24 
25 #include "accesstoken_kit.h"
26 #include "directory_ex.h"
27 #include "file_deal.h"
28 #include "hilog_wrapper.h"
29 #include "image_packer.h"
30 #include "nativetoken_kit.h"
31 #include "pixel_map.h"
32 #include "scene_board_judgement.h"
33 #include "token_setproc.h"
34 #include "wallpaper_common_event_subscriber.h"
35 #include "wallpaper_manager.h"
36 #include "wallpaper_service.h"
37 
38 namespace OHOS {
39 namespace WallpaperMgrService {
40 constexpr int32_t SYSTYEM = 0;
41 constexpr int32_t LOCKSCREEN = 1;
42 constexpr int32_t INVALID_WALLPAPER_TYPE = 2;
43 constexpr int32_t HUNDRED = 100;
44 constexpr int32_t DEFAULT_WALLPAPER_ID = -1;
45 constexpr int32_t FOO_MAX_LEN = 60000000;
46 constexpr int32_t TEST_USERID = 99;
47 constexpr int32_t TEST_USERID1 = 98;
48 constexpr int32_t INVALID_USERID = -1;
49 constexpr int32_t NORMAL = 0;
50 constexpr int32_t UNFOLD_1 = 1;
51 constexpr int32_t UNFOLD_2 = 1;
52 constexpr int32_t PORT = 0;
53 constexpr int32_t LAND = 1;
54 uint64_t selfTokenID_ = 0;
55 constexpr const char *URI = "/data/test/theme/wallpaper/wallpaper_test.JPG";
56 constexpr const char *NORMAL_PORT_URI = "/data/test/theme/wallpaper/normal_port_wallpaper.jpg";
57 constexpr const char *NORMAL_LAND_URI = "/data/test/theme/wallpaper/normal_land_wallpaper.jpg";
58 constexpr const char *UNFOLD1_PORT_URI = "/data/test/theme/wallpaper/unfold1_port_wallpaper.jpg";
59 constexpr const char *UNFOLD1_LAND_URI = "/data/test/theme/wallpaper/unfold1_land_wallpaper.jpg";
60 constexpr const char *UNFOLD2_PORT_URI = "/data/test/theme/wallpaper/unfold2_port_wallpaper.jpg";
61 constexpr const char *UNFOLD2_LAND_URI = "/data/test/theme/wallpaper/unfold2_land_wallpaper.jpg";
62 constexpr const char *URI_ZIP = "/data/test/theme/wallpaper/test.zip";
63 constexpr const char *URI_30FPS_3S_MP4 = "/data/test/theme/wallpaper/30fps_3s.mp4";
64 constexpr const char *URI_15FPS_7S_MP4 = "/data/test/theme/wallpaper/15fps_7s.mp4";
65 constexpr const char *URI_30FPS_3S_MOV = "/data/test/theme/wallpaper/30fps_3s.mov";
66 constexpr const char *WALLPAPER_DEFAULT_PATH = "/data/service/el1/public/wallpaper";
67 constexpr const char *SYSTEM_DIR = "/system";
68 constexpr const char *LOCKSCREEN_DIR = "/lockscreen";
69 constexpr const char *LOCKSCREEN_FILE = "/lockscreen/wallpaper_lock";
70 constexpr const char *WALLPAPER_DEFAULT = "wallpaperdefault.jpeg";
71 constexpr const char *HOME_WALLPAPER = "home_wallpaper_0.jpg";
72 
73 std::shared_ptr<WallpaperCommonEventSubscriber> subscriber = nullptr;
74 
75 using namespace testing::ext;
76 using namespace testing;
77 using namespace OHOS::Media;
78 using namespace OHOS::HiviewDFX;
79 using namespace OHOS::MiscServices;
80 using namespace OHOS::Security::AccessToken;
81 
82 static HapPolicyParams policyParams = { .apl = APL_SYSTEM_CORE,
83     .domain = "test.domain",
84     .permList = { { .permissionName = "ohos.permission.GET_WALLPAPER",
85                       .bundleName = "ohos.wallpaper_test.demo",
86                       .grantMode = 1,
87                       .availableLevel = APL_NORMAL,
88                       .label = "label",
89                       .labelId = 1,
90                       .description = "test",
91                       .descriptionId = 1 },
92         { .permissionName = "ohos.permission.SET_WALLPAPER",
93             .bundleName = "ohos.wallpaper_test.demo",
94             .grantMode = 1,
95             .availableLevel = APL_NORMAL,
96             .label = "label",
97             .labelId = 1,
98             .description = "test",
99             .descriptionId = 1 },
100         { .permissionName = "ohos.permission.MANAGE_LOCAL_ACCOUNTS",
101             .bundleName = "ohos.wallpaper_test.demo",
102             .grantMode = 1,
103             .availableLevel = APL_NORMAL,
104             .label = "label",
105             .labelId = 1,
106             .description = "test",
107             .descriptionId = 1 } },
108     .permStateList = { { .permissionName = "ohos.permission.GET_WALLPAPER",
109                            .isGeneral = true,
110                            .resDeviceID = { "local" },
111                            .grantStatus = { PermissionState::PERMISSION_GRANTED },
112                            .grantFlags = { 1 } },
113         { .permissionName = "ohos.permission.SET_WALLPAPER",
114             .isGeneral = true,
115             .resDeviceID = { "local" },
116             .grantStatus = { PermissionState::PERMISSION_GRANTED },
117             .grantFlags = { 1 } },
118         { .permissionName = "ohos.permission.MANAGE_LOCAL_ACCOUNTS",
119             .isGeneral = true,
120             .resDeviceID = { "local" },
121             .grantStatus = { PermissionState::PERMISSION_GRANTED },
122             .grantFlags = { 1 } } } };
123 
124 HapInfoParams infoParams = { .userID = 1,
125     .bundleName = "wallpaper_service",
126     .instIndex = 0,
127     .appIDDesc = "test",
128     .apiVersion = 9,
129     .isSystemApp = true };
130 
131 static WallpaperInfo wallpaperInfo_normal_port = { FoldState::NORMAL, RotateState::PORT, NORMAL_PORT_URI };
132 static WallpaperInfo wallpaperInfo_normal_land = { FoldState::NORMAL, RotateState::LAND, NORMAL_LAND_URI };
133 static WallpaperInfo wallpaperInfo_unfold1_port = { FoldState::UNFOLD_1, RotateState::PORT, UNFOLD1_PORT_URI };
134 static WallpaperInfo wallpaperInfo_unfold1_land = { FoldState::UNFOLD_1, RotateState::LAND, UNFOLD1_LAND_URI };
135 static WallpaperInfo wallpaperInfo_unfold2_port = { FoldState::UNFOLD_2, RotateState::PORT, UNFOLD2_PORT_URI };
136 static WallpaperInfo wallpaperInfo_unfold2_land = { FoldState::UNFOLD_2, RotateState::LAND, UNFOLD2_LAND_URI };
137 
GrantNativePermission()138 void GrantNativePermission()
139 {
140     selfTokenID_ = GetSelfTokenID();
141     AccessTokenIDEx tokenIdEx = { 0 };
142     tokenIdEx = AccessTokenKit::AllocHapToken(infoParams, policyParams);
143     int32_t ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
144     if (ret == 0) {
145         HILOG_INFO("SetSelfTokenID success!");
146     } else {
147         HILOG_ERROR("SetSelfTokenID fail!");
148     }
149 }
150 
151 class WallpaperTest : public testing::Test {
152 public:
153     static void SetUpTestCase(void);
154     static void TearDownTestCase(void);
155     void SetUp();
156     void TearDown();
157     static void CreateTempImage();
158     static std::shared_ptr<PixelMap> CreateTempPixelMap();
159     static bool SubscribeCommonEvent(shared_ptr<WallpaperService> wallpaperService);
160     static void TriggerEvent(int32_t userId, const std::string &commonEventSupport);
161     static std::string GetUserFilePath(int32_t userId, const char *filePath);
162     static bool TestCallBack(int32_t num);
163 };
164 const std::string VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\","
165                                                "\"SCHEMA_MODE\":\"STRICT\","
166                                                "\"SCHEMA_SKIPSIZE\":0,"
167                                                "\"SCHEMA_DEFINE\":{"
168                                                "\"age\":\"INTEGER, NOT NULL\""
169                                                "},"
170                                                "\"SCHEMA_INDEXES\":[\"$.age\"]}";
171 
SetUpTestCase(void)172 void WallpaperTest::SetUpTestCase(void)
173 {
174     HILOG_INFO("SetUpTestCase");
175     GrantNativePermission();
176     CreateTempImage();
177     HILOG_INFO("SetUpTestCase end");
178 }
179 
TearDownTestCase(void)180 void WallpaperTest::TearDownTestCase(void)
181 {
182     HILOG_INFO("TearDownTestCase");
183     ApiInfo apiInfo{ false, false };
184     WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
185     WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
186     auto ret = SetSelfTokenID(selfTokenID_);
187     HILOG_INFO("SetSelfTokenID ret = %{public}d", ret);
188 }
189 
SetUp(void)190 void WallpaperTest::SetUp(void)
191 {
192 }
193 
TearDown(void)194 void WallpaperTest::TearDown(void)
195 {
196 }
197 
198 class WallpaperEventListenerTestImpl : public WallpaperEventListener {
199 public:
200     std::vector<uint64_t> color_;
201     int32_t wallpaperType_;
202     WallpaperEventListenerTestImpl();
~WallpaperEventListenerTestImpl()203     ~WallpaperEventListenerTestImpl()
204     {
205     }
206 
207     WallpaperEventListenerTestImpl(const WallpaperEventListenerTestImpl &) = delete;
208     WallpaperEventListenerTestImpl &operator=(const WallpaperEventListenerTestImpl &) = delete;
209     WallpaperEventListenerTestImpl(WallpaperEventListenerTestImpl &&) = delete;
210     WallpaperEventListenerTestImpl &operator=(WallpaperEventListenerTestImpl &&) = delete;
211 
212     // callback function will be called when the db data is changed.
213     void OnColorsChange(const std::vector<uint64_t> &color, int32_t wallpaperType) override;
214     void OnWallpaperChange(
215         WallpaperType wallpaperType, WallpaperResourceType resourceType, const std::string &uri) override;
216     // reset the callCount_ to zero.
217     void ResetToZero();
218 
219     unsigned long GetCallCount() const;
220 
221 private:
222     unsigned long callCount_;
223 };
224 
OnColorsChange(const std::vector<uint64_t> & color,int32_t wallpaperType)225 void WallpaperEventListenerTestImpl::OnColorsChange(const std::vector<uint64_t> &color, int32_t wallpaperType)
226 {
227     callCount_++;
228     for (auto const &each : color) {
229         color_.push_back(each);
230     }
231     wallpaperType_ = wallpaperType;
232 }
233 
OnWallpaperChange(WallpaperType wallpaperType,WallpaperResourceType resourceType,const std::string & uri)234 void WallpaperEventListenerTestImpl::OnWallpaperChange(
235     WallpaperType wallpaperType, WallpaperResourceType resourceType, const std::string &uri)
236 {
237     HILOG_INFO("wallpaperType: %{public}d, resourceType: %{public}d, uri: %{public}s",
238         static_cast<int32_t>(wallpaperType), static_cast<int32_t>(resourceType), uri.c_str());
239 }
240 
WallpaperEventListenerTestImpl()241 WallpaperEventListenerTestImpl::WallpaperEventListenerTestImpl()
242 {
243     callCount_ = 0;
244     wallpaperType_ = -1;
245 }
246 
ResetToZero()247 void WallpaperEventListenerTestImpl::ResetToZero()
248 {
249     callCount_ = 0;
250 }
251 
GetCallCount() const252 unsigned long WallpaperEventListenerTestImpl::GetCallCount() const
253 {
254     return callCount_;
255 }
256 
CreateTempImage()257 void WallpaperTest::CreateTempImage()
258 {
259     std::shared_ptr<PixelMap> pixelMap = CreateTempPixelMap();
260     ImagePacker imagePacker;
261     PackOption option;
262     option.format = "image/jpeg";
263     option.quality = HUNDRED;
264     option.numberHint = 1;
265     std::set<std::string> formats;
266     imagePacker.GetSupportedFormats(formats);
267     imagePacker.StartPacking(URI, option);
268     HILOG_INFO("AddImage start");
269     imagePacker.AddImage(*pixelMap);
270     int64_t packedSize = 0;
271     HILOG_INFO("FinalizePacking start");
272     imagePacker.FinalizePacking(packedSize);
273     if (packedSize == 0) {
274         HILOG_INFO("FinalizePacking error");
275     }
276 }
277 
CreateTempPixelMap()278 std::shared_ptr<PixelMap> WallpaperTest::CreateTempPixelMap()
279 {
280     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
281     InitializationOptions opts = { { 5, 7 }, OHOS::Media::PixelFormat::ARGB_8888 };
282     std::unique_ptr<PixelMap> uniquePixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
283     std::shared_ptr<PixelMap> pixelMap = std::move(uniquePixelMap);
284     return pixelMap;
285 }
286 
SubscribeCommonEvent(shared_ptr<WallpaperService> wallpaperService)287 bool WallpaperTest::SubscribeCommonEvent(shared_ptr<WallpaperService> wallpaperService)
288 {
289     subscriber = std::make_shared<WallpaperCommonEventSubscriber>(*wallpaperService);
290     if (subscriber == nullptr) {
291         HILOG_INFO("wallpaperCommonEvent is nullptr");
292         return false;
293     }
294     if (!EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber)) {
295         HILOG_INFO("SubscribeCommonEvent  failed");
296         return false;
297     }
298     return true;
299 }
300 
TriggerEvent(int32_t userId,const std::string & commonEventSupport)301 void WallpaperTest::TriggerEvent(int32_t userId, const std::string &commonEventSupport)
302 {
303     EventFwk::Want want;
304     want.SetAction(commonEventSupport);
305     int32_t code = userId;
306     std::string data(commonEventSupport);
307     EventFwk::CommonEventData eventData(want, code, data);
308     subscriber->OnReceiveEvent(eventData);
309 }
310 
GetUserFilePath(int32_t userId,const char * filePath)311 std::string WallpaperTest::GetUserFilePath(int32_t userId, const char *filePath)
312 {
313     return WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(userId) + filePath;
314 }
315 
TestCallBack(int32_t num)316 bool WallpaperTest::TestCallBack(int32_t num)
317 {
318     if (num > 0) {
319         return true;
320     }
321     return false;
322 }
323 /*********************   ResetWallpaper   *********************/
324 /**
325 * @tc.name:    Reset001
326 * @tc.desc:    Reset wallpaper with wallpaperType[0].
327 * @tc.type:    FUNC
328 * @tc.require: issueI5UHRG
329 */
330 HWTEST_F(WallpaperTest, Reset001, TestSize.Level1)
331 {
332     HILOG_INFO("Reset001 begin.");
333     ApiInfo apiInfo{ false, false };
334     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
335     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
336 }
337 
338 /**
339 * @tc.name:    Reset002
340 * @tc.desc:    Reset wallpaper with wallpaperType[1].
341 * @tc.type:    FUNC
342 * @tc.require: issueI5UHRG
343 */
344 HWTEST_F(WallpaperTest, Reset002, TestSize.Level1)
345 {
346     HILOG_INFO("Reset002 begin.");
347     ApiInfo apiInfo{ false, false };
348     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
349     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
350 }
351 
352 /**
353 * @tc.name:    Reset003
354 * @tc.desc:    Reset wallpaper with wallpaperType[2] throw parameters error.
355 * @tc.type:    FUNC
356 * @tc.require: issueI5UHRG
357 */
358 HWTEST_F(WallpaperTest, Reset003, TestSize.Level1)
359 {
360     HILOG_INFO("Reset003 begin.");
361     ApiInfo apiInfo{ false, false };
362     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(INVALID_WALLPAPER_TYPE, apiInfo);
363     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error.";
364 }
365 
366 /**
367 * @tc.name:    Reset004
368 * @tc.desc:    Reset wallpaper with wallpaperType[0] after resetting wallpaper[0].
369 * @tc.type:    FUNC
370 * @tc.require: issueI5UHRG
371 */
372 HWTEST_F(WallpaperTest, Reset004, TestSize.Level1)
373 {
374     HILOG_INFO("Reset004 begin.");
375     ApiInfo apiInfo{ false, false };
376     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
377     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
378 
379     /* duplicate reset */
380     wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
381     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
382 }
383 
384 /**
385 * @tc.name:    Reset005
386 * @tc.desc:    Reset wallpaper with wallpaperType[1] after resetting wallpaper[1] and check whether Id is same one.
387 * @tc.type:    FUNC
388 * @tc.require: issueI5UHRG
389 */
390 HWTEST_F(WallpaperTest, Reset005, TestSize.Level1)
391 {
392     HILOG_INFO("Reset005 begin.");
393     ApiInfo apiInfo{ false, false };
394     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
395     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
396     int32_t firstId = WallpaperManager::GetInstance().GetWallpaperId(LOCKSCREEN);
397 
398     /* duplicate reset */
399     wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
400     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset.";
401     int32_t secondId = WallpaperManager::GetInstance().GetWallpaperId(LOCKSCREEN);
402     EXPECT_EQ(firstId, secondId) << "Id should be same one.";
403 }
404 
405 /**
406 * @tc.name:    Reset006
407 * @tc.desc:    Reset wallpaper throw permission error
408 * @tc.type:    FUNC
409 * @tc.require: issueI5UHRG
410 */
411 HWTEST_F(WallpaperTest, Reset006, TestSize.Level1)
412 {
413     HILOG_INFO("Reset006 begin.");
414     ApiInfo apiInfo{ true, true };
415     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
416     EXPECT_EQ(wallpaperErrorCode, E_OK);
417     wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
418     EXPECT_EQ(wallpaperErrorCode, E_OK);
419 }
420 /*********************   ResetWallpaper   *********************/
421 
422 /*********************   IsChangePermitted   *********************/
423 
424 /**
425 * @tc.name: IsChangePermitted001
426 * @tc.desc: check permission.
427 * @tc.type: FUNC
428 * @tc.require:
429 * @tc.author:
430 */
431 HWTEST_F(WallpaperTest, IsChangePermitted001, TestSize.Level1)
432 {
433     EXPECT_EQ(WallpaperManager::GetInstance().IsChangePermitted(), true);
434 }
435 
436 /*********************   IsChangePermitted   *********************/
437 
438 /*********************   IsOperationAllowed   *********************/
439 
440 /**
441 * @tc.name: IsOperationAllowed001
442 * @tc.desc: check permission.
443 * @tc.type: FUNC
444 * @tc.require:
445 * @tc.author:
446 */
447 HWTEST_F(WallpaperTest, IsOperationAllowed001, TestSize.Level1)
448 {
449     EXPECT_EQ(WallpaperManager::GetInstance().IsOperationAllowed(), true);
450 }
451 
452 /*********************   IsOperationAllowed   *********************/
453 
454 /*********************   On & Off   *********************/
455 
456 /**
457 * @tc.name: On001
458 * @tc.desc: set wallpaper and get callback.
459 * @tc.type: FUNC
460 * @tc.require:
461 * @tc.author:
462 */
463 HWTEST_F(WallpaperTest, On001, TestSize.Level1)
464 {
465     HILOG_INFO("On001 begin");
466     auto listener = std::make_shared<WallpaperEventListenerTestImpl>();
467     auto status = WallpaperManager::GetInstance().On("colorChange", listener);
468     EXPECT_EQ(status, E_OK) << "subscribe wallpaper color change failed.";
469     auto offSubStatus = WallpaperManager::GetInstance().Off("colorChange", listener);
470     EXPECT_EQ(offSubStatus, E_OK) << "unsubscribe wallpaper color change failed.";
471 }
472 
473 /**
474 * @tc.name: On002
475 * @tc.desc: set wallpaper and get callback.
476 * @tc.type: FUNC
477 * @tc.require:
478 * @tc.author:
479 */
480 HWTEST_F(WallpaperTest, On002, TestSize.Level1)
481 {
482     HILOG_INFO("On002 begin");
483     auto listener = std::make_shared<WallpaperEventListenerTestImpl>();
484     auto status = WallpaperManager::GetInstance().On("wallpaperChange", listener);
485     EXPECT_EQ(status, E_OK);
486     auto offSubStatus = WallpaperManager::GetInstance().Off("wallpaperChange", listener);
487     EXPECT_EQ(offSubStatus, E_OK);
488 }
489 
490 /*********************   On & Off   *********************/
491 
492 /*********************   GetColors   *********************/
493 /**
494 * @tc.name: GetColors001
495 * @tc.desc: GetColors with wallpaperType[0].
496 * @tc.type: FUNC
497 * @tc.require:
498 * @tc.author:
499 */
500 HWTEST_F(WallpaperTest, GetColors001, TestSize.Level0)
501 {
502     HILOG_INFO("GetColors001 begin");
503     std::vector<uint64_t> colors;
504     ApiInfo apiInfo{ false, false };
505     ErrorCode errorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, colors);
506     EXPECT_EQ(errorCode, E_OK) << "Failed to GetColors.";
507     EXPECT_FALSE(colors.empty());
508 }
509 
510 /**
511 * @tc.name: GetColors002
512 * @tc.desc: GetColors with wallpaperType[1].
513 * @tc.type: FUNC
514 * @tc.require:
515 * @tc.author:
516 */
517 HWTEST_F(WallpaperTest, GetColors002, TestSize.Level0)
518 {
519     HILOG_INFO("GetColors002 begin");
520     std::vector<uint64_t> colors;
521     ApiInfo apiInfo{ false, false };
522     ErrorCode errorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, colors);
523     EXPECT_EQ(errorCode, E_OK) << "Failed to GetColors.";
524     EXPECT_FALSE(colors.empty());
525 }
526 
527 /**
528 * @tc.name: GetColors003
529 * @tc.desc: GetColors throw permission error.
530 * @tc.type: FUNC
531 * @tc.require:
532 * @tc.author:
533 */
534 HWTEST_F(WallpaperTest, GetColors003, TestSize.Level0)
535 {
536     HILOG_INFO("GetColors003 begin");
537     std::vector<uint64_t> colors;
538     ApiInfo apiInfo{ true, true };
539     ErrorCode errorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, colors);
540     EXPECT_EQ(errorCode, E_OK);
541     errorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, colors);
542     EXPECT_EQ(errorCode, E_OK);
543 }
544 /*********************   GetColors   *********************/
545 
546 /*********************   GetId   *********************/
547 /**
548 * @tc.name: GetId001
549 * @tc.desc: GetId with wallpaperType[0].
550 * @tc.type: FUNC
551 * @tc.require: issueI65VF1
552 * @tc.author: lvbai
553 */
554 HWTEST_F(WallpaperTest, GetId001, TestSize.Level0)
555 {
556     HILOG_INFO("GetId001 begin");
557     ApiInfo apiInfo{ false, false };
558     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
559     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to ResetWallpaper";
560     int32_t id = WallpaperManager::GetInstance().GetWallpaperId(SYSTYEM);
561     EXPECT_EQ(id, DEFAULT_WALLPAPER_ID) << "Failed to GetId";
562 }
563 
564 /**
565 * @tc.name: GetId002
566 * @tc.desc: GetId with wallpaperType[1].
567 * @tc.type: FUNC
568 * @tc.require: issueI65VF1
569 * @tc.author: lvbai
570 */
571 HWTEST_F(WallpaperTest, GetId002, TestSize.Level0)
572 {
573     HILOG_INFO("GetId002 begin");
574     ApiInfo apiInfo{ false, false };
575     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
576     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to ResetWallpaper";
577     int32_t id = WallpaperManager::GetInstance().GetWallpaperId(LOCKSCREEN);
578     EXPECT_EQ(id, DEFAULT_WALLPAPER_ID) << "Failed to GetId";
579 }
580 
581 /**
582 * @tc.name: GetId003
583 * @tc.desc: GetId with wallpaperType[0] after setWallpaper.
584 * @tc.type: FUNC
585 * @tc.require: issueI65VF1
586 * @tc.author: lvbai
587 */
588 HWTEST_F(WallpaperTest, GetId003, TestSize.Level0)
589 {
590     HILOG_INFO("GetId003 begin");
591     ApiInfo apiInfo{ false, false };
592     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
593     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetWallpaper";
594     int32_t id = WallpaperManager::GetInstance().GetWallpaperId(SYSTYEM);
595     EXPECT_GT(id, DEFAULT_WALLPAPER_ID) << "Failed to GetId";
596 }
597 
598 /**
599 * @tc.name: GetId004
600 * @tc.desc: GetId with wallpaperType[1] after setWallpaper.
601 * @tc.type: FUNC
602 * @tc.require: issueI65VF1
603 * @tc.author: lvbai
604 */
605 HWTEST_F(WallpaperTest, GetId004, TestSize.Level0)
606 {
607     HILOG_INFO("GetId004 begin");
608     ApiInfo apiInfo{ false, false };
609     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
610     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetWallpaper";
611     int32_t id = WallpaperManager::GetInstance().GetWallpaperId(LOCKSCREEN);
612     EXPECT_GT(id, DEFAULT_WALLPAPER_ID) << "Failed to GetId";
613 }
614 /*********************   GetId   *********************/
615 
616 /*********************   GetFile   *********************/
617 /**
618 * @tc.name:    GetFile001
619 * @tc.desc:    GetFile with wallpaperType[0].
620 * @tc.type:    FUNC
621 * @tc.require: issueI5UHRG
622 */
623 HWTEST_F(WallpaperTest, GetFile001, TestSize.Level0)
624 {
625     HILOG_INFO("GetFile001 begin");
626     int32_t wallpaperFd = 0;
627     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetFile(SYSTYEM, wallpaperFd);
628     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to get File.";
629 }
630 
631 /**
632 * @tc.name:    GetFile002
633 * @tc.desc:    GetFile with wallpaperType[1].
634 * @tc.type:    FUNC
635 * @tc.require: issueI5UHRG
636 */
637 HWTEST_F(WallpaperTest, GetFile002, TestSize.Level0)
638 {
639     HILOG_INFO("GetFile002 begin");
640     int32_t wallpaperFd = 0;
641     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetFile(LOCKSCREEN, wallpaperFd);
642     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to get File.";
643 }
644 
645 /**
646 * @tc.name:    GetFile003
647 * @tc.desc:    GetFile with wallpaperType[2] throw parameters error.
648 * @tc.type:    FUNC
649 * @tc.require: issueI5UHRG
650 */
651 HWTEST_F(WallpaperTest, GetFile003, TestSize.Level0)
652 {
653     HILOG_INFO("GetFile003 begin");
654     int32_t wallpaperFd = 0;
655     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetFile(INVALID_WALLPAPER_TYPE, wallpaperFd);
656     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw parameters error";
657 }
658 
659 /**
660 * @tc.name:    GetFile004
661 * @tc.desc:    GetFile with wallpaperType[0].
662 * @tc.type:    FUNC
663 * @tc.require:
664 * @tc.author:
665 */
666 HWTEST_F(WallpaperTest, GetFile004, TestSize.Level0)
667 {
668     HILOG_INFO("GetFile001 begin");
669     int32_t wallpaperFd = 0;
670     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetFile(SYSTYEM, wallpaperFd);
671     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to get File.";
672 }
673 /*********************   GetFile   *********************/
674 
675 /*********************   GetWallpaperMinHeight   *********************/
676 /**
677 * @tc.name: getMinHeight001
678 * @tc.desc: GetWallpaperMinHeight .
679 * @tc.type: FUNC
680 * @tc.require:
681 */
682 HWTEST_F(WallpaperTest, getMinHeight001, TestSize.Level0)
683 {
684     HILOG_INFO("getMinHeight001  begin");
685     int32_t height = 0;
686     ApiInfo apiInfo{ false, false };
687     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetWallpaperMinHeight(apiInfo, height);
688     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to get WallpaperMinHeight.";
689     EXPECT_GT(height, 0);
690 }
691 
692 /**
693 * @tc.name: getMinHeight002
694 * @tc.desc: GetWallpaperMinHeight throw permission error.
695 * @tc.type: FUNC
696 * @tc.require:
697 */
698 HWTEST_F(WallpaperTest, getMinHeight002, TestSize.Level0)
699 {
700     HILOG_INFO("getMinHeight002  begin");
701     int32_t height = 0;
702     ApiInfo apiInfo{ true, true };
703     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetWallpaperMinHeight(apiInfo, height);
704     EXPECT_EQ(wallpaperErrorCode, E_OK);
705 }
706 /*********************   GetWallpaperMinHeight   *********************/
707 
708 /*********************   GetWallpaperMinWidth   *********************/
709 /**
710 * @tc.name: getMinWidth001
711 * @tc.desc: GetWallpaperMinWidth .
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(WallpaperTest, getMinWidth001, TestSize.Level0)
716 {
717     HILOG_INFO("getMinWidth001  begin");
718     int32_t width = 0;
719     ApiInfo apiInfo{ false, false };
720     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetWallpaperMinWidth(apiInfo, width);
721     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to get WallpaperMinWidth.";
722     EXPECT_GT(width, 0);
723 }
724 
725 /**
726 * @tc.name: getMinWidth002
727 * @tc.desc: GetWallpaperMinWidth throw permission error.
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(WallpaperTest, getMinWidth002, TestSize.Level0)
732 {
733     HILOG_INFO("getMinWidth002  begin");
734     int32_t width = 0;
735     ApiInfo apiInfo{ true, true };
736     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetWallpaperMinWidth(apiInfo, width);
737     EXPECT_EQ(wallpaperErrorCode, E_OK);
738 }
739 /*********************   GetWallpaperMinWidth   *********************/
740 
741 /*********************   GetPixelMap   *********************/
742 /**
743 * @tc.name:    GetPixelMap001
744 * @tc.desc:    GetPixelMap with wallpaperType[0].
745 * @tc.type:    FUNC
746 * @tc.require: issueI5UHRG
747 */
748 HWTEST_F(WallpaperTest, GetPixelMap001, TestSize.Level0)
749 {
750     HILOG_INFO("GetPixelMap001  begin");
751     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
752     ApiInfo apiInfo{ false, false };
753     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetPixelMap(SYSTYEM, apiInfo, pixelMap);
754     EXPECT_EQ(wallpaperErrorCode, E_OK);
755 }
756 
757 /**
758 * @tc.name:    GetPixelMap002
759 * @tc.desc:    GetPixelMap with wallpaperType[1].
760 * @tc.type:    FUNC
761 * @tc.require: issueI5UHRG
762 */
763 HWTEST_F(WallpaperTest, GetPixelMap002, TestSize.Level0)
764 {
765     HILOG_INFO("GetPixelMap002  begin");
766     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
767     ApiInfo apiInfo{ false, false };
768     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetPixelMap(LOCKSCREEN, apiInfo, pixelMap);
769     EXPECT_EQ(wallpaperErrorCode, E_OK);
770 }
771 
772 /**
773 * @tc.name:    GetPixelMap003
774 * @tc.desc:    GetPixelMap throw permission error.
775 * @tc.type:    FUNC
776 * @tc.require:
777 */
778 HWTEST_F(WallpaperTest, GetPixelMap003, TestSize.Level0)
779 {
780     HILOG_INFO("GetPixelMap003  begin");
781     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
782     ApiInfo apiInfo{ true, true };
783     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().GetPixelMap(LOCKSCREEN, apiInfo, pixelMap);
784     EXPECT_EQ(wallpaperErrorCode, E_OK);
785     wallpaperErrorCode = WallpaperManager::GetInstance().GetPixelMap(SYSTYEM, apiInfo, pixelMap);
786     EXPECT_EQ(wallpaperErrorCode, E_OK);
787 }
788 /*********************   GetPixelMap   *********************/
789 
790 /*********************   SetWallpaperByMap   *********************/
791 /**
792 * @tc.name:    SetWallpaperByMap001
793 * @tc.desc:    SetWallpaperByMap with wallpaperType[0].
794 * @tc.type:    FUNC
795 * @tc.require: issueI5UHRG
796 */
797 HWTEST_F(WallpaperTest, SetWallpaperByMap001, TestSize.Level0)
798 {
799     HILOG_INFO("SetWallpaperByMap001  begin");
800     std::shared_ptr<PixelMap> pixelMap = WallpaperTest::CreateTempPixelMap();
801     ApiInfo apiInfo{ false, false };
802     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(pixelMap, SYSTYEM, apiInfo);
803     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set SYSTYEM PixelMap.";
804 }
805 
806 /**
807 * @tc.name:    SetWallpaperByMap002
808 * @tc.desc:    SetWallpaperByMap with wallpaperType[1].
809 * @tc.type:    FUNC
810 * @tc.require: issueI5UHRG
811 */
812 HWTEST_F(WallpaperTest, SetWallpaperByMap002, TestSize.Level0)
813 {
814     HILOG_INFO("SetWallpaperByMap002  begin");
815     std::shared_ptr<PixelMap> pixelMap = WallpaperTest::CreateTempPixelMap();
816     ApiInfo apiInfo{ false, false };
817     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(pixelMap, LOCKSCREEN, apiInfo);
818     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set LOCKSCREEN PixelMap.";
819 }
820 
821 /**
822 * @tc.name:    SetWallpaperByMap003
823 * @tc.desc:    SetWallpaperByMap with wallpaperType[2] throw parameters error.
824 * @tc.type:    FUNC
825 * @tc.require: issueI5UHRG
826 */
827 HWTEST_F(WallpaperTest, SetWallpaperByMap003, TestSize.Level0)
828 {
829     HILOG_INFO("SetWallpaperByMap003  begin");
830     std::shared_ptr<PixelMap> pixelMap = WallpaperTest::CreateTempPixelMap();
831     ApiInfo apiInfo{ false, false };
832     ErrorCode wallpaperErrorCode =
833         WallpaperManager::GetInstance().SetWallpaper(pixelMap, INVALID_WALLPAPER_TYPE, apiInfo);
834     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw parameters error";
835 }
836 /*********************   SetWallpaperByMap   *********************/
837 
838 /*********************   SetWallpaperByUri   *********************/
839 /**
840 * @tc.name:    SetWallpaperByUri001
841 * @tc.desc:    SetWallpaperByUri with wallpaperType[0] .
842 * @tc.type:    FUNC
843 * @tc.require: issueI5UHRG
844 */
845 HWTEST_F(WallpaperTest, SetWallpaperByUri001, TestSize.Level0)
846 {
847     HILOG_INFO("SetWallpaperByUri001  begin");
848     ApiInfo apiInfo{ false, false };
849     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
850     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set SYSTYEM.";
851 }
852 
853 /**
854 * @tc.name:    SetWallpaperByUri002
855 * @tc.desc:    SetWallpaperByUri with wallpaperType[1].
856 * @tc.type:    FUNC
857 * @tc.require: issueI5UHRG
858 */
859 HWTEST_F(WallpaperTest, SetWallpaperByUri002, TestSize.Level0)
860 {
861     HILOG_INFO("SetWallpaperByUri002  begin");
862     ApiInfo apiInfo{ false, false };
863     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
864     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set LOCKSCREEN.";
865 }
866 
867 /**
868 * @tc.name:    SetWallpaperByUri003
869 * @tc.desc:    SetWallpaperByUri with wallpaperType[2] throw parameters error.
870 * @tc.type:    FUNC
871 * @tc.require: issueI5UHRG
872 */
873 HWTEST_F(WallpaperTest, SetWallpaperByUri003, TestSize.Level0)
874 {
875     HILOG_INFO("SetWallpaperByUri003  begin");
876     ApiInfo apiInfo{ false, false };
877     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, INVALID_WALLPAPER_TYPE, apiInfo);
878     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error";
879 }
880 
881 /**
882 * @tc.name:    SetWallpaperByUri004
883 * @tc.desc:    SetWallpaperByUri with error uri.
884 * @tc.type:    FUNC
885 * @tc.require: issueI5UHRG
886 */
887 HWTEST_F(WallpaperTest, SetWallpaperByUri004, TestSize.Level0)
888 {
889     HILOG_INFO("SetWallpaperByUri004  begin");
890     ApiInfo apiInfo{ false, false };
891     ErrorCode wallpaperErrorCode =
892         WallpaperManager::GetInstance().SetWallpaper("/data/test/theme/wallpaper/errorURI", LOCKSCREEN, apiInfo);
893     EXPECT_NE(wallpaperErrorCode, E_OK) << "Failed to throw error";
894 }
895 
896 /**
897 * @tc.name:    SetWallpaperByUri005
898 * @tc.desc:    SetWallpaperByUri with unsafe uri.
899 * @tc.type:    FUNC
900 * @tc.require: issueI647HI
901 */
902 HWTEST_F(WallpaperTest, SetWallpaperByUri005, TestSize.Level0)
903 {
904     HILOG_INFO("SetWallpaperByUri005  begin");
905     ApiInfo apiInfo{ false, false };
906     ErrorCode wallpaperErrorCode =
907         WallpaperManager::GetInstance().SetWallpaper("../data/test/theme/wallpaper/errorURI", LOCKSCREEN, apiInfo);
908     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to return error";
909 }
910 
911 /**
912 * @tc.name:    SetWallpaperByUri006
913 * @tc.desc:    SetWallpaperByUri throw permission error.
914 * @tc.type:    FUNC
915 * @tc.require:
916 */
917 HWTEST_F(WallpaperTest, SetWallpaperByUri006, TestSize.Level0)
918 {
919     HILOG_INFO("SetWallpaperByUri006  begin");
920     ApiInfo apiInfo{ true, true };
921     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
922     EXPECT_EQ(wallpaperErrorCode, E_OK);
923     wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
924     EXPECT_EQ(wallpaperErrorCode, E_OK);
925 }
926 
927 /**
928 * @tc.name:    SetWallpaperByUri007
929 * @tc.desc:    SetWallpaperByUri throw permission error.
930 * @tc.type:    FUNC
931 * @tc.require:
932 */
933 HWTEST_F(WallpaperTest, SetWallpaperByUri007, TestSize.Level0)
934 {
935     HILOG_INFO("SetWallpaperByUri007  begin");
936     ApiInfo apiInfo{ true, true };
937     WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
938     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
939     int32_t userId = wallpaperService->QueryActiveUserId();
940     HILOG_INFO("guochao  userId:%{public}d", userId);
941     bool ret = FileDeal::IsFileExist(WallpaperTest::GetUserFilePath(userId, LOCKSCREEN_FILE));
942     EXPECT_EQ(ret, false) << "Failed to reset.";
943     WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
944     ret = FileDeal::IsFileExist(WallpaperTest::GetUserFilePath(userId, LOCKSCREEN_FILE));
945     EXPECT_EQ(ret, true);
946     WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
947 }
948 
949 /*********************   SetWallpaperByUri   *********************/
950 
951 /*********************   FILE_DEAL   *********************/
952 /**
953 * @tc.name:    FILE_DEAL001
954 * @tc.desc:    File operation-related interfaces
955 * @tc.type:    FUNC
956 * @tc.require:
957 * @tc.author:
958 */
959 HWTEST_F(WallpaperTest, FILE_DEAL001, TestSize.Level0)
960 {
961     HILOG_INFO("FILE_DEAL001  begin");
962     FileDeal fileOperation;
963     bool isExist = fileOperation.Mkdir("/data/test/theme/wallpaper/");
964     EXPECT_EQ(isExist, true);
965     isExist = fileOperation.Mkdir("/data/test/theme/errorURI/");
966     EXPECT_EQ(isExist, true);
967     isExist = fileOperation.IsFileExist(URI);
968     EXPECT_EQ(isExist, true);
969     isExist = fileOperation.IsFileExist("/data/test/theme/wallpaper/errorURI");
970     EXPECT_EQ(isExist, false);
971 }
972 /*********************   FILE_DEAL   *********************/
973 
974 /**
975 * @tc.name:    SetWallpaper001
976 * @tc.desc:    SetWallpaper with error length
977 * @tc.type:    FUNC
978 * @tc.require: issueI6AW6M
979 * @tc.author:  weishaoxiong
980 */
981 HWTEST_F(WallpaperTest, SetWallpaper001, TestSize.Level0)
982 {
983     HILOG_INFO("SetWallpaper001  begin");
984     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
985     ErrorCode wallpaperErrorCode = wallpaperService->SetWallpaper(0, 0, -1);
986     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error";
987     wallpaperErrorCode = wallpaperService->SetWallpaper(0, 0, FOO_MAX_LEN);
988 
989     EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error";
990 }
991 
992 /*********************   USER_DEAL   *********************/
993 /**
994 * @tc.name:    AddUsersDeal001
995 * @tc.desc:    Create a user directory after the user is added
996 * @tc.type:    FUNC
997 * @tc.require: issueI6DWHR
998 */
999 HWTEST_F(WallpaperTest, AddUsersDeal001, TestSize.Level0)
1000 {
1001     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1002     bool ret = WallpaperTest::SubscribeCommonEvent(wallpaperService);
1003     ASSERT_EQ(ret, true);
1004     std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1005     WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1006     ret = FileDeal::IsDirExist(WallpaperTest::GetUserFilePath(TEST_USERID, SYSTEM_DIR));
1007     EXPECT_EQ(ret, true);
1008     ret = FileDeal::IsDirExist(WallpaperTest::GetUserFilePath(TEST_USERID, LOCKSCREEN_DIR));
1009     EXPECT_EQ(ret, true);
1010     std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1011     if (!OHOS::ForceRemoveDirectory(userDir)) {
1012         HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1013     }
1014 }
1015 
1016 /**
1017 * @tc.name:    RemovedUserDeal001
1018 * @tc.desc:    delete a user directory after the user is removed
1019 * @tc.type:    FUNC
1020 * @tc.require: issueI6DWHR
1021 */
1022 HWTEST_F(WallpaperTest, RemovedUserDeal001, TestSize.Level0)
1023 {
1024     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1025     ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1026     std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1027     WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1028     std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1029     ASSERT_EQ(FileDeal::IsDirExist(userDir), true);
1030 
1031     commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1032     WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1033     EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1034     if (!OHOS::ForceRemoveDirectory(userDir)) {
1035         HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1036     }
1037 }
1038 
1039 /**
1040 * @tc.name:    SwitchedUserIdDeal001
1041 * @tc.desc:    The wallpaper has changed after switched user
1042 * @tc.type:    FUNC
1043 * @tc.require: issueI6DWHR
1044 */
1045 HWTEST_F(WallpaperTest, SwitchedUserIdDeal001, TestSize.Level0)
1046 {
1047     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1048     wallpaperService->InitServiceHandler();
1049     ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1050     ApiInfo apiInfo{ false, false };
1051     std::vector<int32_t> ids;
1052     AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
1053     int32_t beforeUserId = ids[0];
1054     std::string addCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1055     WallpaperTest::TriggerEvent(TEST_USERID, addCommonEvent);
1056     std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1057     ASSERT_EQ(FileDeal::IsDirExist(userDir), true);
1058     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
1059     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset lockscreen wallpaper";
1060 
1061     std::vector<uint64_t> oldLockscreenColor;
1062     wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, oldLockscreenColor);
1063     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1064     wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
1065     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset system wallpaper";
1066     std::vector<uint64_t> oldSystemColor;
1067     wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, oldSystemColor);
1068     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1069 
1070     std::string switchCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED;
1071     WallpaperTest::TriggerEvent(TEST_USERID, switchCommonEvent);
1072     wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
1073     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set lockscreen wallpaper";
1074     std::vector<uint64_t> newLockscreenColor;
1075     wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, newLockscreenColor);
1076     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1077     wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
1078     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set system wallpaper";
1079     std::vector<uint64_t> newSystemColor;
1080     wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, newSystemColor);
1081     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1082     EXPECT_NE(oldLockscreenColor, newLockscreenColor);
1083     EXPECT_NE(oldSystemColor, newSystemColor);
1084 
1085     WallpaperTest::TriggerEvent(beforeUserId, switchCommonEvent);
1086     std::string removeCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1087     WallpaperTest::TriggerEvent(TEST_USERID, removeCommonEvent);
1088     EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1089     if (!OHOS::ForceRemoveDirectory(userDir)) {
1090         HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1091     }
1092 }
1093 
1094 /**
1095 * @tc.name:    InvalidUserIdDeal001
1096 * @tc.desc:    Invalid user id deal
1097 * @tc.type:    FUNC
1098 * @tc.require: issueI6DWHR
1099 */
1100 HWTEST_F(WallpaperTest, InvalidUserIdDeal001, TestSize.Level0)
1101 {
1102     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1103     wallpaperService->InitServiceHandler();
1104     ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1105     std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1106     WallpaperTest::TriggerEvent(INVALID_USERID, commonEvent);
1107     std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(INVALID_USERID);
1108     EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1109     FileDeal::Mkdir(userDir);
1110     commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1111     WallpaperTest::TriggerEvent(INVALID_USERID, commonEvent);
1112     EXPECT_EQ(FileDeal::IsDirExist(userDir), true);
1113     if (!OHOS::ForceRemoveDirectory(userDir)) {
1114         HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1115     }
1116 }
1117 /*********************   USER_DEAL   *********************/
1118 
1119 /*********************   SetVideo    *********************/
1120 /**
1121  * @tc.name:    SetVideo001
1122  * @tc.desc:    SetVideo input error fileType
1123  * @tc.type:    FUNC
1124  * @tc.require: issueI6R07J
1125  */
1126 HWTEST_F(WallpaperTest, SetVideo001, TestSize.Level0)
1127 {
1128     HILOG_INFO("SetVideo001 begin");
1129     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MOV, SYSTYEM);
1130     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1131 }
1132 
1133 /**
1134  * @tc.name:    SetVideo002
1135  * @tc.desc:    SetVideo input error uri
1136  * @tc.type:    FUNC
1137  * @tc.require: issueI6R07J
1138  */
1139 HWTEST_F(WallpaperTest, SetVideo002, TestSize.Level0)
1140 {
1141     HILOG_INFO("SetVideo002 begin");
1142     std::string errUri = "errorPath/zm_30fps_4s.mp4";
1143     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(errUri, SYSTYEM);
1144     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1145 }
1146 
1147 /**
1148  * @tc.name:    SetVideo003
1149  * @tc.desc:    SetVideo input correct parameter
1150  * @tc.type:    FUNC
1151  * @tc.require: issueI6R07J
1152  */
1153 HWTEST_F(WallpaperTest, SetVideo003, TestSize.Level0)
1154 {
1155     HILOG_INFO("SetVideo003 begin");
1156     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MP4, SYSTYEM);
1157     EXPECT_EQ(ret, E_OK);
1158 }
1159 
1160 /**
1161  * @tc.name:    SetVideo004
1162  * @tc.desc:    SetVideo input error duration
1163  * @tc.type:    FUNC
1164  * @tc.require: issueI6R07J
1165  */
1166 HWTEST_F(WallpaperTest, SetVideo004, TestSize.Level0)
1167 {
1168     HILOG_INFO("SetVideo004 begin");
1169     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_15FPS_7S_MP4, SYSTYEM);
1170     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1171 }
1172 
1173 /**
1174  * @tc.name:    SetVideo005
1175  * @tc.desc:    SetVideo input error fileType
1176  * @tc.type:    FUNC
1177  * @tc.require: issueI6R07J
1178  */
1179 HWTEST_F(WallpaperTest, SetVideo005, TestSize.Level0)
1180 {
1181     HILOG_INFO("SetVideo005 begin");
1182     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MOV, LOCKSCREEN);
1183     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1184 }
1185 
1186 /**
1187  * @tc.name:    SetVideo006
1188  * @tc.desc:    SetVideo input error uri
1189  * @tc.type:    FUNC
1190  * @tc.require: issueI6R07J
1191  */
1192 HWTEST_F(WallpaperTest, SetVideo006, TestSize.Level0)
1193 {
1194     HILOG_INFO("SetVideo006 begin");
1195     std::string errUri = "errorPath/zm_30fps_4s.mp4";
1196     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(errUri, LOCKSCREEN);
1197     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1198 }
1199 
1200 /**
1201  * @tc.name:    SetVideo007
1202  * @tc.desc:    SetVideo input correct parameter
1203  * @tc.type:    FUNC
1204  * @tc.require: issueI6R07J
1205  */
1206 HWTEST_F(WallpaperTest, SetVideo007, TestSize.Level0)
1207 {
1208     HILOG_INFO("SetVideo007 begin");
1209     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MP4, LOCKSCREEN);
1210     EXPECT_EQ(ret, E_OK);
1211 }
1212 
1213 /**
1214  * @tc.name:    SetVideo008
1215  * @tc.desc:    SetVideo input error duration
1216  * @tc.type:    FUNC
1217  * @tc.require: issueI6R07J
1218  */
1219 HWTEST_F(WallpaperTest, SetVideo008, TestSize.Level0)
1220 {
1221     HILOG_INFO("SetVideo008 begin");
1222     ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_15FPS_7S_MP4, LOCKSCREEN);
1223     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1224 }
1225 /*********************   SetVideo    *********************/
1226 
1227 /**
1228  * @tc.name:    SetCustomWallpaper001
1229  * @tc.desc:    Set a custom wallpaper in the Sceneborad scene
1230  * @tc.type:    FUNC
1231  * @tc.require: issueI7AAMU
1232  */
1233 HWTEST_F(WallpaperTest, SetCustomWallpaper001, TestSize.Level0)
1234 {
1235     HILOG_INFO("SetCustomWallpaper001 begin");
1236     ErrorCode testErrorCode = E_OK;
1237     if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1238         testErrorCode = E_NO_PERMISSION;
1239     }
1240     ErrorCode ret = WallpaperManager::GetInstance().SetCustomWallpaper(URI_ZIP, SYSTYEM);
1241     EXPECT_EQ(ret, testErrorCode);
1242     ret = WallpaperManager::GetInstance().SetCustomWallpaper(URI_ZIP, LOCKSCREEN);
1243     EXPECT_EQ(ret, testErrorCode);
1244 }
1245 
1246 /*********************   SendEvent    *********************/
1247 
1248 /**
1249  * @tc.name:    SendEvent001
1250  * @tc.desc:    SetVideo input error fileType
1251  * @tc.type:    FUNC
1252  * @tc.require: issueI6R07J
1253  */
1254 HWTEST_F(WallpaperTest, SendEvent001, TestSize.Level0)
1255 {
1256     HILOG_INFO("SendEvent001 begin");
1257     std::string errEventType = "SHOW_ERROREVENTTYPE";
1258     ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_ERROREVENTTYPE");
1259     EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1260 }
1261 
1262 /**
1263  * @tc.name:    SendEvent002
1264  * @tc.desc:    SetVideo input error fileType
1265  * @tc.type:    FUNC
1266  * @tc.require: issueI6R07J
1267  */
1268 HWTEST_F(WallpaperTest, SendEvent002, TestSize.Level0)
1269 {
1270     HILOG_INFO("SendEvent002 begin");
1271     ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_SYSTEMSCREEN");
1272     EXPECT_EQ(ret, E_OK);
1273 }
1274 
1275 /**
1276  * @tc.name:    SendEvent003
1277  * @tc.desc:    SetVideo input error fileType
1278  * @tc.type:    FUNC
1279  * @tc.require: issueI6R07J
1280  */
1281 HWTEST_F(WallpaperTest, SendEvent003, TestSize.Level0)
1282 {
1283     HILOG_INFO("SendEvent003 begin");
1284     ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_LOCKSCREEN");
1285     EXPECT_EQ(ret, E_OK);
1286 }
1287 
1288 /**
1289  * @tc.name:    WallpaperTest_001
1290  * @tc.desc:    Test Onstop and OnStart.
1291  * @tc.type:    FUNC
1292  * @tc.require: issueI7OUB6
1293  */
1294 HWTEST_F(WallpaperTest, WallpaperTest_001, TestSize.Level0)
1295 {
1296     HILOG_INFO("Test Onstop");
1297     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1298     wallpaperService->state_ = WallpaperService::ServiceRunningState::STATE_RUNNING;
1299     wallpaperService->OnStop();
1300     EXPECT_EQ(wallpaperService->state_, WallpaperService::ServiceRunningState::STATE_NOT_START);
1301 }
1302 
1303 /**
1304  * @tc.name:    GetPictureFileName_001
1305  * @tc.desc:    Load userIds that are not found in the Map.
1306  * @tc.type:    FUNC
1307  * @tc.require: issueI90IUI
1308  */
1309 HWTEST_F(WallpaperTest, GetPictureFileName_001, TestSize.Level0)
1310 {
1311     HILOG_INFO("GetPictureFileName_001 begin");
1312     std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1313     std::string fileName;
1314     wallpaperService->GetPictureFileName(TEST_USERID1, WALLPAPER_SYSTEM, fileName);
1315     auto wallpaperDefault = fileName.find(WALLPAPER_DEFAULT);
1316     auto homeWallpaper = fileName.find(HOME_WALLPAPER);
1317     EXPECT_EQ((wallpaperDefault != string::npos) || (homeWallpaper != string::npos), true);
1318     wallpaperService->SetWallpaperBackupData(TEST_USERID1, PICTURE, URI, WALLPAPER_SYSTEM);
1319     wallpaperService->GetPictureFileName(TEST_USERID1, WALLPAPER_SYSTEM, fileName);
1320     auto pos = fileName.find(to_string(TEST_USERID1));
1321     EXPECT_NE(pos, string::npos);
1322     wallpaperService->OnRemovedUser(TEST_USERID1);
1323 }
1324 
1325 /**
1326  * @tc.name:    RegisterWallpaperCallback_001
1327  * @tc.desc:    Test RegisterWallpaperCallback
1328  * @tc.type:    FUNC
1329  * @tc.require: issueIA87VK
1330  */
1331 HWTEST_F(WallpaperTest, RegisterWallpaperCallback_001, TestSize.Level0)
1332 {
1333     HILOG_INFO("RegisterWallpaperCallback_001 begin");
1334     JScallback callback = &WallpaperTest::TestCallBack;
1335     bool res = WallpaperManager::GetInstance().RegisterWallpaperCallback(callback);
1336     EXPECT_EQ(res, true);
1337 }
1338 
1339 /**
1340  * @tc.name:    RegisterWallpaperListener_001
1341  * @tc.desc:    Test RegisterWallpaperListener
1342  * @tc.type:    FUNC
1343  * @tc.require: issueIA87VK
1344  */
1345 HWTEST_F(WallpaperTest, RegisterWallpaperListener_001, TestSize.Level0)
1346 {
1347     HILOG_INFO("RegisterWallpaperListener_001 begin");
1348     bool res = WallpaperManager::GetInstance().RegisterWallpaperListener();
1349     EXPECT_EQ(res, true);
1350 }
1351 
1352 /*********************   SetAllWallpapers   *********************/
1353 /**
1354 * @tc.name: SetAllWallpapers001
1355 * @tc.desc: SetAllWallpapers normal device with wallpaperType[0]
1356 * @tc.type: FUNC
1357 * @tc.require:
1358 */
1359 HWTEST_F(WallpaperTest, SetAllWallpapers001, TestSize.Level0)
1360 {
1361     HILOG_INFO("SetAllWallpapers001 begin");
1362     std::vector<WallpaperInfo> wallpaperInfo;
1363     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1364     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1365     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1366     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1367 }
1368 
1369 /**
1370 * @tc.name: SetAllWallpapers002
1371 * @tc.desc: SetAllWallpapers normal device with wallpaperType[1]
1372 * @tc.type: FUNC
1373 * @tc.require:
1374 */
1375 HWTEST_F(WallpaperTest, SetAllWallpapers002, TestSize.Level0)
1376 {
1377     HILOG_INFO("SetAllWallpapers002 begin");
1378     std::vector<WallpaperInfo> wallpaperInfo;
1379     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1380     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1381     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1382     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1383 }
1384 
1385 /**
1386 * @tc.name: SetAllWallpapers003
1387 * @tc.desc: SetAllWallpapers unfold_1 device with wallpaperType[0]
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(WallpaperTest, SetAllWallpapers003, TestSize.Level0)
1392 {
1393     HILOG_INFO("SetAllWallpapers003 begin");
1394     std::vector<WallpaperInfo> wallpaperInfo;
1395     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1396     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1397     wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1398     wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1399     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1400     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1401 }
1402 
1403 /**
1404 * @tc.name: SetAllWallpapers004
1405 * @tc.desc: SetAllWallpapers unfold_1 device with wallpaperType[1]
1406 * @tc.type: FUNC
1407 * @tc.require:
1408 */
1409 HWTEST_F(WallpaperTest, SetAllWallpapers004, TestSize.Level0)
1410 {
1411     HILOG_INFO("SetAllWallpapers004 begin");
1412     std::vector<WallpaperInfo> wallpaperInfo;
1413     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1414     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1415     wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1416     wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1417     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1418     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1419 }
1420 
1421 /**
1422 * @tc.name: SetAllWallpapers005
1423 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[0]
1424 * @tc.type: FUNC
1425 * @tc.require:
1426 */
1427 HWTEST_F(WallpaperTest, SetAllWallpapers005, TestSize.Level0)
1428 {
1429     HILOG_INFO("SetAllWallpapers005 begin");
1430     std::vector<WallpaperInfo> wallpaperInfo;
1431     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1432     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1433     wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1434     wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1435     wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1436     wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1437     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1438     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1439 }
1440 
1441 /**
1442 * @tc.name: SetAllWallpapers006
1443 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[1]
1444 * @tc.type: FUNC
1445 * @tc.require:
1446 */
1447 HWTEST_F(WallpaperTest, SetAllWallpapers006, TestSize.Level0)
1448 {
1449     HILOG_INFO("SetAllWallpapers006 begin");
1450     std::vector<WallpaperInfo> wallpaperInfo;
1451     wallpaperInfo.push_back(wallpaperInfo_normal_port);
1452     wallpaperInfo.push_back(wallpaperInfo_normal_land);
1453     wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1454     wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1455     wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1456     wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1457     ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1458     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1459 }
1460 
1461 /*********************   SetAllWallpapers   *********************/
1462 
1463 /*********************   GetCorrespondWallpaper   *********************/
1464 /**
1465 * @tc.name:   GetCorrespondWallpaper001
1466 * @tc.desc:   GetCorrespondWallpaper normal device with wallpaperType[0].
1467 * @tc.type:    FUNC
1468 * @tc.require:
1469 */
1470 HWTEST_F(WallpaperTest, GetCorrespondWallpaper001, TestSize.Level0)
1471 {
1472     HILOG_INFO("GetCorrespondWallpaper001  begin");
1473     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1474     ErrorCode wallpaperErrorCode =
1475         WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, NORMAL, PORT, pixelMap);
1476     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1477     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, NORMAL, LAND, pixelMap);
1478     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1479 }
1480 
1481 /**
1482 * @tc.name:   GetCorrespondWallpaper002
1483 * @tc.desc:   GetCorrespondWallpaper normal device with wallpaperType[1].
1484 * @tc.type:    FUNC
1485 * @tc.require:
1486 */
1487 HWTEST_F(WallpaperTest, GetCorrespondWallpaper002, TestSize.Level0)
1488 {
1489     HILOG_INFO("GetPixelMap002  begin");
1490     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1491     ErrorCode wallpaperErrorCode =
1492         WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, NORMAL, PORT, pixelMap);
1493     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1494     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, NORMAL, LAND, pixelMap);
1495     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1496 }
1497 
1498 /**
1499 * @tc.name:   GetCorrespondWallpaper003
1500 * @tc.desc:   GetCorrespondWallpaper unfold_1 device with wallpaperType[0].
1501 * @tc.type:    FUNC
1502 * @tc.require:
1503 */
1504 HWTEST_F(WallpaperTest, GetCorrespondWallpaper003, TestSize.Level0)
1505 {
1506     HILOG_INFO("GetCorrespondWallpaper003  begin");
1507     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1508     ErrorCode wallpaperErrorCode =
1509         WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_1, PORT, pixelMap);
1510     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1511     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_1, LAND, pixelMap);
1512     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1513 }
1514 
1515 /**
1516 * @tc.name:   GetCorrespondWallpaper004
1517 * @tc.desc:   GetCorrespondWallpaper unfold_1 device with wallpaperType[1].
1518 * @tc.type:    FUNC
1519 * @tc.require:
1520 */
1521 HWTEST_F(WallpaperTest, GetCorrespondWallpaper004, TestSize.Level0)
1522 {
1523     HILOG_INFO("GetCorrespondWallpaper004  begin");
1524     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1525     ErrorCode wallpaperErrorCode =
1526         WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_1, PORT, pixelMap);
1527     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1528     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_1, LAND, pixelMap);
1529     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1530 }
1531 
1532 /**
1533 * @tc.name:   GetCorrespondWallpaper005
1534 * @tc.desc:   GetCorrespondWallpaper unfold_2 device with wallpaperType[0].
1535 * @tc.type:    FUNC
1536 * @tc.require:
1537 */
1538 HWTEST_F(WallpaperTest, GetCorrespondWallpaper005, TestSize.Level0)
1539 {
1540     HILOG_INFO("GetCorrespondWallpaper005  begin");
1541     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1542     ErrorCode wallpaperErrorCode =
1543         WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_2, PORT, pixelMap);
1544     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1545     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_2, LAND, pixelMap);
1546     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1547 }
1548 
1549 /**
1550 * @tc.name:   GetCorrespondWallpaper006
1551 * @tc.desc:   GetCorrespondWallpaper unfold_2 device with wallpaperType[1].
1552 * @tc.type:    FUNC
1553 * @tc.require:
1554 */
1555 HWTEST_F(WallpaperTest, GetCorrespondWallpaper006, TestSize.Level0)
1556 {
1557     HILOG_INFO("GetCorrespondWallpaper006  begin");
1558     std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1559     ErrorCode wallpaperErrorCode =
1560         WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_2, PORT, pixelMap);
1561     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1562     wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_2, LAND, pixelMap);
1563     EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1564 }
1565 /*********************   GetCorrespondWallpaper   *********************/
1566 } // namespace WallpaperMgrService
1567 } // namespace OHOS