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 "screenlock_system_ability.h"
18 #include "innerlistenermanager.h"
19 #undef private
20 #undef protected
21
22 #include <cstdint>
23 #include <list>
24 #include <string>
25 #include <sys/time.h>
26
27 #include "accesstoken_kit.h"
28 #include "sclock_log.h"
29 #include "screenlock_callback_test.h"
30 #include "screenlock_common.h"
31 #include "screenlock_event_list_test.h"
32 #include "screenlock_notify_test_instance.h"
33 #include "screenlock_service_test.h"
34 #include "screenlock_system_ability.h"
35 #include "screenlock_system_ability_stub.h"
36 #include "securec.h"
37 #include "token_setproc.h"
38 #include "inner_listener_test.h"
39 #include "system_ability_definition.h"
40
41
42 namespace OHOS {
43 namespace ScreenLock {
44 using namespace testing::ext;
45 using namespace OHOS::Rosen;
46 using namespace OHOS::Security::AccessToken;
47 constexpr const uint16_t EACH_LINE_LENGTH = 100;
48 constexpr const uint16_t TOTAL_LENGTH = 1000;
49 constexpr const char *CMD1 = "hidumper -s 3704";
50 constexpr const char *CMD2 = "hidumper -s 3704 -a -h";
51 constexpr const char *CMD3 = "hidumper -s 3704 -a -all";
52 uint64_t g_selfTokenID = 0;
53 static EventListenerTest g_unlockTestListener;
54
55 static HapPolicyParams g_policyParams = {.apl = APL_SYSTEM_CORE,
56 .domain = "test.domain",
57 .permList = {{.permissionName = "ohos.permission.ACCESS_SCREEN_LOCK_INNER",
58 .bundleName = "ohos.screenlock_test.demo",
59 .grantMode = 1,
60 .availableLevel = APL_NORMAL,
61 .label = "label",
62 .labelId = 1,
63 .description = "test",
64 .descriptionId = 1},
65 {.permissionName = "ohos.permission.DUMP",
66 .bundleName = "ohos.screenlock_test.demo",
67 .grantMode = 1,
68 .availableLevel = APL_SYSTEM_CORE,
69 .label = "label",
70 .labelId = 1,
71 .description = "test",
72 .descriptionId = 1},
73 {.permissionName = "ohos.permission.ACCESS_SCREEN_LOCK",
74 .bundleName = "ohos.screenlock_test.demo",
75 .grantMode = 1,
76 .availableLevel = APL_NORMAL,
77 .label = "label",
78 .labelId = 1,
79 .description = "test",
80 .descriptionId = 1}},
81 .permStateList = {{.permissionName = "ohos.permission.ACCESS_SCREEN_LOCK_INNER",
82 .isGeneral = true,
83 .resDeviceID = {"local"},
84 .grantStatus = {PermissionState::PERMISSION_GRANTED},
85 .grantFlags = {1}},
86 {.permissionName = "ohos.permission.DUMP",
87 .isGeneral = true,
88 .resDeviceID = {"local"},
89 .grantStatus = {PermissionState::PERMISSION_GRANTED},
90 .grantFlags = {1}},
91 {.permissionName = "ohos.permission.ACCESS_SCREEN_LOCK",
92 .isGeneral = true,
93 .resDeviceID = {"local"},
94 .grantStatus = {PermissionState::PERMISSION_GRANTED},
95 .grantFlags = {1}}}};
96
97 HapInfoParams g_infoParams = { .userID = 1,
98 .bundleName = "screenlock_service",
99 .instIndex = 0,
100 .appIDDesc = "test",
101 .apiVersion = 9,
102 .isSystemApp = true };
103
GrantNativePermission()104 void GrantNativePermission()
105 {
106 g_selfTokenID = GetSelfTokenID();
107 AccessTokenIDEx tokenIdEx = { 0 };
108 tokenIdEx = AccessTokenKit::AllocHapToken(g_infoParams, g_policyParams);
109 int32_t ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
110 if (ret == 0) {
111 SCLOCK_HILOGI("SetSelfTokenID success!");
112 } else {
113 SCLOCK_HILOGE("SetSelfTokenID fail!");
114 }
115 }
116
SetUpTestCase()117 void ScreenLockServiceTest::SetUpTestCase()
118 {
119 GrantNativePermission();
120 }
121
TearDownTestCase()122 void ScreenLockServiceTest::TearDownTestCase()
123 {
124 ScreenLockSystemAbility::GetInstance()->ResetFfrtQueue();
125 SetSelfTokenID(g_selfTokenID);
126 }
127
SetUp()128 void ScreenLockServiceTest::SetUp()
129 {
130 }
131
TearDown()132 void ScreenLockServiceTest::TearDown()
133 {
134 }
135
ExecuteCmd(const std::string & cmd,std::string & result)136 bool ScreenLockServiceTest::ExecuteCmd(const std::string &cmd, std::string &result)
137 {
138 char buff[EACH_LINE_LENGTH] = { 0x00 };
139 char output[TOTAL_LENGTH] = { 0x00 };
140 FILE *ptr = popen(cmd.c_str(), "r");
141 if (ptr != nullptr) {
142 while (fgets(buff, sizeof(buff), ptr) != nullptr) {
143 if (strcat_s(output, sizeof(output), buff) != 0) {
144 pclose(ptr);
145 ptr = nullptr;
146 return false;
147 }
148 }
149 pclose(ptr);
150 ptr = nullptr;
151 } else {
152 return false;
153 }
154 result = std::string(output);
155 return true;
156 }
157
158 /**
159 * @tc.name: ScreenLockTest001
160 * @tc.desc: beginWakeUp event.
161 * @tc.type: FUNC
162 * @tc.require:
163 * @tc.author:
164 */
165 HWTEST_F(ScreenLockServiceTest, ScreenLockTest001, TestSize.Level0)
166 {
167 SCLOCK_HILOGD("Test event of beginWakeUp");
168 ScreenLockSystemAbility::GetInstance();
169 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
170 EventStatus status = EventStatus::BEGIN;
171 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
172 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
173 ASSERT_NE(displayPowerEventListener, nullptr);
174 displayPowerEventListener->OnDisplayPowerEvent(event, status);
175 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
176 SCLOCK_HILOGD("Test_BeginWakeUp retVal=%{public}d", retVal);
177 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_WAKEUP));
178 }
179
180 /**
181 * @tc.name: ScreenLockTest003
182 * @tc.desc: beginSleep event.
183 * @tc.type: FUNC
184 * @tc.require:
185 * @tc.author:
186 */
187 HWTEST_F(ScreenLockServiceTest, ScreenLockTest003, TestSize.Level0)
188 {
189 SCLOCK_HILOGD("Test event of beginsleep");
190 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
191 ScreenLockSystemAbility::GetInstance()->OnStart();
192 DisplayPowerEvent event = DisplayPowerEvent::SLEEP;
193 EventStatus status = EventStatus::BEGIN;
194 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
195 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
196 ASSERT_NE(displayPowerEventListener, nullptr);
197 displayPowerEventListener->OnDisplayPowerEvent(event, status);
198 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
199 SCLOCK_HILOGD("Test_BeginSleep retVal=%{public}d", retVal);
200 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_SLEEP));
201 }
202
203 /**
204 * @tc.name: ScreenLockTest004
205 * @tc.desc: beginScreenOn event.
206 * @tc.type: FUNC
207 * @tc.require:
208 * @tc.author:
209 */
210 HWTEST_F(ScreenLockServiceTest, ScreenLockTest004, TestSize.Level0)
211 {
212 SCLOCK_HILOGD("Test event of beginscreenon");
213 ScreenLockSystemAbility::GetInstance();
214 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_ON;
215 EventStatus status = EventStatus::BEGIN;
216 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
217 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
218 ASSERT_NE(displayPowerEventListener, nullptr);
219 displayPowerEventListener->OnDisplayPowerEvent(event, status);
220 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
221 SCLOCK_HILOGD("Test_BeginScreenOn retVal=%{public}d", retVal);
222 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_ON));
223 }
224
225 /**
226 * @tc.name: ScreenLockTest005
227 * @tc.desc: beginScreenOff event.
228 * @tc.type: FUNC
229 * @tc.require:
230 * @tc.author:
231 */
232 HWTEST_F(ScreenLockServiceTest, ScreenLockTest005, TestSize.Level0)
233 {
234 SCLOCK_HILOGD("Test event of beginscreenoff");
235 ScreenLockSystemAbility::GetInstance();
236 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_OFF;
237 EventStatus status = EventStatus::BEGIN;
238 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
239 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
240 ASSERT_NE(displayPowerEventListener, nullptr);
241 displayPowerEventListener->OnDisplayPowerEvent(event, status);
242 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
243 SCLOCK_HILOGD("Test_BeginScreenOff retVal=%{public}d", retVal);
244 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_OFF));
245 }
246
247 /**
248 * @tc.name: ScreenLockTest006
249 * @tc.desc: endWakeUp event.
250 * @tc.type: FUNC
251 * @tc.require:
252 * @tc.author:
253 */
254 HWTEST_F(ScreenLockServiceTest, ScreenLockTest006, TestSize.Level0)
255 {
256 SCLOCK_HILOGD("Test event of endwakeup");
257 ScreenLockSystemAbility::GetInstance();
258 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
259 EventStatus status = EventStatus::END;
260 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
261 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
262 ASSERT_NE(displayPowerEventListener, nullptr);
263 displayPowerEventListener->OnDisplayPowerEvent(event, status);
264 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
265 SCLOCK_HILOGD("Test_EndWakeUp retVal=%{public}d", retVal);
266 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_WAKEUP));
267 }
268
269 /**
270 * @tc.name: ScreenLockTest007
271 * @tc.desc: endSleep event.
272 * @tc.type: FUNC
273 * @tc.require:
274 * @tc.author:
275 */
276 HWTEST_F(ScreenLockServiceTest, ScreenLockTest007, TestSize.Level0)
277 {
278 SCLOCK_HILOGD("Test event of endsleep");
279 ScreenLockSystemAbility::GetInstance();
280 DisplayPowerEvent event = DisplayPowerEvent::SLEEP;
281 EventStatus status = EventStatus::END;
282 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
283 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
284 ASSERT_NE(displayPowerEventListener, nullptr);
285 displayPowerEventListener->OnDisplayPowerEvent(event, status);
286 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
287 SCLOCK_HILOGD("Test_EndSleep retVal=%{public}d", retVal);
288 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_SLEEP));
289 }
290
291 /**
292 * @tc.name: ScreenLockTest008
293 * @tc.desc: endScreenOn event.
294 * @tc.type: FUNC
295 * @tc.require:
296 * @tc.author:
297 */
298 HWTEST_F(ScreenLockServiceTest, ScreenLockTest008, TestSize.Level0)
299 {
300 SCLOCK_HILOGD("Test event of endscreenon");
301 ScreenLockSystemAbility::GetInstance();
302 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_ON;
303 EventStatus status = EventStatus::END;
304 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
305 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
306 ASSERT_NE(displayPowerEventListener, nullptr);
307 displayPowerEventListener->OnDisplayPowerEvent(event, status);
308 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
309 SCLOCK_HILOGD("Test_EndScreenOn retVal=%{public}d", retVal);
310 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_END_ON));
311 }
312
313 /**
314 * @tc.name: ScreenLockTest009
315 * @tc.desc: endScreenOff and begin desktopready event.
316 * @tc.type: FUNC
317 * @tc.require:
318 * @tc.author:
319 */
320 HWTEST_F(ScreenLockServiceTest, ScreenLockTest009, TestSize.Level0)
321 {
322 SCLOCK_HILOGD("Test event of endscreenoff");
323 ScreenLockSystemAbility::GetInstance();
324 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_OFF;
325 EventStatus status = EventStatus::END;
326 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
327 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
328 ASSERT_NE(displayPowerEventListener, nullptr);
329 displayPowerEventListener->OnDisplayPowerEvent(event, status);
330 event = DisplayPowerEvent::DESKTOP_READY;
331 status = EventStatus::BEGIN;
332 displayPowerEventListener->OnDisplayPowerEvent(event, status);
333 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
334 SCLOCK_HILOGD("Test_EndScreenOff retVal=%{public}d", retVal);
335 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_END_OFF));
336 }
337
338 /**
339 * @tc.name: ScreenLockDumperTest013
340 * @tc.desc: dump showhelp.
341 * @tc.type: FUNC
342 * @tc.require:
343 * @tc.author:
344 */
345 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest013, TestSize.Level0)
346 {
347 SCLOCK_HILOGD("Test hidumper of showhelp");
348 std::string result;
349 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD1, result);
350 EXPECT_TRUE(ret);
351 }
352
353 /**
354 * @tc.name: ScreenLockDumperTest014
355 * @tc.desc: dump showhelp.
356 * @tc.type: FUNC
357 * @tc.require:
358 * @tc.author:
359 */
360 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest014, TestSize.Level0)
361 {
362 SCLOCK_HILOGD("Test hidumper of -h");
363 std::string result;
364 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD2, result);
365 EXPECT_TRUE(ret);
366 }
367
368 /**
369 * @tc.name: ScreenLockDumperTest015
370 * @tc.desc: dump screenlock information.
371 * @tc.type: FUNC
372 * @tc.require:
373 * @tc.author:
374 */
375 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest015, TestSize.Level0)
376 {
377 SCLOCK_HILOGD("Test hidumper of -all");
378 std::string result;
379 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD3, result);
380 EXPECT_TRUE(ret);
381 }
382
383 /**
384 * @tc.name: ScreenLockTest016
385 * @tc.desc: Test Lock.
386 * @tc.type: FUNC
387 * @tc.require:
388 * @tc.author:
389 */
390 HWTEST_F(ScreenLockServiceTest, ScreenLockTest016, TestSize.Level0)
391 {
392 SCLOCK_HILOGD("Test RequestLock");
393 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
394 sptr<ScreenLockCallbackInterface> listener = new (std::nothrow) ScreenlockCallbackTest(g_unlockTestListener);
395 ASSERT_NE(listener, nullptr);
396
397 int32_t userId = ScreenLockSystemAbility::GetInstance()->GetState().GetCurrentUser();
398 ScreenLockSystemAbility::GetInstance()->SetScreenlocked(true, userId);
399 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
400 EXPECT_EQ(isLocked, true);
401 int32_t result = ScreenLockSystemAbility::GetInstance()->Lock(listener);
402 bool ret = ScreenLockSystemAbility::GetInstance()->IsSystemApp();
403 if (!ret) {
404 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
405 } else {
406 EXPECT_EQ(result, E_SCREENLOCK_OK);
407 }
408 ScreenLockSystemAbility::GetInstance()->SetScreenlocked(false, userId);
409 result = ScreenLockSystemAbility::GetInstance()->Lock(listener);
410 if (!ret) {
411 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
412 } else {
413 EXPECT_EQ(result, E_SCREENLOCK_OK);
414 }
415 }
416
417 /**
418 * @tc.name: ScreenLockTest017
419 * @tc.desc: Test Unlock and UnlockScreen.
420 * @tc.type: FUNC
421 * @tc.require:
422 * @tc.author:
423 */
424 HWTEST_F(ScreenLockServiceTest, ScreenLockTest017, TestSize.Level0)
425 {
426 SCLOCK_HILOGD("Test RequestUnlock");
427 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
428 sptr<ScreenLockCallbackInterface> listener = new (std::nothrow) ScreenlockCallbackTest(g_unlockTestListener);
429 ASSERT_NE(listener, nullptr);
430 int32_t result = ScreenLockSystemAbility::GetInstance()->UnlockScreen(listener);
431 bool retcode = ScreenLockSystemAbility::GetInstance()->CheckPermission("ohos.permission.ACCESS_SCREEN_LOCK");
432 if (!retcode) {
433 EXPECT_EQ(result, E_SCREENLOCK_NOT_FOCUS_APP);
434 } else {
435 EXPECT_EQ(result, E_SCREENLOCK_OK);
436 }
437 result = ScreenLockSystemAbility::GetInstance()->Unlock(listener);
438 bool ret = ScreenLockSystemAbility::GetInstance()->IsSystemApp();
439 if (!ret) {
440 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
441 } else {
442 EXPECT_EQ(result, E_SCREENLOCK_OK);
443 }
444 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
445 result = ScreenLockSystemAbility::GetInstance()->Unlock(listener);
446 if (!ret) {
447 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
448 } else {
449 EXPECT_EQ(result, E_SCREENLOCK_OK);
450 }
451 }
452
453 /**
454 * @tc.name: ScreenLockTest018
455 * @tc.desc: Test SendScreenLockEvent.
456 * @tc.type: FUNC
457 * @tc.require:
458 * @tc.author:
459 */
460 HWTEST_F(ScreenLockServiceTest, ScreenLockTest018, TestSize.Level0)
461 {
462 SCLOCK_HILOGD("Test SendScreenLockEvent");
463 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_SUCC);
464 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
465 bool ret = ScreenLockSystemAbility::GetInstance()->IsSystemApp();
466 if (!ret) {
467 std::string result;
468 auto retcode = ScreenLockServiceTest::ExecuteCmd(CMD3, result);
469 SCLOCK_HILOGD("retcode=%{public}d", retcode);
470 EXPECT_TRUE(retcode);
471 } else {
472 EXPECT_EQ(isLocked, false);
473 }
474 }
475
476 /**
477 * @tc.name: ScreenLockTest019
478 * @tc.desc: Test SendScreenLockEvent.
479 * @tc.type: FUNC
480 * @tc.require:
481 * @tc.author:
482 */
483 HWTEST_F(ScreenLockServiceTest, ScreenLockTest019, TestSize.Level0)
484 {
485 SCLOCK_HILOGD("Test SendScreenLockEvent");
486 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_FAIL);
487 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
488 bool ret = ScreenLockSystemAbility::GetInstance()->IsSystemApp();
489 if (!ret) {
490 std::string result;
491 auto retcode = ScreenLockServiceTest::ExecuteCmd(CMD3, result);
492 SCLOCK_HILOGD("retcode=%{public}d", retcode);
493 EXPECT_TRUE(retcode);
494 } else {
495 EXPECT_EQ(isLocked, false);
496 }
497 }
498
499 /**
500 * @tc.name: ScreenLockTest020
501 * @tc.desc: Test SendScreenLockEvent.
502 * @tc.type: FUNC
503 * @tc.require:
504 * @tc.author:
505 */
506 HWTEST_F(ScreenLockServiceTest, ScreenLockTest020, TestSize.Level0)
507 {
508 SCLOCK_HILOGD("Test SendScreenLockEvent");
509 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_CANCEL);
510 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
511 bool ret = ScreenLockSystemAbility::GetInstance()->IsSystemApp();
512 if (!ret) {
513 std::string result;
514 auto retcode = ScreenLockServiceTest::ExecuteCmd(CMD3, result);
515 SCLOCK_HILOGD("retcode=%{public}d", retcode);
516 EXPECT_TRUE(retcode);
517 } else {
518 EXPECT_EQ(isLocked, false);
519 }
520 }
521
522 /**
523 * @tc.name: ScreenLockTest021
524 * @tc.desc: Test SendScreenLockEvent.
525 * @tc.type: FUNC
526 * @tc.require:
527 * @tc.author:
528 */
529 HWTEST_F(ScreenLockServiceTest, ScreenLockTest021, TestSize.Level0)
530 {
531 SCLOCK_HILOGD("Test SendScreenLockEvent");
532 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_SUCC);
533 bool isLocked;
534 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
535 EXPECT_EQ(isLocked, true);
536 }
537
538 /**
539 * @tc.name: ScreenLockTest022
540 * @tc.desc: Test SendScreenLockEvent.
541 * @tc.type: FUNC
542 * @tc.require:
543 * @tc.author:
544 */
545 HWTEST_F(ScreenLockServiceTest, ScreenLockTest022, TestSize.Level0)
546 {
547 SCLOCK_HILOGD("Test SendScreenLockEvent");
548 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_FAIL);
549 bool isLocked;
550 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
551 EXPECT_EQ(isLocked, true);
552 }
553
554 /**
555 * @tc.name: ScreenLockTest023
556 * @tc.desc: Test SendScreenLockEvent.
557 * @tc.type: FUNC
558 * @tc.require:
559 * @tc.author:
560 */
561 HWTEST_F(ScreenLockServiceTest, ScreenLockTest023, TestSize.Level0)
562 {
563 SCLOCK_HILOGD("Test SendScreenLockEvent");
564 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(SCREEN_DRAWDONE, SCREEN_SUCC);
565 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_CANCEL);
566 bool isLocked;
567 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
568 EXPECT_EQ(isLocked, true);
569 }
570
571 /**
572 * @tc.name: ScreenLockTest025
573 * @tc.desc: Test Onstop and OnStart.
574 * @tc.type: FUNC
575 * @tc.require:
576 * @tc.author:
577 */
578 HWTEST_F(ScreenLockServiceTest, ScreenLockTest025, TestSize.Level0)
579 {
580 SCLOCK_HILOGD("Test Onstop");
581 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
582 ScreenLockSystemAbility::GetInstance()->OnStart();
583 std::string deviceId = "1";
584 ScreenLockSystemAbility::GetInstance()->OnAddSystemAbility(DISPLAY_MANAGER_SERVICE_SA_ID, deviceId);
585 ScreenLockSystemAbility::GetInstance()->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, deviceId);
586 ScreenLockSystemAbility::GetInstance()->OnAddSystemAbility(SUBSYS_USERIAM_SYS_ABILITY_USERIDM, deviceId);
587 ScreenLockSystemAbility::GetInstance()->OnRemoveSystemAbility(SUBSYS_USERIAM_SYS_ABILITY_USERIDM, deviceId);
588 ScreenLockSystemAbility::GetInstance()->OnRemoveSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, deviceId);
589 ScreenLockSystemAbility::GetInstance()->OnStart();
590 EXPECT_EQ(ScreenLockSystemAbility::GetInstance()->state_, ServiceRunningState::STATE_RUNNING);
591 int times = 0;
592 ScreenLockSystemAbility::GetInstance()->RegisterDisplayPowerEventListener(times);
593 bool isLocked;
594 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
595 SCLOCK_HILOGD("Test_SendScreenLockEvent of screendrawdone isLocked=%{public}d", isLocked);
596 EXPECT_EQ(isLocked, true);
597 }
598
599 /**
600 * @tc.name: ScreenLockTest026
601 * @tc.desc: Test GetSecure.
602 * @tc.type: FUNC
603 * @tc.require:
604 * @tc.author:
605 */
606 HWTEST_F(ScreenLockServiceTest, ScreenLockTest026, TestSize.Level0)
607 {
608 SCLOCK_HILOGD("Test GetSecure.");
609 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
610 bool ret = ScreenLockSystemAbility::GetInstance()->GetSecure();
611 EXPECT_EQ(ret, false);
612 }
613
614 /**
615 * @tc.name: ScreenLockTest027
616 * @tc.desc: Test UnlockScreenEvent.
617 * @tc.type: FUNC
618 * @tc.require:
619 * @tc.author:
620 */
621 HWTEST_F(ScreenLockServiceTest, ScreenLockTest027, TestSize.Level0)
622 {
623 SCLOCK_HILOGD("Test UnlockScreenEvent.");
624 ScreenLockSystemAbility::GetInstance()->unlockVecListeners_.clear();
625 ScreenLockSystemAbility::GetInstance()->UnlockScreenEvent(SCREEN_CANCEL);
626 bool isLocked;
627 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
628 EXPECT_EQ(isLocked, true);
629 }
630
631 /**
632 * @tc.name: LockTest028
633 * @tc.desc: Test Lock Screen.
634 * @tc.type: FUNC
635 * @tc.require:
636 * @tc.author:
637 */
638 HWTEST_F(ScreenLockServiceTest, LockTest028, TestSize.Level0)
639 {
640 SCLOCK_HILOGD("Test RequestLock.");
641 int32_t userId = 0;
642 int32_t result = ScreenLockSystemAbility::GetInstance()->Lock(userId);
643 bool ret = ScreenLockSystemAbility::GetInstance()->CheckPermission("ohos.permission.ACCESS_SCREEN_LOCK_INNER");
644 if (!ret) {
645 EXPECT_EQ(result, E_SCREENLOCK_NO_PERMISSION);
646 } else {
647 EXPECT_EQ(result, E_SCREENLOCK_OK);
648 }
649 }
650
651 /**
652 * @tc.name: ScreenLockTest029
653 * @tc.desc: Test SetScreenLockDisabled.
654 * @tc.type: FUNC
655 * @tc.require:
656 * @tc.author:
657 */
658 HWTEST_F(ScreenLockServiceTest, ScreenLockTest029, TestSize.Level0)
659 {
660 SCLOCK_HILOGD("Test SetScreenLockDisabled.");
661 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
662 int userId = 0;
663 int32_t ret = ScreenLockSystemAbility::GetInstance()->SetScreenLockDisabled(false, userId);
664 bool disable = true;
665 int32_t result = ScreenLockSystemAbility::GetInstance()->IsScreenLockDisabled(userId, disable);
666 SCLOCK_HILOGD("SetScreenLockDisabled.[ret]:%{public}d, [disable]:%{public}d", ret, disable);
667
668 userId = 100;
669 ret = ScreenLockSystemAbility::GetInstance()->SetScreenLockDisabled(false, userId);
670 bool retcode = ScreenLockSystemAbility::GetInstance()->CheckPermission("ohos.permission.ACCESS_SCREEN_LOCK");
671 if (!retcode) {
672 EXPECT_EQ(result, E_SCREENLOCK_NO_PERMISSION);
673 } else {
674 EXPECT_EQ(result, E_SCREENLOCK_OK);
675 }
676 }
677
678 /**
679 * @tc.name: ScreenLockTest030
680 * @tc.desc: Test SetScreenLockAuthState.
681 * @tc.type: FUNC
682 * @tc.require:
683 * @tc.author:
684 */
685 HWTEST_F(ScreenLockServiceTest, ScreenLockTest030, TestSize.Level0)
686 {
687 SCLOCK_HILOGD("Test SetScreenLockAuthState.");
688 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
689 int userId = 0;
690 std::string authtoken = "test";
691 int32_t ret = ScreenLockSystemAbility::GetInstance()->SetScreenLockAuthState(1, userId, authtoken);
692 SCLOCK_HILOGD("SetScreenLockAuthState.[ret]:%{public}d", ret);
693
694 int32_t authState = 0;
695 int32_t result = ScreenLockSystemAbility::GetInstance()->GetScreenLockAuthState(userId, authState);
696 bool retcode = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
697 if (retcode) {
698 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
699 } else {
700 EXPECT_EQ(result, E_SCREENLOCK_OK);
701 }
702 }
703
704 /**
705 * @tc.name: ScreenLockTest031
706 * @tc.desc: Test RequestStrongAuth.
707 * @tc.type: FUNC
708 * @tc.require:
709 * @tc.author:
710 */
711 HWTEST_F(ScreenLockServiceTest, ScreenLockTest031, TestSize.Level0)
712 {
713 SCLOCK_HILOGD("Test RequestStrongAuth.");
714 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
715 int32_t userId = 0;
716 int reasonFlag = 1;
717 int32_t ret = ScreenLockSystemAbility::GetInstance()->RequestStrongAuth(reasonFlag, userId);
718
719 ret = ScreenLockSystemAbility::GetInstance()->GetStrongAuth(userId, reasonFlag);
720
721 bool retcode = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
722 if (retcode) {
723 EXPECT_EQ(ret, E_SCREENLOCK_NOT_SYSTEM_APP);
724 } else {
725 EXPECT_EQ(ret, E_SCREENLOCK_OK);
726 }
727 }
728
729 /**
730 * @tc.name: ScreenLockTest032
731 * @tc.desc: Test RequestStrongAuth.
732 * @tc.type: FUNC
733 * @tc.require:
734 * @tc.author:
735 */
736 HWTEST_F(ScreenLockServiceTest, ScreenLockTest032, TestSize.Level0)
737 {
738 SCLOCK_HILOGD("Test RequestStrongAuth.");
739 int fd = 1;
740 std::vector<std::u16string> args = { u"arg1", u"arg2" };
741
742 int result = ScreenLockSystemAbility::GetInstance()->Dump(fd, args);
743 EXPECT_EQ(result, ERR_OK);
744 }
745
746 /**
747 * @tc.name: ScreenLockTest033
748 * @tc.desc: Test IsLockedWithUserId.
749 * @tc.type: FUNC
750 * @tc.require:
751 * @tc.author:
752 */
753 HWTEST_F(ScreenLockServiceTest, ScreenLockTest033, TestSize.Level0)
754 {
755 SCLOCK_HILOGD("Test IsLockedWithUserId.");
756 int fd = 1;
757 std::vector<std::u16string> args = { u"arg1", u"arg2" };
758
759 int32_t userId = 100;
760 bool isLocked = false;
761 int result = ScreenLockSystemAbility::GetInstance()->IsLockedWithUserId(userId, isLocked);
762 bool ret = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
763 if (ret) {
764 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
765 } else {
766 EXPECT_EQ(result, E_SCREENLOCK_OK);
767 }
768 }
769
770 /**
771 * @tc.name: ScreenLockTest034
772 * @tc.desc: Test RegisterInnerListener.
773 * @tc.type: FUNC
774 * @tc.require:
775 * @tc.author:
776 */
777 HWTEST_F(ScreenLockServiceTest, ScreenLockTest034, TestSize.Level0)
778 {
779 SCLOCK_HILOGD("Test RegisterInnerListener.");
780 int fd = 1;
781 std::vector<std::u16string> args = {u"arg1", u"arg2"};
782
783 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
784 int32_t userId = 100;
785 int result = ScreenLockSystemAbility::GetInstance()->RegisterInnerListener(
786 userId, ListenType::DEVICE_LOCK, InnerListenerIfTest1);
787 bool ret = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
788 if (ret) {
789 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
790 } else {
791 EXPECT_EQ(result, E_SCREENLOCK_NULLPTR);
792 }
793 result = ScreenLockSystemAbility::GetInstance()->RegisterInnerListener(
794 userId, ListenType::STRONG_AUTH, InnerListenerIfTest1);
795 if (ret) {
796 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
797 } else {
798 EXPECT_EQ(result, E_SCREENLOCK_NULLPTR);
799 }
800 }
801
802 /**
803 * @tc.name: ScreenLockTest035
804 * @tc.desc: Test UnRegisterInnerListener.
805 * @tc.type: FUNC
806 * @tc.require:
807 * @tc.author:
808 */
809 HWTEST_F(ScreenLockServiceTest, ScreenLockTest035, TestSize.Level0)
810 {
811 SCLOCK_HILOGD("Test UnRegisterInnerListener.");
812 int fd = 1;
813 std::vector<std::u16string> args = {u"arg1", u"arg2"};
814
815 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
816 int32_t userId = 100;
817 int result = ScreenLockSystemAbility::GetInstance()->UnRegisterInnerListener(
818 userId, ListenType::DEVICE_LOCK, InnerListenerIfTest1);
819 bool ret = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
820 if (ret) {
821 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
822 } else {
823 EXPECT_EQ(result, E_SCREENLOCK_OK);
824 }
825 result = ScreenLockSystemAbility::GetInstance()->UnRegisterInnerListener(
826 userId, ListenType::STRONG_AUTH, InnerListenerIfTest1);
827 if (ret) {
828 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
829 } else {
830 EXPECT_EQ(result, E_SCREENLOCK_OK);
831 }
832 }
833
834 /**
835 * @tc.name: ScreenLockTest036
836 * @tc.desc: Test IsDeviceLocked.
837 * @tc.type: FUNC
838 * @tc.require:
839 * @tc.author:
840 */
841 HWTEST_F(ScreenLockServiceTest, ScreenLockTest036, TestSize.Level0)
842 {
843 SCLOCK_HILOGD("Test IsDeviceLocked.");
844 int fd = 1;
845 std::vector<std::u16string> args = { u"arg1", u"arg2" };
846
847 bool isDeviceLocked = false;
848 int32_t userId = 100;
849 int result = ScreenLockSystemAbility::GetInstance()->IsDeviceLocked(userId, isDeviceLocked);
850 bool ret = ScreenLockSystemAbility::GetInstance()->CheckSystemPermission();
851 if (ret) {
852 EXPECT_EQ(result, E_SCREENLOCK_NOT_SYSTEM_APP);
853 } else {
854 EXPECT_EQ(result, E_SCREENLOCK_USER_ID_INVALID);
855 }
856 }
857
858 /**
859 * @tc.name: ScreenLockTest037
860 * @tc.desc: Test InnerListenerManager RegisterInnerListener.
861 * @tc.type: FUNC
862 * @tc.require:
863 * @tc.author:
864 */
865 HWTEST_F(ScreenLockServiceTest, ScreenLockTest037, TestSize.Level0)
866 {
867 SCLOCK_HILOGD("Test InnerListenerManager RegisterInnerListener.");
868 int fd = 1;
869 std::vector<std::u16string> args = { u"arg1", u"arg2" };
870
871 int32_t userId = 100;
872 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
873 int32_t result = InnerListenerManager::GetInstance()->RegisterInnerListener(userId, ListenType::DEVICE_LOCK,
874 InnerListenerIfTest1);
875 SCLOCK_HILOGI("ScreenLockTest037.[result1]:%{public}d", result);
876 EXPECT_EQ(result, E_SCREENLOCK_NULLPTR);
877
878 result = InnerListenerManager::GetInstance()->UnRegisterInnerListener(ListenType::DEVICE_LOCK,
879 InnerListenerIfTest1);
880 SCLOCK_HILOGI("ScreenLockTest037.[result2]:%{public}d", result);
881 EXPECT_EQ(result, E_SCREENLOCK_OK);
882 }
883
884 /**
885 * @tc.name: ScreenLockTest038
886 * @tc.desc: Test InnerListenerManager OnStrongAuthChanged.
887 * @tc.type: FUNC
888 * @tc.require:
889 * @tc.author:
890 */
891 HWTEST_F(ScreenLockServiceTest, ScreenLockTest038, TestSize.Level0)
892 {
893 SCLOCK_HILOGD("Test InnerListenerManager OnStrongAuthChanged.");
894 int fd = 1;
895 std::vector<std::u16string> args = { u"arg1", u"arg2" };
896
897 int32_t userId = 100;
898 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
899 int32_t result = InnerListenerManager::GetInstance()->RegisterInnerListener(userId, ListenType::STRONG_AUTH,
900 InnerListenerIfTest1);
901 InnerListenerManager::GetInstance()->OnStrongAuthChanged(userId, 0);
902 SCLOCK_HILOGI("ScreenLockTest038.[result]:%{public}d", result);
903 EXPECT_EQ(result, E_SCREENLOCK_NULLPTR);
904 }
905
906 /**
907 * @tc.name: ScreenLockTest039
908 * @tc.desc: Test InnerListenerManager OnStrongAuthChanged.
909 * @tc.type: FUNC
910 * @tc.require:
911 * @tc.author:
912 */
913 HWTEST_F(ScreenLockServiceTest, ScreenLockTest039, TestSize.Level0)
914 {
915 SCLOCK_HILOGD("Test InnerListenerManager OnDeviceLockStateChanged.");
916 int fd = 1;
917 std::vector<std::u16string> args = { u"arg1", u"arg2" };
918
919 int32_t userId = 100;
920 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
921 int32_t result = InnerListenerManager::GetInstance()->RegisterInnerListener(userId, ListenType::DEVICE_LOCK,
922 InnerListenerIfTest1);
923 InnerListenerManager::GetInstance()->OnDeviceLockStateChanged(userId, 0);
924 SCLOCK_HILOGI("ScreenLockTest038.[result]:%{public}d", result);
925 EXPECT_EQ(result, E_SCREENLOCK_NULLPTR);
926 }
927
928 /**
929 * @tc.name: ScreenLockTest040
930 * @tc.desc: Test UserIamReadyCallback.
931 * @tc.type: FUNC
932 * @tc.require:
933 * @tc.author:
934 */
935 HWTEST_F(ScreenLockServiceTest, ScreenLockTest040, TestSize.Level0)
936 {
937 SCLOCK_HILOGD("Test UserIamReadyCallback.");
938 int fd = 1;
939
940 int32_t userId = 100;
941
942 int32_t otherUserId = 102;
943 ScreenLockSystemAbility::GetInstance()->OnRemoveUser(otherUserId);
944 ScreenLockSystemAbility::GetInstance()->OnActiveUser(userId, otherUserId);
945 ScreenLockSystemAbility::GetInstance()->OnRemoveUser(otherUserId);
946 ScreenLockSystemAbility::GetInstance()->OnSystemReady();
947 }
948
949 /**
950 * @tc.name: ScreenLockTest041
951 * @tc.desc: Test InnerListenerManager AddInnerListener.
952 * @tc.type: FUNC
953 * @tc.require:
954 * @tc.author:
955 */
956 HWTEST_F(ScreenLockServiceTest, ScreenLockTest041, TestSize.Level0)
957 {
958 SCLOCK_HILOGD("Test UserIamReadyCallback.");
959 int fd = 1;
960
961 int32_t userId = 100;
962
963 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
964 InnerListenerManager::GetInstance()->HasListenerSet(userId, ListenType::DEVICE_LOCK);
965
966 int32_t result =
967 InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
968
969 result =
970 InnerListenerManager::GetInstance()->AddInnerListener(userId, ListenType::DEVICE_LOCK, InnerListenerIfTest1);
971
972 InnerListenerManager::GetInstance()->getListenerSet(userId, ListenType::DEVICE_LOCK);
973
974 InnerListenerManager::GetInstance()->getListenerSet(101, ListenType::DEVICE_LOCK);
975
976 InnerListenerManager::GetInstance()->HasListenerSet(userId, ListenType::DEVICE_LOCK);
977
978 InnerListenerManager::GetInstance()->HasListenerSet(userId, ListenType::STRONG_AUTH);
979
980 result =
981 InnerListenerManager::GetInstance()->AddInnerListener(userId, ListenType::DEVICE_LOCK, InnerListenerIfTest1);
982
983 result = InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
984
985 result = InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
986
987 InnerListenerManager::GetInstance()->OnDeviceLockStateChanged(userId, 0);
988 SCLOCK_HILOGI("ScreenLockTest041.[result]:%{public}d", result);
989 EXPECT_EQ(result, E_SCREENLOCK_OK);
990 }
991
992 /**
993 * @tc.name: ScreenLockTest042
994 * @tc.desc: Test InnerListenerManager RemoveInnerListener.
995 * @tc.type: FUNC
996 * @tc.require:
997 * @tc.author:
998 */
999 HWTEST_F(ScreenLockServiceTest, ScreenLockTest042, TestSize.Level0)
1000 {
1001 SCLOCK_HILOGD("Test RemoveInnerListener.");
1002 int fd = 1;
1003
1004 int32_t userId = 100;
1005
1006 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
1007
1008 int32_t result =
1009 InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
1010
1011 result = InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
1012
1013 InnerListenerManager::GetInstance()->OnDeviceLockStateChanged(userId, 0);
1014 SCLOCK_HILOGI("ScreenLockTest042.[result]:%{public}d", result);
1015 EXPECT_EQ(result, E_SCREENLOCK_OK);
1016 }
1017
1018 /**
1019 * @tc.name: ScreenLockTest043
1020 * @tc.desc: Test GetDeviceLockedStateByAuth.
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 * @tc.author:
1024 */
1025 HWTEST_F(ScreenLockServiceTest, ScreenLockTest043, TestSize.Level0)
1026 {
1027 SCLOCK_HILOGD("Test GetDeviceLockedStateByAuth.");
1028 int fd = 1;
1029 int32_t authState = 5;
1030 int32_t userId = 102;
1031
1032 ScreenLockSystemAbility::GetInstance()->AuthStateInit(userId);
1033
1034 ScreenLockSystemAbility::GetInstance()->AuthStateInit(userId);
1035
1036 bool result = ScreenLockSystemAbility::GetInstance()->GetDeviceLockedStateByAuth(authState);
1037
1038 authState = 1;
1039
1040 result = ScreenLockSystemAbility::GetInstance()->GetDeviceLockedStateByAuth(authState);
1041 SCLOCK_HILOGI("ScreenLockTest043.[result]:%{public}d", result);
1042 EXPECT_EQ(result, true);
1043 }
1044
1045 /**
1046 * @tc.name: ScreenLockTest044
1047 * @tc.desc: Test InnerListenerManager RemoveInnerListener.
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 * @tc.author:
1051 */
1052 HWTEST_F(ScreenLockServiceTest, ScreenLockTest044, TestSize.Level0)
1053 {
1054 SCLOCK_HILOGD("Test GetDeviceLockedStateByAuth.");
1055 int fd = 1;
1056
1057 int32_t userId = 100;
1058
1059 sptr<InnerListenerIf> InnerListenerIfTest1 = new (std::nothrow) InnerListenerIfTest();
1060
1061 int32_t result =
1062 InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
1063
1064 result = InnerListenerManager::GetInstance()->RemoveInnerListener(ListenType::DEVICE_LOCK, InnerListenerIfTest1);
1065
1066 InnerListenerManager::GetInstance()->OnDeviceLockStateChanged(userId, 0);
1067 SCLOCK_HILOGI("ScreenLockTest041.[result]:%{public}d", result);
1068 EXPECT_EQ(result, E_SCREENLOCK_OK);
1069 }
1070 } // namespace ScreenLock
1071 } // namespace OHOS