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 = 1;
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 }
807
808 /**
809 * @tc.name: SetWallpaperByMap002
810 * @tc.desc: SetWallpaperByMap with wallpaperType[1].
811 * @tc.type: FUNC
812 * @tc.require: issueI5UHRG
813 */
814 HWTEST_F(WallpaperTest, SetWallpaperByMap002, TestSize.Level0)
815 {
816 HILOG_INFO("SetWallpaperByMap002 begin");
817 std::shared_ptr<PixelMap> pixelMap = WallpaperTest::CreateTempPixelMap();
818 ApiInfo apiInfo{ false, false };
819 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(pixelMap, LOCKSCREEN, apiInfo);
820 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set LOCKSCREEN PixelMap.";
821 }
822
823 /**
824 * @tc.name: SetWallpaperByMap003
825 * @tc.desc: SetWallpaperByMap with wallpaperType[2] throw parameters error.
826 * @tc.type: FUNC
827 * @tc.require: issueI5UHRG
828 */
829 HWTEST_F(WallpaperTest, SetWallpaperByMap003, TestSize.Level0)
830 {
831 HILOG_INFO("SetWallpaperByMap003 begin");
832 std::shared_ptr<PixelMap> pixelMap = WallpaperTest::CreateTempPixelMap();
833 ApiInfo apiInfo{ false, false };
834 ErrorCode wallpaperErrorCode =
835 WallpaperManager::GetInstance().SetWallpaper(pixelMap, INVALID_WALLPAPER_TYPE, apiInfo);
836 EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw parameters error";
837 }
838 /********************* SetWallpaperByMap *********************/
839
840 /********************* SetWallpaperByUri *********************/
841 /**
842 * @tc.name: SetWallpaperByUri001
843 * @tc.desc: SetWallpaperByUri with wallpaperType[0] .
844 * @tc.type: FUNC
845 * @tc.require: issueI5UHRG
846 */
847 HWTEST_F(WallpaperTest, SetWallpaperByUri001, TestSize.Level0)
848 {
849 HILOG_INFO("SetWallpaperByUri001 begin");
850 ApiInfo apiInfo{ false, false };
851 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
852 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set SYSTYEM.";
853 }
854
855 /**
856 * @tc.name: SetWallpaperByUri002
857 * @tc.desc: SetWallpaperByUri with wallpaperType[1].
858 * @tc.type: FUNC
859 * @tc.require: issueI5UHRG
860 */
861 HWTEST_F(WallpaperTest, SetWallpaperByUri002, TestSize.Level0)
862 {
863 HILOG_INFO("SetWallpaperByUri002 begin");
864 ApiInfo apiInfo{ false, false };
865 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
866 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set LOCKSCREEN.";
867 }
868
869 /**
870 * @tc.name: SetWallpaperByUri003
871 * @tc.desc: SetWallpaperByUri with wallpaperType[2] throw parameters error.
872 * @tc.type: FUNC
873 * @tc.require: issueI5UHRG
874 */
875 HWTEST_F(WallpaperTest, SetWallpaperByUri003, TestSize.Level0)
876 {
877 HILOG_INFO("SetWallpaperByUri003 begin");
878 ApiInfo apiInfo{ false, false };
879 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, INVALID_WALLPAPER_TYPE, apiInfo);
880 EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error";
881 }
882
883 /**
884 * @tc.name: SetWallpaperByUri004
885 * @tc.desc: SetWallpaperByUri with error uri.
886 * @tc.type: FUNC
887 * @tc.require: issueI5UHRG
888 */
889 HWTEST_F(WallpaperTest, SetWallpaperByUri004, TestSize.Level0)
890 {
891 HILOG_INFO("SetWallpaperByUri004 begin");
892 ApiInfo apiInfo{ false, false };
893 ErrorCode wallpaperErrorCode =
894 WallpaperManager::GetInstance().SetWallpaper("/data/test/theme/wallpaper/errorURI", LOCKSCREEN, apiInfo);
895 EXPECT_NE(wallpaperErrorCode, E_OK) << "Failed to throw error";
896 }
897
898 /**
899 * @tc.name: SetWallpaperByUri005
900 * @tc.desc: SetWallpaperByUri with unsafe uri.
901 * @tc.type: FUNC
902 * @tc.require: issueI647HI
903 */
904 HWTEST_F(WallpaperTest, SetWallpaperByUri005, TestSize.Level0)
905 {
906 HILOG_INFO("SetWallpaperByUri005 begin");
907 ApiInfo apiInfo{ false, false };
908 ErrorCode wallpaperErrorCode =
909 WallpaperManager::GetInstance().SetWallpaper("../data/test/theme/wallpaper/errorURI", LOCKSCREEN, apiInfo);
910 EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to return error";
911 }
912
913 /**
914 * @tc.name: SetWallpaperByUri006
915 * @tc.desc: SetWallpaperByUri throw permission error.
916 * @tc.type: FUNC
917 * @tc.require:
918 */
919 HWTEST_F(WallpaperTest, SetWallpaperByUri006, TestSize.Level0)
920 {
921 HILOG_INFO("SetWallpaperByUri006 begin");
922 ApiInfo apiInfo{ true, true };
923 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
924 EXPECT_EQ(wallpaperErrorCode, E_OK);
925 wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
926 EXPECT_EQ(wallpaperErrorCode, E_OK);
927 }
928
929 /**
930 * @tc.name: SetWallpaperByUri007
931 * @tc.desc: SetWallpaperByUri throw permission error.
932 * @tc.type: FUNC
933 * @tc.require:
934 */
935 HWTEST_F(WallpaperTest, SetWallpaperByUri007, TestSize.Level0)
936 {
937 HILOG_INFO("SetWallpaperByUri007 begin");
938 ApiInfo apiInfo{ true, true };
939 WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
940 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
941 int32_t userId = wallpaperService->QueryActiveUserId();
942 HILOG_INFO("guochao userId:%{public}d", userId);
943 bool ret = FileDeal::IsFileExist(WallpaperTest::GetUserFilePath(userId, LOCKSCREEN_FILE));
944 EXPECT_EQ(ret, false) << "Failed to reset.";
945 WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
946 ret = FileDeal::IsFileExist(WallpaperTest::GetUserFilePath(userId, LOCKSCREEN_FILE));
947 EXPECT_EQ(ret, true);
948 WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
949 }
950
951 /********************* SetWallpaperByUri *********************/
952
953 /********************* FILE_DEAL *********************/
954 /**
955 * @tc.name: FILE_DEAL001
956 * @tc.desc: File operation-related interfaces
957 * @tc.type: FUNC
958 * @tc.require:
959 * @tc.author:
960 */
961 HWTEST_F(WallpaperTest, FILE_DEAL001, TestSize.Level0)
962 {
963 HILOG_INFO("FILE_DEAL001 begin");
964 FileDeal fileOperation;
965 bool isExist = fileOperation.Mkdir("/data/test/theme/wallpaper/");
966 EXPECT_EQ(isExist, true);
967 isExist = fileOperation.Mkdir("/data/test/theme/errorURI/");
968 EXPECT_EQ(isExist, true);
969 isExist = fileOperation.IsFileExist(URI);
970 EXPECT_EQ(isExist, true);
971 isExist = fileOperation.IsFileExist("/data/test/theme/wallpaper/errorURI");
972 EXPECT_EQ(isExist, false);
973 }
974 /********************* FILE_DEAL *********************/
975
976 /**
977 * @tc.name: SetWallpaper001
978 * @tc.desc: SetWallpaper with error length
979 * @tc.type: FUNC
980 * @tc.require: issueI6AW6M
981 * @tc.author: weishaoxiong
982 */
983 HWTEST_F(WallpaperTest, SetWallpaper001, TestSize.Level0)
984 {
985 HILOG_INFO("SetWallpaper001 begin");
986 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
987 ErrorCode wallpaperErrorCode = wallpaperService->SetWallpaper(0, 0, -1);
988 EXPECT_EQ(wallpaperErrorCode, E_PARAMETERS_INVALID) << "Failed to throw error";
989 wallpaperErrorCode = wallpaperService->SetWallpaper(0, 0, FOO_MAX_LEN);
990
991 EXPECT_EQ(wallpaperErrorCode, E_PICTURE_OVERSIZED) << "Failed to throw error";
992 }
993
994 /********************* USER_DEAL *********************/
995 /**
996 * @tc.name: AddUsersDeal001
997 * @tc.desc: Create a user directory after the user is added
998 * @tc.type: FUNC
999 * @tc.require: issueI6DWHR
1000 */
1001 HWTEST_F(WallpaperTest, AddUsersDeal001, TestSize.Level0)
1002 {
1003 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1004 bool ret = WallpaperTest::SubscribeCommonEvent(wallpaperService);
1005 ASSERT_EQ(ret, true);
1006 std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1007 WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1008 ret = FileDeal::IsDirExist(WallpaperTest::GetUserFilePath(TEST_USERID, SYSTEM_DIR));
1009 EXPECT_EQ(ret, true);
1010 ret = FileDeal::IsDirExist(WallpaperTest::GetUserFilePath(TEST_USERID, LOCKSCREEN_DIR));
1011 EXPECT_EQ(ret, true);
1012 std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1013 if (!OHOS::ForceRemoveDirectory(userDir)) {
1014 HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1015 }
1016 }
1017
1018 /**
1019 * @tc.name: RemovedUserDeal001
1020 * @tc.desc: delete a user directory after the user is removed
1021 * @tc.type: FUNC
1022 * @tc.require: issueI6DWHR
1023 */
1024 HWTEST_F(WallpaperTest, RemovedUserDeal001, TestSize.Level0)
1025 {
1026 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1027 ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1028 std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1029 WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1030 std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1031 ASSERT_EQ(FileDeal::IsDirExist(userDir), true);
1032
1033 commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1034 WallpaperTest::TriggerEvent(TEST_USERID, commonEvent);
1035 EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1036 if (!OHOS::ForceRemoveDirectory(userDir)) {
1037 HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1038 }
1039 }
1040
1041 /**
1042 * @tc.name: SwitchedUserIdDeal001
1043 * @tc.desc: The wallpaper has changed after switched user
1044 * @tc.type: FUNC
1045 * @tc.require: issueI6DWHR
1046 */
1047 HWTEST_F(WallpaperTest, SwitchedUserIdDeal001, TestSize.Level0)
1048 {
1049 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1050 wallpaperService->InitServiceHandler();
1051 ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1052 ApiInfo apiInfo{ false, false };
1053 std::vector<int32_t> ids;
1054 AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
1055 int32_t beforeUserId = ids.empty()? DEFAULT_USERID : ids[0];
1056 std::string addCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1057 WallpaperTest::TriggerEvent(TEST_USERID, addCommonEvent);
1058 std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(TEST_USERID);
1059 ASSERT_EQ(FileDeal::IsDirExist(userDir), true);
1060 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
1061 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset lockscreen wallpaper";
1062
1063 std::vector<uint64_t> oldLockscreenColor;
1064 wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, oldLockscreenColor);
1065 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1066 wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
1067 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset system wallpaper";
1068 std::vector<uint64_t> oldSystemColor;
1069 wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, oldSystemColor);
1070 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1071
1072 std::string switchCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED;
1073 WallpaperTest::TriggerEvent(TEST_USERID, switchCommonEvent);
1074 wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, LOCKSCREEN, apiInfo);
1075 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set lockscreen wallpaper";
1076 std::vector<uint64_t> newLockscreenColor;
1077 wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(LOCKSCREEN, apiInfo, newLockscreenColor);
1078 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1079 wallpaperErrorCode = WallpaperManager::GetInstance().SetWallpaper(URI, SYSTYEM, apiInfo);
1080 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set system wallpaper";
1081 std::vector<uint64_t> newSystemColor;
1082 wallpaperErrorCode = WallpaperManager::GetInstance().GetColors(SYSTYEM, apiInfo, newSystemColor);
1083 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetColors";
1084 EXPECT_NE(oldLockscreenColor, newLockscreenColor);
1085 EXPECT_NE(oldSystemColor, newSystemColor);
1086
1087 WallpaperTest::TriggerEvent(beforeUserId, switchCommonEvent);
1088 std::string removeCommonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1089 WallpaperTest::TriggerEvent(TEST_USERID, removeCommonEvent);
1090 EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1091 if (!OHOS::ForceRemoveDirectory(userDir)) {
1092 HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1093 }
1094 }
1095
1096 /**
1097 * @tc.name: InvalidUserIdDeal001
1098 * @tc.desc: Invalid user id deal
1099 * @tc.type: FUNC
1100 * @tc.require: issueI6DWHR
1101 */
1102 HWTEST_F(WallpaperTest, InvalidUserIdDeal001, TestSize.Level0)
1103 {
1104 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1105 wallpaperService->InitServiceHandler();
1106 ASSERT_EQ(WallpaperTest::SubscribeCommonEvent(wallpaperService), true);
1107 std::string commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_ADDED;
1108 WallpaperTest::TriggerEvent(INVALID_USERID, commonEvent);
1109 std::string userDir = WALLPAPER_DEFAULT_PATH + std::string("/") + std::to_string(INVALID_USERID);
1110 EXPECT_EQ(FileDeal::IsDirExist(userDir), false);
1111 FileDeal::Mkdir(userDir);
1112 commonEvent = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
1113 WallpaperTest::TriggerEvent(INVALID_USERID, commonEvent);
1114 EXPECT_EQ(FileDeal::IsDirExist(userDir), true);
1115 if (!OHOS::ForceRemoveDirectory(userDir)) {
1116 HILOG_ERROR("Force remove user directory path failed, errno %{public}d.", errno);
1117 }
1118 }
1119 /********************* USER_DEAL *********************/
1120
1121 /********************* SetVideo *********************/
1122 /**
1123 * @tc.name: SetVideo001
1124 * @tc.desc: SetVideo input error fileType
1125 * @tc.type: FUNC
1126 * @tc.require: issueI6R07J
1127 */
1128 HWTEST_F(WallpaperTest, SetVideo001, TestSize.Level0)
1129 {
1130 HILOG_INFO("SetVideo001 begin");
1131 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MOV, SYSTYEM);
1132 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1133 }
1134
1135 /**
1136 * @tc.name: SetVideo002
1137 * @tc.desc: SetVideo input error uri
1138 * @tc.type: FUNC
1139 * @tc.require: issueI6R07J
1140 */
1141 HWTEST_F(WallpaperTest, SetVideo002, TestSize.Level0)
1142 {
1143 HILOG_INFO("SetVideo002 begin");
1144 std::string errUri = "errorPath/zm_30fps_4s.mp4";
1145 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(errUri, SYSTYEM);
1146 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1147 }
1148
1149 /**
1150 * @tc.name: SetVideo003
1151 * @tc.desc: SetVideo input correct parameter
1152 * @tc.type: FUNC
1153 * @tc.require: issueI6R07J
1154 */
1155 HWTEST_F(WallpaperTest, SetVideo003, TestSize.Level0)
1156 {
1157 HILOG_INFO("SetVideo003 begin");
1158 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MP4, SYSTYEM);
1159 EXPECT_EQ(ret, E_OK);
1160 }
1161
1162 /**
1163 * @tc.name: SetVideo004
1164 * @tc.desc: SetVideo input error duration
1165 * @tc.type: FUNC
1166 * @tc.require: issueI6R07J
1167 */
1168 HWTEST_F(WallpaperTest, SetVideo004, TestSize.Level0)
1169 {
1170 HILOG_INFO("SetVideo004 begin");
1171 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_15FPS_7S_MP4, SYSTYEM);
1172 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1173 }
1174
1175 /**
1176 * @tc.name: SetVideo005
1177 * @tc.desc: SetVideo input error fileType
1178 * @tc.type: FUNC
1179 * @tc.require: issueI6R07J
1180 */
1181 HWTEST_F(WallpaperTest, SetVideo005, TestSize.Level0)
1182 {
1183 HILOG_INFO("SetVideo005 begin");
1184 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MOV, LOCKSCREEN);
1185 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1186 }
1187
1188 /**
1189 * @tc.name: SetVideo006
1190 * @tc.desc: SetVideo input error uri
1191 * @tc.type: FUNC
1192 * @tc.require: issueI6R07J
1193 */
1194 HWTEST_F(WallpaperTest, SetVideo006, TestSize.Level0)
1195 {
1196 HILOG_INFO("SetVideo006 begin");
1197 std::string errUri = "errorPath/zm_30fps_4s.mp4";
1198 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(errUri, LOCKSCREEN);
1199 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1200 }
1201
1202 /**
1203 * @tc.name: SetVideo007
1204 * @tc.desc: SetVideo input correct parameter
1205 * @tc.type: FUNC
1206 * @tc.require: issueI6R07J
1207 */
1208 HWTEST_F(WallpaperTest, SetVideo007, TestSize.Level0)
1209 {
1210 HILOG_INFO("SetVideo007 begin");
1211 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_30FPS_3S_MP4, LOCKSCREEN);
1212 EXPECT_EQ(ret, E_OK);
1213 }
1214
1215 /**
1216 * @tc.name: SetVideo008
1217 * @tc.desc: SetVideo input error duration
1218 * @tc.type: FUNC
1219 * @tc.require: issueI6R07J
1220 */
1221 HWTEST_F(WallpaperTest, SetVideo008, TestSize.Level0)
1222 {
1223 HILOG_INFO("SetVideo008 begin");
1224 ErrorCode ret = WallpaperManager::GetInstance().SetVideo(URI_15FPS_7S_MP4, LOCKSCREEN);
1225 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1226 }
1227 /********************* SetVideo *********************/
1228
1229 /**
1230 * @tc.name: SetCustomWallpaper001
1231 * @tc.desc: Set a custom wallpaper in the Sceneborad scene
1232 * @tc.type: FUNC
1233 * @tc.require: issueI7AAMU
1234 */
1235 HWTEST_F(WallpaperTest, SetCustomWallpaper001, TestSize.Level0)
1236 {
1237 HILOG_INFO("SetCustomWallpaper001 begin");
1238 ErrorCode testErrorCode = E_OK;
1239 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1240 testErrorCode = E_NO_PERMISSION;
1241 }
1242 ErrorCode ret = WallpaperManager::GetInstance().SetCustomWallpaper(URI_ZIP, SYSTYEM);
1243 EXPECT_EQ(ret, testErrorCode);
1244 ret = WallpaperManager::GetInstance().SetCustomWallpaper(URI_ZIP, LOCKSCREEN);
1245 EXPECT_EQ(ret, testErrorCode);
1246 }
1247
1248 /********************* SendEvent *********************/
1249
1250 /**
1251 * @tc.name: SendEvent001
1252 * @tc.desc: SetVideo input error fileType
1253 * @tc.type: FUNC
1254 * @tc.require: issueI6R07J
1255 */
1256 HWTEST_F(WallpaperTest, SendEvent001, TestSize.Level0)
1257 {
1258 HILOG_INFO("SendEvent001 begin");
1259 std::string errEventType = "SHOW_ERROREVENTTYPE";
1260 ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_ERROREVENTTYPE");
1261 EXPECT_EQ(ret, E_PARAMETERS_INVALID);
1262 }
1263
1264 /**
1265 * @tc.name: SendEvent002
1266 * @tc.desc: SetVideo input error fileType
1267 * @tc.type: FUNC
1268 * @tc.require: issueI6R07J
1269 */
1270 HWTEST_F(WallpaperTest, SendEvent002, TestSize.Level0)
1271 {
1272 HILOG_INFO("SendEvent002 begin");
1273 ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_SYSTEMSCREEN");
1274 EXPECT_EQ(ret, E_OK);
1275 }
1276
1277 /**
1278 * @tc.name: SendEvent003
1279 * @tc.desc: SetVideo input error fileType
1280 * @tc.type: FUNC
1281 * @tc.require: issueI6R07J
1282 */
1283 HWTEST_F(WallpaperTest, SendEvent003, TestSize.Level0)
1284 {
1285 HILOG_INFO("SendEvent003 begin");
1286 ErrorCode ret = WallpaperManager::GetInstance().SendEvent("SHOW_LOCKSCREEN");
1287 EXPECT_EQ(ret, E_OK);
1288 }
1289
1290 /**
1291 * @tc.name: WallpaperTest_001
1292 * @tc.desc: Test Onstop and OnStart.
1293 * @tc.type: FUNC
1294 * @tc.require: issueI7OUB6
1295 */
1296 HWTEST_F(WallpaperTest, WallpaperTest_001, TestSize.Level0)
1297 {
1298 HILOG_INFO("Test Onstop");
1299 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1300 wallpaperService->state_ = WallpaperService::ServiceRunningState::STATE_RUNNING;
1301 wallpaperService->OnStop();
1302 EXPECT_EQ(wallpaperService->state_, WallpaperService::ServiceRunningState::STATE_NOT_START);
1303 }
1304
1305 /**
1306 * @tc.name: GetPictureFileName_001
1307 * @tc.desc: Load userIds that are not found in the Map.
1308 * @tc.type: FUNC
1309 * @tc.require: issueI90IUI
1310 */
1311 HWTEST_F(WallpaperTest, GetPictureFileName_001, TestSize.Level0)
1312 {
1313 HILOG_INFO("GetPictureFileName_001 begin");
1314 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1315 std::string fileName;
1316 wallpaperService->GetPictureFileName(TEST_USERID1, WALLPAPER_SYSTEM, fileName);
1317 auto wallpaperDefault = fileName.find(WALLPAPER_DEFAULT);
1318 auto homeWallpaper = fileName.find(HOME_WALLPAPER);
1319 EXPECT_EQ((wallpaperDefault != string::npos) || (homeWallpaper != string::npos), true);
1320 wallpaperService->SetWallpaperBackupData(TEST_USERID1, PICTURE, URI, WALLPAPER_SYSTEM);
1321 wallpaperService->GetPictureFileName(TEST_USERID1, WALLPAPER_SYSTEM, fileName);
1322 auto pos = fileName.find(to_string(TEST_USERID1));
1323 EXPECT_NE(pos, string::npos);
1324 wallpaperService->OnRemovedUser(TEST_USERID1);
1325 }
1326
1327 /**
1328 * @tc.name: RegisterWallpaperCallback_001
1329 * @tc.desc: Test RegisterWallpaperCallback
1330 * @tc.type: FUNC
1331 * @tc.require: issueIA87VK
1332 */
1333 HWTEST_F(WallpaperTest, RegisterWallpaperCallback_001, TestSize.Level0)
1334 {
1335 HILOG_INFO("RegisterWallpaperCallback_001 begin");
1336 JScallback callback = &WallpaperTest::TestCallBack;
1337 bool res = WallpaperManager::GetInstance().RegisterWallpaperCallback(callback);
1338 EXPECT_EQ(res, true);
1339 }
1340
1341 /**
1342 * @tc.name: RegisterWallpaperListener_001
1343 * @tc.desc: Test RegisterWallpaperListener
1344 * @tc.type: FUNC
1345 * @tc.require: issueIA87VK
1346 */
1347 HWTEST_F(WallpaperTest, RegisterWallpaperListener_001, TestSize.Level0)
1348 {
1349 HILOG_INFO("RegisterWallpaperListener_001 begin");
1350 bool res = WallpaperManager::GetInstance().RegisterWallpaperListener();
1351 EXPECT_EQ(res, true);
1352 }
1353
1354 /********************* SetAllWallpapers *********************/
1355 /**
1356 * @tc.name: SetAllWallpapers001
1357 * @tc.desc: SetAllWallpapers normal device with wallpaperType[0]
1358 * @tc.type: FUNC
1359 * @tc.require:
1360 */
1361 HWTEST_F(WallpaperTest, SetAllWallpapers001, TestSize.Level0)
1362 {
1363 HILOG_INFO("SetAllWallpapers001 begin");
1364 std::vector<WallpaperInfo> wallpaperInfo;
1365 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1366 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1367 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1368 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1369 }
1370
1371 /**
1372 * @tc.name: SetAllWallpapers002
1373 * @tc.desc: SetAllWallpapers normal device with wallpaperType[1]
1374 * @tc.type: FUNC
1375 * @tc.require:
1376 */
1377 HWTEST_F(WallpaperTest, SetAllWallpapers002, TestSize.Level0)
1378 {
1379 HILOG_INFO("SetAllWallpapers002 begin");
1380 std::vector<WallpaperInfo> wallpaperInfo;
1381 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1382 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1383 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1384 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1385 }
1386
1387 /**
1388 * @tc.name: SetAllWallpapers003
1389 * @tc.desc: SetAllWallpapers unfold_1 device with wallpaperType[0]
1390 * @tc.type: FUNC
1391 * @tc.require:
1392 */
1393 HWTEST_F(WallpaperTest, SetAllWallpapers003, TestSize.Level0)
1394 {
1395 HILOG_INFO("SetAllWallpapers003 begin");
1396 std::vector<WallpaperInfo> wallpaperInfo;
1397 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1398 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1399 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1400 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1401 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1402 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1403 }
1404
1405 /**
1406 * @tc.name: SetAllWallpapers004
1407 * @tc.desc: SetAllWallpapers unfold_1 device with wallpaperType[1]
1408 * @tc.type: FUNC
1409 * @tc.require:
1410 */
1411 HWTEST_F(WallpaperTest, SetAllWallpapers004, TestSize.Level0)
1412 {
1413 HILOG_INFO("SetAllWallpapers004 begin");
1414 std::vector<WallpaperInfo> wallpaperInfo;
1415 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1416 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1417 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1418 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1419 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1420 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1421 }
1422
1423 /**
1424 * @tc.name: SetAllWallpapers005
1425 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[0]
1426 * @tc.type: FUNC
1427 * @tc.require:
1428 */
1429 HWTEST_F(WallpaperTest, SetAllWallpapers005, TestSize.Level0)
1430 {
1431 HILOG_INFO("SetAllWallpapers005 begin");
1432 std::vector<WallpaperInfo> wallpaperInfo;
1433 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1434 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1435 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1436 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1437 wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1438 wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1439 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1440 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1441 }
1442
1443 /**
1444 * @tc.name: SetAllWallpapers006
1445 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[1]
1446 * @tc.type: FUNC
1447 * @tc.require:
1448 */
1449 HWTEST_F(WallpaperTest, SetAllWallpapers006, TestSize.Level0)
1450 {
1451 HILOG_INFO("SetAllWallpapers006 begin");
1452 std::vector<WallpaperInfo> wallpaperInfo;
1453 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1454 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1455 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1456 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1457 wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1458 wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1459 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1460 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to SetAllWallpapers";
1461 }
1462
1463 /********************* SetAllWallpapers *********************/
1464
1465 /********************* GetCorrespondWallpaper *********************/
1466 /**
1467 * @tc.name: GetCorrespondWallpaper001
1468 * @tc.desc: GetCorrespondWallpaper normal device with wallpaperType[0].
1469 * @tc.type: FUNC
1470 * @tc.require:
1471 */
1472 HWTEST_F(WallpaperTest, GetCorrespondWallpaper001, TestSize.Level0)
1473 {
1474 HILOG_INFO("GetCorrespondWallpaper001 begin");
1475 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1476 ErrorCode wallpaperErrorCode =
1477 WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, NORMAL, PORT, pixelMap);
1478 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1479 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, NORMAL, LAND, pixelMap);
1480 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1481 }
1482
1483 /**
1484 * @tc.name: GetCorrespondWallpaper002
1485 * @tc.desc: GetCorrespondWallpaper normal device with wallpaperType[1].
1486 * @tc.type: FUNC
1487 * @tc.require:
1488 */
1489 HWTEST_F(WallpaperTest, GetCorrespondWallpaper002, TestSize.Level0)
1490 {
1491 HILOG_INFO("GetPixelMap002 begin");
1492 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1493 ErrorCode wallpaperErrorCode =
1494 WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, NORMAL, PORT, pixelMap);
1495 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1496 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, NORMAL, LAND, pixelMap);
1497 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1498 }
1499
1500 /**
1501 * @tc.name: GetCorrespondWallpaper003
1502 * @tc.desc: GetCorrespondWallpaper unfold_1 device with wallpaperType[0].
1503 * @tc.type: FUNC
1504 * @tc.require:
1505 */
1506 HWTEST_F(WallpaperTest, GetCorrespondWallpaper003, TestSize.Level0)
1507 {
1508 HILOG_INFO("GetCorrespondWallpaper003 begin");
1509 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1510 ErrorCode wallpaperErrorCode =
1511 WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_1, PORT, pixelMap);
1512 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1513 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_1, LAND, pixelMap);
1514 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1515 }
1516
1517 /**
1518 * @tc.name: GetCorrespondWallpaper004
1519 * @tc.desc: GetCorrespondWallpaper unfold_1 device with wallpaperType[1].
1520 * @tc.type: FUNC
1521 * @tc.require:
1522 */
1523 HWTEST_F(WallpaperTest, GetCorrespondWallpaper004, TestSize.Level0)
1524 {
1525 HILOG_INFO("GetCorrespondWallpaper004 begin");
1526 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1527 ErrorCode wallpaperErrorCode =
1528 WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_1, PORT, pixelMap);
1529 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1530 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_1, LAND, pixelMap);
1531 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1532 }
1533
1534 /**
1535 * @tc.name: GetCorrespondWallpaper005
1536 * @tc.desc: GetCorrespondWallpaper unfold_2 device with wallpaperType[0].
1537 * @tc.type: FUNC
1538 * @tc.require:
1539 */
1540 HWTEST_F(WallpaperTest, GetCorrespondWallpaper005, TestSize.Level0)
1541 {
1542 HILOG_INFO("GetCorrespondWallpaper005 begin");
1543 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1544 ErrorCode wallpaperErrorCode =
1545 WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_2, PORT, pixelMap);
1546 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1547 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(SYSTYEM, UNFOLD_2, LAND, pixelMap);
1548 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1549 }
1550
1551 /**
1552 * @tc.name: GetCorrespondWallpaper006
1553 * @tc.desc: GetCorrespondWallpaper unfold_2 device with wallpaperType[1].
1554 * @tc.type: FUNC
1555 * @tc.require:
1556 */
1557 HWTEST_F(WallpaperTest, GetCorrespondWallpaper006, TestSize.Level0)
1558 {
1559 HILOG_INFO("GetCorrespondWallpaper006 begin");
1560 std::shared_ptr<OHOS::Media::PixelMap> pixelMap;
1561 ErrorCode wallpaperErrorCode =
1562 WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_2, PORT, pixelMap);
1563 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1564 wallpaperErrorCode = WallpaperManager::GetInstance().GetCorrespondWallpaper(LOCKSCREEN, UNFOLD_2, LAND, pixelMap);
1565 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to GetCorrespondWallpaper";
1566 }
1567 /********************* GetCorrespondWallpaper *********************/
1568
1569 /********************* Wallpaper_Inner_Api *********************/
1570 /**
1571 * @tc.name: IsDefaultWallpaperResource
1572 * @tc.desc: IsDefaultWallpaperResource wallpaper resource is empty.
1573 * @tc.type: FUNC
1574 * @tc.require:
1575 */
1576 HWTEST_F(WallpaperTest, IsDefaultWallpaperResource001, TestSize.Level0)
1577 {
1578 HILOG_INFO("IsDefaultWallpaperResource001 begin");
1579 std::shared_ptr<WallpaperService> wallpaperService = std::make_shared<WallpaperService>();
1580 int32_t userId = wallpaperService->QueryActiveUserId();
1581 ApiInfo apiInfo{ false, false };
1582 std::vector<WallpaperInfo> wallpaperInfo;
1583 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1584 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1585 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1586 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1587 wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1588 wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1589 ErrorCode wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(SYSTYEM, apiInfo);
1590 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset lockscreen wallpaper";
1591 auto ret = WallpaperManagerClient::GetInstance().IsDefaultWallpaperResource(userId, SYSTYEM);
1592 EXPECT_EQ(ret, true) << "Failed to IsDefaultWallpaperResource";
1593 wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1594 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set system wallpaper";
1595 ret = WallpaperManagerClient::GetInstance().IsDefaultWallpaperResource(userId, SYSTYEM);
1596 EXPECT_EQ(ret, false) << "Failed to IsDefaultWallpaperResource";
1597 wallpaperErrorCode = WallpaperManager::GetInstance().ResetWallpaper(LOCKSCREEN, apiInfo);
1598 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to reset lockscreen wallpaper";
1599 ret = WallpaperManagerClient::GetInstance().IsDefaultWallpaperResource(userId, LOCKSCREEN);
1600 EXPECT_EQ(ret, true) << "Failed to IsDefaultWallpaperResource";
1601 wallpaperErrorCode = WallpaperManager::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1602 EXPECT_EQ(wallpaperErrorCode, E_OK) << "Failed to set system wallpaper";
1603 ret = WallpaperManagerClient::GetInstance().IsDefaultWallpaperResource(userId, SYSTYEM);
1604 EXPECT_EQ(ret, false) << "Failed to IsDefaultWallpaperResource";
1605 }
1606
1607 /**
1608 * @tc.name: SetAllWallpapers
1609 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[0].
1610 * @tc.type: FUNC
1611 * @tc.require:
1612 */
1613 HWTEST_F(WallpaperTest, SetAllWallpapersClient001, TestSize.Level0)
1614 {
1615 HILOG_INFO("SetAllWallpapersClient001 begin");
1616 std::vector<WallpaperInfo> wallpaperInfo;
1617 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1618 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1619 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1620 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1621 wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1622 wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1623 auto ret = WallpaperManagerClient::GetInstance().SetAllWallpapers(wallpaperInfo, SYSTYEM);
1624 EXPECT_EQ(ret, static_cast<int32_t>(E_OK)) << "Failed to SetAllWallpapers";
1625 }
1626
1627 /**
1628 * @tc.name: SetAllWallpapers
1629 * @tc.desc: SetAllWallpapers unfold_2 device with wallpaperType[1]
1630 * @tc.type: FUNC
1631 * @tc.require:
1632 */
1633 HWTEST_F(WallpaperTest, SetAllWallpapersClient002, TestSize.Level0)
1634 {
1635 HILOG_INFO("SetAllWallpapersClient002 begin");
1636 std::vector<WallpaperInfo> wallpaperInfo;
1637 wallpaperInfo.push_back(wallpaperInfo_normal_port);
1638 wallpaperInfo.push_back(wallpaperInfo_normal_land);
1639 wallpaperInfo.push_back(wallpaperInfo_unfold1_port);
1640 wallpaperInfo.push_back(wallpaperInfo_unfold1_land);
1641 wallpaperInfo.push_back(wallpaperInfo_unfold2_port);
1642 wallpaperInfo.push_back(wallpaperInfo_unfold2_land);
1643 auto ret = WallpaperManagerClient::GetInstance().SetAllWallpapers(wallpaperInfo, LOCKSCREEN);
1644 EXPECT_EQ(ret, static_cast<int32_t>(E_OK)) << "Failed to SetAllWallpapers";
1645 }
1646 /********************* Wallpaper_Inner_Api *********************/
1647
1648 } // namespace WallpaperMgrService
1649 } // namespace OHOS
