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