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()->RequestLock(listener);
440 EXPECT_EQ(result, E_SCREENLOCK_NO_PERMISSION);
441 ScreenLockSystemAbility::GetInstance()->stateValue_.SetScreenlocked(false);
442 result = ScreenLockSystemAbility::GetInstance()->RequestLock(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 if (listener == nullptr) {
459 SCLOCK_HILOGE("listener object is nullptr");
460 EXPECT_EQ(false, true);
461 return;
462 }
463 int32_t result = ScreenLockSystemAbility::GetInstance()->RequestUnlock(listener);
464 EXPECT_EQ(result, E_SCREENLOCK_OK);
465 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
466 result = ScreenLockSystemAbility::GetInstance()->RequestUnlock(listener);
467 EXPECT_EQ(result, E_SCREENLOCK_OK);
468 }
469
470 /**
471 * @tc.name: ScreenLockTest018
472 * @tc.desc: Test SendScreenLockEvent.
473 * @tc.type: FUNC
474 * @tc.require:
475 * @tc.author:
476 */
477 HWTEST_F(ScreenLockServiceTest, ScreenLockTest018, TestSize.Level0)
478 {
479 SCLOCK_HILOGD("Test SendScreenLockEvent");
480 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_SUCC);
481 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
482 EXPECT_EQ(isLocked, false);
483 }
484
485 /**
486 * @tc.name: ScreenLockTest019
487 * @tc.desc: Test SendScreenLockEvent.
488 * @tc.type: FUNC
489 * @tc.require:
490 * @tc.author:
491 */
492 HWTEST_F(ScreenLockServiceTest, ScreenLockTest019, TestSize.Level0)
493 {
494 SCLOCK_HILOGD("Test SendScreenLockEvent");
495 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_FAIL);
496 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
497 EXPECT_EQ(isLocked, true);
498 }
499
500 /**
501 * @tc.name: ScreenLockTest020
502 * @tc.desc: Test SendScreenLockEvent.
503 * @tc.type: FUNC
504 * @tc.require:
505 * @tc.author:
506 */
507 HWTEST_F(ScreenLockServiceTest, ScreenLockTest020, TestSize.Level0)
508 {
509 SCLOCK_HILOGD("Test SendScreenLockEvent");
510 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(UNLOCK_SCREEN_RESULT, SCREEN_CANCEL);
511 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
512 EXPECT_EQ(isLocked, true);
513 }
514
515 /**
516 * @tc.name: ScreenLockTest021
517 * @tc.desc: Test SendScreenLockEvent.
518 * @tc.type: FUNC
519 * @tc.require:
520 * @tc.author:
521 */
522 HWTEST_F(ScreenLockServiceTest, ScreenLockTest021, TestSize.Level0)
523 {
524 SCLOCK_HILOGD("Test SendScreenLockEvent");
525 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_SUCC);
526 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
527 EXPECT_EQ(isLocked, true);
528 }
529
530 /**
531 * @tc.name: ScreenLockTest022
532 * @tc.desc: Test SendScreenLockEvent.
533 * @tc.type: FUNC
534 * @tc.require:
535 * @tc.author:
536 */
537 HWTEST_F(ScreenLockServiceTest, ScreenLockTest022, TestSize.Level0)
538 {
539 SCLOCK_HILOGD("Test SendScreenLockEvent");
540 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_FAIL);
541 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
542 EXPECT_EQ(isLocked, false);
543 }
544
545 /**
546 * @tc.name: ScreenLockTest023
547 * @tc.desc: Test SendScreenLockEvent.
548 * @tc.type: FUNC
549 * @tc.require:
550 * @tc.author:
551 */
552 HWTEST_F(ScreenLockServiceTest, ScreenLockTest023, TestSize.Level0)
553 {
554 SCLOCK_HILOGD("Test SendScreenLockEvent");
555 ScreenLockSystemAbility::GetInstance()->SendScreenLockEvent(LOCK_SCREEN_RESULT, SCREEN_CANCEL);
556 bool isLocked = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
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 = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
573 EXPECT_EQ(isLocked, true);
574 }
575
576 /**
577 * @tc.name: ScreenLockTest025
578 * @tc.desc: Test Onstop and OnStart.
579 * @tc.type: FUNC
580 * @tc.require:
581 * @tc.author:
582 */
583 HWTEST_F(ScreenLockServiceTest, ScreenLockTest025, TestSize.Level0)
584 {
585 SCLOCK_HILOGD("Test Onstop");
586 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
587 ScreenLockSystemAbility::GetInstance()->OnStart();
588 ScreenLockSystemAbility::GetInstance()->OnStop();
589 ScreenLockSystemAbility::GetInstance()->OnStart();
590 EXPECT_EQ(ScreenLockSystemAbility::GetInstance()->state_, ServiceRunningState::STATE_NOT_START);
591 int times = 0;
592 ScreenLockSystemAbility::GetInstance()->RegisterDisplayPowerEventListener(times);
593 bool ret = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
594 SCLOCK_HILOGD("Test_SendScreenLockEvent of screendrawdone ret=%{public}d", ret);
595 EXPECT_EQ(ret, false);
596 }
597
598 /**
599 * @tc.name: ScreenLockTest026
600 * @tc.desc: Test GetSecure.
601 * @tc.type: FUNC
602 * @tc.require:
603 * @tc.author:
604 */
605 HWTEST_F(ScreenLockServiceTest, ScreenLockTest026, TestSize.Level0)
606 {
607 SCLOCK_HILOGD("Test GetSecure.");
608 ScreenLockSystemAbility::GetInstance()->state_ = ServiceRunningState::STATE_NOT_START;
609 bool ret = ScreenLockSystemAbility::GetInstance()->GetSecure();
610 EXPECT_EQ(ret, false);
611 }
612
613 /**
614 * @tc.name: ScreenLockTest027
615 * @tc.desc: Test UnlockScreenEvent.
616 * @tc.type: FUNC
617 * @tc.require:
618 * @tc.author:
619 */
620 HWTEST_F(ScreenLockServiceTest, ScreenLockTest027, TestSize.Level0)
621 {
622 SCLOCK_HILOGD("Test UnlockScreenEvent.");
623 ScreenLockSystemAbility::GetInstance()->unlockVecListeners_.clear();
624 ScreenLockSystemAbility::GetInstance()->UnlockScreenEvent(SCREEN_CANCEL);
625 bool ret = ScreenLockSystemAbility::GetInstance()->IsScreenLocked();
626 EXPECT_EQ(ret, true);
627 }
628 } // namespace ScreenLock
629 } // namespace OHOS