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