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