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 #undef private
19 #undef protected
20
21 #include <cstdint>
22 #include <list>
23 #include <string>
24 #include <sys/time.h>
25
26 #include "sclock_log.h"
27 #include "screenlock_callback_test.h"
28 #include "screenlock_common.h"
29 #include "screenlock_event_list_test.h"
30 #include "screenlock_notify_test_instance.h"
31 #include "screenlock_service_test.h"
32 #include "screenlock_system_ability.h"
33 #include "screenlock_system_ability_stub.h"
34 #include "securec.h"
35 #include "scene_board_judgement.h"
36
37 namespace OHOS {
38 namespace ScreenLock {
39 using namespace testing::ext;
40 using namespace OHOS::Rosen;
41 constexpr const uint16_t EACH_LINE_LENGTH = 100;
42 constexpr const uint16_t TOTAL_LENGTH = 1000;
43 constexpr const char *CMD1 = "hidumper -s 3704";
44 constexpr const char *CMD2 = "hidumper -s 3704 -a -h";
45 constexpr const char *CMD3 = "hidumper -s 3704 -a -all";
46
47 static EventListenerTest g_unlockTestListener;
48
SetUpTestCase()49 void ScreenLockServiceTest::SetUpTestCase()
50 {
51 }
52
TearDownTestCase()53 void ScreenLockServiceTest::TearDownTestCase()
54 {
55 ScreenLockSystemAbility::GetInstance()->ResetFfrtQueue();
56 }
57
SetUp()58 void ScreenLockServiceTest::SetUp()
59 {
60 }
61
TearDown()62 void ScreenLockServiceTest::TearDown()
63 {
64 }
65
ExecuteCmd(const std::string & cmd,std::string & result)66 bool ScreenLockServiceTest::ExecuteCmd(const std::string &cmd, std::string &result)
67 {
68 char buff[EACH_LINE_LENGTH] = { 0x00 };
69 char output[TOTAL_LENGTH] = { 0x00 };
70 FILE *ptr = popen(cmd.c_str(), "r");
71 if (ptr != nullptr) {
72 while (fgets(buff, sizeof(buff), ptr) != nullptr) {
73 if (strcat_s(output, sizeof(output), buff) != 0) {
74 pclose(ptr);
75 ptr = nullptr;
76 return false;
77 }
78 }
79 pclose(ptr);
80 ptr = nullptr;
81 } else {
82 return false;
83 }
84 result = std::string(output);
85 return true;
86 }
87
88 /**
89 * @tc.name: ScreenLockTest001
90 * @tc.desc: beginWakeUp event.
91 * @tc.type: FUNC
92 * @tc.require:
93 * @tc.author:
94 */
95 HWTEST_F(ScreenLockServiceTest, ScreenLockTest001, TestSize.Level0)
96 {
97 SCLOCK_HILOGD("Test event of beginWakeUp");
98 ScreenLockSystemAbility::GetInstance();
99 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
100 EventStatus status = EventStatus::BEGIN;
101 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
102 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
103 ASSERT_NE(displayPowerEventListener, nullptr);
104 displayPowerEventListener->OnDisplayPowerEvent(event, status);
105 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
106 SCLOCK_HILOGD("Test_BeginWakeUp retVal=%{public}d", retVal);
107 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_WAKEUP));
108 }
109
110 /**
111 * @tc.name: ScreenLockTest002
112 * @tc.desc: OnsystemEvent
113 * @tc.type: FUNC
114 * @tc.require:
115 * @tc.author:
116 */
117 HWTEST_F(ScreenLockServiceTest, ScreenLockTest002, TestSize.Level0)
118 {
119 SCLOCK_HILOGD("Test OnsystemEvent");
120 sptr<ScreenLockSystemAbilityInterface> listener = new (std::nothrow)
121 ScreenlockNotifyTestInstance(g_unlockTestListener);
122 ASSERT_NE(listener, nullptr);
123 ScreenLockSystemAbility::GetInstance()->OnSystemEvent(listener);
124 EXPECT_NE(ScreenLockSystemAbility::GetInstance()->systemEventListener_, nullptr);
125 }
126
127 /**
128 * @tc.name: ScreenLockTest003
129 * @tc.desc: beginSleep event.
130 * @tc.type: FUNC
131 * @tc.require:
132 * @tc.author:
133 */
134 HWTEST_F(ScreenLockServiceTest, ScreenLockTest003, TestSize.Level0)
135 {
136 SCLOCK_HILOGD("Test event of beginsleep");
137 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
138 ScreenLockSystemAbility::GetInstance()->OnStart();
139 DisplayPowerEvent event = DisplayPowerEvent::SLEEP;
140 EventStatus status = EventStatus::BEGIN;
141 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
142 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
143 ASSERT_NE(displayPowerEventListener, nullptr);
144 displayPowerEventListener->OnDisplayPowerEvent(event, status);
145 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
146 SCLOCK_HILOGD("Test_BeginSleep retVal=%{public}d", retVal);
147 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_SLEEP));
148 }
149
150 /**
151 * @tc.name: ScreenLockTest004
152 * @tc.desc: beginScreenOn event.
153 * @tc.type: FUNC
154 * @tc.require:
155 * @tc.author:
156 */
157 HWTEST_F(ScreenLockServiceTest, ScreenLockTest004, TestSize.Level0)
158 {
159 SCLOCK_HILOGD("Test event of beginscreenon");
160 ScreenLockSystemAbility::GetInstance();
161 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_ON;
162 EventStatus status = EventStatus::BEGIN;
163 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
164 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
165 ASSERT_NE(displayPowerEventListener, nullptr);
166 displayPowerEventListener->OnDisplayPowerEvent(event, status);
167 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
168 SCLOCK_HILOGD("Test_BeginScreenOn retVal=%{public}d", retVal);
169 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_ON));
170 }
171
172 /**
173 * @tc.name: ScreenLockTest005
174 * @tc.desc: beginScreenOff event.
175 * @tc.type: FUNC
176 * @tc.require:
177 * @tc.author:
178 */
179 HWTEST_F(ScreenLockServiceTest, ScreenLockTest005, TestSize.Level0)
180 {
181 SCLOCK_HILOGD("Test event of beginscreenoff");
182 ScreenLockSystemAbility::GetInstance();
183 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_OFF;
184 EventStatus status = EventStatus::BEGIN;
185 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
186 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
187 ASSERT_NE(displayPowerEventListener, nullptr);
188 displayPowerEventListener->OnDisplayPowerEvent(event, status);
189 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
190 SCLOCK_HILOGD("Test_BeginScreenOff retVal=%{public}d", retVal);
191 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_OFF));
192 }
193
194 /**
195 * @tc.name: ScreenLockTest006
196 * @tc.desc: endWakeUp event.
197 * @tc.type: FUNC
198 * @tc.require:
199 * @tc.author:
200 */
201 HWTEST_F(ScreenLockServiceTest, ScreenLockTest006, TestSize.Level0)
202 {
203 SCLOCK_HILOGD("Test event of endwakeup");
204 ScreenLockSystemAbility::GetInstance();
205 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
206 EventStatus status = EventStatus::END;
207 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
208 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
209 ASSERT_NE(displayPowerEventListener, nullptr);
210 displayPowerEventListener->OnDisplayPowerEvent(event, status);
211 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
212 SCLOCK_HILOGD("Test_EndWakeUp retVal=%{public}d", retVal);
213 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_WAKEUP));
214 }
215
216 /**
217 * @tc.name: ScreenLockTest007
218 * @tc.desc: endSleep event.
219 * @tc.type: FUNC
220 * @tc.require:
221 * @tc.author:
222 */
223 HWTEST_F(ScreenLockServiceTest, ScreenLockTest007, TestSize.Level0)
224 {
225 SCLOCK_HILOGD("Test event of endsleep");
226 ScreenLockSystemAbility::GetInstance();
227 DisplayPowerEvent event = DisplayPowerEvent::SLEEP;
228 EventStatus status = EventStatus::END;
229 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
230 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
231 ASSERT_NE(displayPowerEventListener, nullptr);
232 displayPowerEventListener->OnDisplayPowerEvent(event, status);
233 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetInteractiveState();
234 SCLOCK_HILOGD("Test_EndSleep retVal=%{public}d", retVal);
235 EXPECT_EQ(retVal, static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_SLEEP));
236 }
237
238 /**
239 * @tc.name: ScreenLockTest008
240 * @tc.desc: endScreenOn event.
241 * @tc.type: FUNC
242 * @tc.require:
243 * @tc.author:
244 */
245 HWTEST_F(ScreenLockServiceTest, ScreenLockTest008, TestSize.Level0)
246 {
247 SCLOCK_HILOGD("Test event of endscreenon");
248 ScreenLockSystemAbility::GetInstance();
249 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_ON;
250 EventStatus status = EventStatus::END;
251 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
252 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
253 ASSERT_NE(displayPowerEventListener, nullptr);
254 displayPowerEventListener->OnDisplayPowerEvent(event, status);
255 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
256 SCLOCK_HILOGD("Test_EndScreenOn retVal=%{public}d", retVal);
257 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_END_ON));
258 }
259
260 /**
261 * @tc.name: ScreenLockTest009
262 * @tc.desc: endScreenOff and begin desktopready event.
263 * @tc.type: FUNC
264 * @tc.require:
265 * @tc.author:
266 */
267 HWTEST_F(ScreenLockServiceTest, ScreenLockTest009, TestSize.Level0)
268 {
269 SCLOCK_HILOGD("Test event of endscreenoff");
270 ScreenLockSystemAbility::GetInstance();
271 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_OFF;
272 EventStatus status = EventStatus::END;
273 sptr<ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener> displayPowerEventListener = new (std::nothrow)
274 ScreenLockSystemAbility::ScreenLockDisplayPowerEventListener();
275 ASSERT_NE(displayPowerEventListener, nullptr);
276 displayPowerEventListener->OnDisplayPowerEvent(event, status);
277 event = DisplayPowerEvent::DESKTOP_READY;
278 status = EventStatus::BEGIN;
279 displayPowerEventListener->OnDisplayPowerEvent(event, status);
280 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenState();
281 SCLOCK_HILOGD("Test_EndScreenOff retVal=%{public}d", retVal);
282 EXPECT_EQ(retVal, static_cast<int>(ScreenState::SCREEN_STATE_END_OFF));
283 }
284
285 /**
286 * @tc.name: ScreenLockTest010
287 * @tc.desc: changeUser event.
288 * @tc.type: FUNC
289 * @tc.require:
290 * @tc.author:
291 */
292 HWTEST_F(ScreenLockServiceTest, ScreenLockTest010, TestSize.Level0)
293 {
294 SCLOCK_HILOGD("Test event of changeuser");
295 int paramOne = 10;
296 ScreenLockSystemAbility::GetInstance()->OnChangeUser(paramOne);
297 int retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetCurrentUser();
298 SCLOCK_HILOGD("Test_ChangeUser retVal=%{public}d", retVal);
299 EXPECT_EQ(retVal, paramOne);
300 int paramTwo = -1;
301 ScreenLockSystemAbility::GetInstance()->OnChangeUser(paramTwo);
302 retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetCurrentUser();
303 EXPECT_EQ(retVal, paramOne);
304 }
305
306 /**
307 * @tc.name: ScreenLockTest011
308 * @tc.desc: screenLockEnabled event.
309 * @tc.type: FUNC
310 * @tc.require:
311 * @tc.author:
312 */
313 HWTEST_F(ScreenLockServiceTest, ScreenLockTest011, TestSize.Level0)
314 {
315 SCLOCK_HILOGD("Test event of screenlockenabled");
316 bool enabled = SCREENLOCK_APP_CAN_USE;
317 ScreenLockSystemAbility::GetInstance()->OnScreenlockEnabled(enabled);
318 bool retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenlockEnabled();
319 SCLOCK_HILOGD("Test_ScreenLockEnabled retVal=%{public}d", retVal);
320 EXPECT_EQ(retVal, enabled);
321 }
322
323 /**
324 * @tc.name: ScreenLockTest012
325 * @tc.desc: screenLockEnabled event.
326 * @tc.type: FUNC
327 * @tc.require:
328 * @tc.author:
329 */
330 HWTEST_F(ScreenLockServiceTest, ScreenLockTest012, TestSize.Level0)
331 {
332 SCLOCK_HILOGD("Test event of screenlockenabled");
333 bool enabled = SCREENLOCK_APP_CAN_NOT_USE;
334 ScreenLockSystemAbility::GetInstance()->OnScreenlockEnabled(enabled);
335 bool retVal = ScreenLockSystemAbility::GetInstance()->GetState().GetScreenlockEnabled();
336 SCLOCK_HILOGD("Test_ScreenLockEnabled retVal=%{public}d", retVal);
337 EXPECT_EQ(retVal, enabled);
338 }
339
340 /**
341 * @tc.name: ScreenLockDumperTest013
342 * @tc.desc: dump showhelp.
343 * @tc.type: FUNC
344 * @tc.require:
345 * @tc.author:
346 */
347 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest013, TestSize.Level0)
348 {
349 SCLOCK_HILOGD("Test hidumper of showhelp");
350 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
351 EXPECT_TRUE(true);
352 return; // Because there is no ScreenLock SA when the Sceneboard is enabled, skip the following use cases.
353 }
354 std::string result;
355 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD1, result);
356 EXPECT_TRUE(ret);
357 EXPECT_NE(result.find("Option"), std::string::npos);
358 EXPECT_NE(result.find("-all"), std::string::npos);
359 }
360
361 /**
362 * @tc.name: ScreenLockDumperTest014
363 * @tc.desc: dump showhelp.
364 * @tc.type: FUNC
365 * @tc.require:
366 * @tc.author:
367 */
368 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest014, TestSize.Level0)
369 {
370 SCLOCK_HILOGD("Test hidumper of -h");
371 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
372 EXPECT_TRUE(true);
373 return; // Because there is no ScreenLock SA when the Sceneboard is enabled, skip the following use cases.
374 }
375 std::string result;
376 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD2, result);
377 EXPECT_TRUE(ret);
378 EXPECT_NE(result.find("Description"), std::string::npos);
379 EXPECT_NE(result.find("dump all screenlock information"), std::string::npos);
380 }
381
382 /**
383 * @tc.name: ScreenLockDumperTest015
384 * @tc.desc: dump screenlock information.
385 * @tc.type: FUNC
386 * @tc.require:
387 * @tc.author:
388 */
389 HWTEST_F(ScreenLockServiceTest, ScreenLockDumperTest015, TestSize.Level0)
390 {
391 SCLOCK_HILOGD("Test hidumper of -all");
392 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
393 EXPECT_TRUE(true);
394 return; // Because there is no ScreenLock SA when the Sceneboard is enabled, skip the following use cases.
395 }
396 std::string result;
397 auto ret = ScreenLockServiceTest::ExecuteCmd(CMD3, result);
398 EXPECT_TRUE(ret);
399 EXPECT_NE(result.find("screenLocked"), std::string::npos);
400 EXPECT_NE(result.find("screenState"), std::string::npos);
401 EXPECT_NE(result.find("offReason"), std::string::npos);
402 EXPECT_NE(result.find("interactiveState"), std::string::npos);
403 }
404
405 /**
406 * @tc.name: ScreenLockTest016
407 * @tc.desc: Test Lock.
408 * @tc.type: FUNC
409 * @tc.require:
410 * @tc.author:
411 */
412 HWTEST_F(ScreenLockServiceTest, ScreenLockTest016, TestSize.Level0)
413 {
414 SCLOCK_HILOGD("Test RequestLock");
415 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
416 sptr<ScreenLockCallbackInterface> listener = new (std::nothrow) ScreenlockCallbackTest(g_unlockTestListener);
417 ASSERT_NE(listener, nullptr);
418
419 ScreenLockSystemAbility::GetInstance()->stateValue_.SetScreenlocked(true);
420 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
421 EXPECT_EQ(isLocked, true);
422 int32_t result = ScreenLockSystemAbility::GetInstance()->Lock(listener);
423 EXPECT_EQ(result, E_SCREENLOCK_NO_PERMISSION);
424 ScreenLockSystemAbility::GetInstance()->stateValue_.SetScreenlocked(false);
425 result = ScreenLockSystemAbility::GetInstance()->Lock(listener);
426 EXPECT_EQ(result, E_SCREENLOCK_OK);
427 }
428
429 /**
430 * @tc.name: ScreenLockTest017
431 * @tc.desc: Test Unlock and UnlockScreen.
432 * @tc.type: FUNC
433 * @tc.require:
434 * @tc.author:
435 */
436 HWTEST_F(ScreenLockServiceTest, ScreenLockTest017, TestSize.Level0)
437 {
438 SCLOCK_HILOGD("Test RequestUnlock");
439 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
440 sptr<ScreenLockCallbackInterface> listener = new (std::nothrow) ScreenlockCallbackTest(g_unlockTestListener);
441 ASSERT_NE(listener, nullptr);
442 ScreenLockSystemAbility::GetInstance()->UnlockScreen(listener);
443 int32_t result = ScreenLockSystemAbility::GetInstance()->Unlock(listener);
444 EXPECT_EQ(result, E_SCREENLOCK_OK);
445 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
446 result = ScreenLockSystemAbility::GetInstance()->Unlock(listener);
447 EXPECT_EQ(result, E_SCREENLOCK_OK);
448 }
449
450 /**
451 * @tc.name: ScreenLockTest018
452 * @tc.desc: Test SendScreenLockEvent.
453 * @tc.type: FUNC
454 * @tc.require:
455 * @tc.author:
456 */
457 HWTEST_F(ScreenLockServiceTest, ScreenLockTest018, TestSize.Level0)
458 {
459 SCLOCK_HILOGD("Test SendScreenLockEvent");
460 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_SUCC);
461 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
462 EXPECT_EQ(isLocked, false);
463 }
464
465 /**
466 * @tc.name: ScreenLockTest019
467 * @tc.desc: Test SendScreenLockEvent.
468 * @tc.type: FUNC
469 * @tc.require:
470 * @tc.author:
471 */
472 HWTEST_F(ScreenLockServiceTest, ScreenLockTest019, TestSize.Level0)
473 {
474 SCLOCK_HILOGD("Test SendScreenLockEvent");
475 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_FAIL);
476 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
477 EXPECT_EQ(isLocked, true);
478 }
479
480 /**
481 * @tc.name: ScreenLockTest020
482 * @tc.desc: Test SendScreenLockEvent.
483 * @tc.type: FUNC
484 * @tc.require:
485 * @tc.author:
486 */
487 HWTEST_F(ScreenLockServiceTest, ScreenLockTest020, TestSize.Level0)
488 {
489 SCLOCK_HILOGD("Test SendScreenLockEvent");
490 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_CANCEL);
491 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
492 EXPECT_EQ(isLocked, true);
493 }
494
495 /**
496 * @tc.name: ScreenLockTest021
497 * @tc.desc: Test SendScreenLockEvent.
498 * @tc.type: FUNC
499 * @tc.require:
500 * @tc.author:
501 */
502 HWTEST_F(ScreenLockServiceTest, ScreenLockTest021, TestSize.Level0)
503 {
504 SCLOCK_HILOGD("Test SendScreenLockEvent");
505 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_SUCC);
506 bool isLocked;
507 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
508 EXPECT_EQ(isLocked, true);
509 }
510
511 /**
512 * @tc.name: ScreenLockTest022
513 * @tc.desc: Test SendScreenLockEvent.
514 * @tc.type: FUNC
515 * @tc.require:
516 * @tc.author:
517 */
518 HWTEST_F(ScreenLockServiceTest, ScreenLockTest022, TestSize.Level0)
519 {
520 SCLOCK_HILOGD("Test SendScreenLockEvent");
521 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_FAIL);
522 bool isLocked;
523 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
524 EXPECT_EQ(isLocked, false);
525 }
526
527 /**
528 * @tc.name: ScreenLockTest023
529 * @tc.desc: Test SendScreenLockEvent.
530 * @tc.type: FUNC
531 * @tc.require:
532 * @tc.author:
533 */
534 HWTEST_F(ScreenLockServiceTest, ScreenLockTest023, TestSize.Level0)
535 {
536 SCLOCK_HILOGD("Test SendScreenLockEvent");
537 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_CANCEL);
538 bool isLocked;
539 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
540 EXPECT_EQ(isLocked, false);
541 }
542
543 /**
544 * @tc.name: ScreenLockTest024
545 * @tc.desc: Test SendScreenLockEvent.
546 * @tc.type: FUNC
547 * @tc.require:
548 * @tc.author:
549 */
550 HWTEST_F(ScreenLockServiceTest, ScreenLockTest024, TestSize.Level0)
551 {
552 SCLOCK_HILOGD("Test SendScreenLockEvent");
553 ScreenLockSystemAbility::GetInstance()->OnSystemReady();
554 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(SCREEN_DRAWDONE, SCREEN_CANCEL);
555 bool isLocked;
556 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
557 EXPECT_EQ(isLocked, true);
558 }
559
560 /**
561 * @tc.name: ScreenLockTest025
562 * @tc.desc: Test Onstop and OnStart.
563 * @tc.type: FUNC
564 * @tc.require:
565 * @tc.author:
566 */
567 HWTEST_F(ScreenLockServiceTest, ScreenLockTest025, TestSize.Level0)
568 {
569 SCLOCK_HILOGD("Test Onstop");
570 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
571 EXPECT_TRUE(true);
572 return; // Because there is no ScreenLock SA when the Sceneboard is enabled, skip the following use cases.
573 }
574 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
575 ScreenLockSystemAbility::GetInstance()->OnStart();
576 ScreenLockSystemAbility::GetInstance()->OnStop();
577 ScreenLockSystemAbility::GetInstance()->OnStart();
578 EXPECT_EQ(ScreenLockSystemAbility::GetInstance()->state_, ServiceRunningState::STATE_NOT_START);
579 int times = 0;
580 ScreenLockSystemAbility::GetInstance()->RegisterDisplayPowerEventListener(times);
581 bool isLocked;
582 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
583 SCLOCK_HILOGD("Test_SendScreenLockEvent of screendrawdone isLocked=%{public}d", isLocked);
584 EXPECT_EQ(isLocked, false);
585 }
586
587 /**
588 * @tc.name: ScreenLockTest026
589 * @tc.desc: Test GetSecure.
590 * @tc.type: FUNC
591 * @tc.require:
592 * @tc.author:
593 */
594 HWTEST_F(ScreenLockServiceTest, ScreenLockTest026, TestSize.Level0)
595 {
596 SCLOCK_HILOGD("Test GetSecure.");
597 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
598 bool ret = ScreenLockSystemAbility::GetInstance()->GetSecure();
599 EXPECT_EQ(ret, false);
600 }
601
602 /**
603 * @tc.name: ScreenLockTest027
604 * @tc.desc: Test UnlockScreenEvent.
605 * @tc.type: FUNC
606 * @tc.require:
607 * @tc.author:
608 */
609 HWTEST_F(ScreenLockServiceTest, ScreenLockTest027, TestSize.Level0)
610 {
611 SCLOCK_HILOGD("Test UnlockScreenEvent.");
612 ScreenLockSystemAbility::GetInstance()->unlockVecListeners_.clear();
613 ScreenLockSystemAbility::GetInstance()->UnlockScreenEvent(SCREEN_CANCEL);
614 bool isLocked;
615 ScreenLockSystemAbility::GetInstance()->IsLocked(isLocked);
616 EXPECT_EQ(isLocked, true);
617 }
618 } // namespace ScreenLock
619 } // namespace OHOS