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 #include "screenlock_service_test.h"
16
17 #include <cstdint>
18 #include <gtest/gtest.h>
19 #include <list>
20 #include <string>
21 #include <sys/time.h>
22
23 #include "sclock_log.h"
24 #include "screenlock_common.h"
25 #include "screenlock_event_list_test.h"
26 #include "screenlock_manager.h"
27 #include "screenlock_notify_test_instance.h"
28 #include "screenlock_system_ability.h"
29 #include "screenlock_system_ability_stub.h"
30 #include "screenlock_app_manager.h"
31 #include "screenlock_unlock_callback_test.h"
32
33 namespace OHOS {
34 namespace ScreenLock {
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::ScreenLock;
38
39 static EventListenerTest g_unlockTestListener;
40
SetUpTestCase()41 void ScreenLockServiceTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void ScreenLockServiceTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void ScreenLockServiceTest::SetUp()
50 {
51 }
52
TearDown()53 void ScreenLockServiceTest::TearDown()
54 {
55 }
56
57 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest002, TestSize.Level0)
58 {
59 SCLOCK_HILOGD("Test IsScreenLocked state ,get unlockstate");
60 bool status = ScreenLockManager::GetInstance()->IsScreenLocked();
61 SCLOCK_HILOGD("IsScreenLocked status is-------->%{public}d", status);
62 bool isScreenLocked = false;
63 ScreenLockManager::GetInstance()->Test_SetScreenLocked(isScreenLocked);
64 bool result = ScreenLockManager::GetInstance()->IsScreenLocked();
65 SCLOCK_HILOGD("IsScreenLocked result is-------->%{public}d", result);
66 EXPECT_EQ(result, false);
67 }
68
69 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest003, TestSize.Level0)
70 {
71 SCLOCK_HILOGD("Test IsScreenLocked state ,get lockstate");
72 bool status = ScreenLockManager::GetInstance()->IsScreenLocked();
73 SCLOCK_HILOGD("IsScreenLocked status is-------->%{public}d", status);
74 bool isScreenLocked = true;
75 ScreenLockManager::GetInstance()->Test_SetScreenLocked(isScreenLocked);
76 bool result = ScreenLockManager::GetInstance()->IsScreenLocked();
77 SCLOCK_HILOGD("IsScreenLocked result is-------->%{public}d", result);
78 EXPECT_EQ(result, true);
79 }
80
81 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest004, TestSize.Level0)
82 {
83 SCLOCK_HILOGD("Test secure");
84 bool result = ScreenLockManager::GetInstance()->GetSecure();
85 SCLOCK_HILOGD(" result is-------->%{public}d", result);
86 EXPECT_EQ(result, false);
87 }
88
89 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest006, TestSize.Level0)
90 {
91 SCLOCK_HILOGD("Test can not get foucs,expect unlock fail");
92 ScreenLockManager::GetInstance()->Test_SetScreenLocked(true);
93 sptr<ScreenLockSystemAbilityInterface> listener = new ScreenlockUnlockCallbackTest(g_unlockTestListener);
94 if (listener == nullptr) {
95 SCLOCK_HILOGE("listener object is nullptr");
96 EXPECT_EQ(false, true);
97 return ;
98 }
99 ScreenLockManager::GetInstance()->RequestUnlock(listener);
100 std::string event = UNLOCK_SCREEN_RESULT;
101 ScreenLockAppManager::GetInstance()->SendScreenLockEvent(event, UNLOCKSCREEN_FAIL);
102 bool result = ScreenLockManager::GetInstance()->IsScreenLocked();
103 SCLOCK_HILOGD("get not foucs IsScreenLocked result is-------->%{public}d", result);
104 EXPECT_EQ(result, true);
105 }
106
107 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest007, TestSize.Level0)
108 {
109 SCLOCK_HILOGD("Test screnlockapp notice unlock fail");
110 ScreenLockManager::GetInstance()->Test_SetScreenLocked(true);
111 sptr<ScreenLockSystemAbilityInterface> listener = new ScreenlockUnlockCallbackTest(g_unlockTestListener);
112 if (listener == nullptr) {
113 SCLOCK_HILOGE("listener object is nullptr");
114 EXPECT_EQ(false, true);
115 return ;
116 }
117 ScreenLockManager::GetInstance()->RequestUnlock(listener);
118 std::string event = UNLOCK_SCREEN_RESULT;
119 ScreenLockAppManager::GetInstance()->SendScreenLockEvent(event, UNLOCKSCREEN_FAIL);
120 bool result = ScreenLockManager::GetInstance()->IsScreenLocked();
121 SCLOCK_HILOGD("IsScreenLocked result is-------->%{public}d", result);
122 EXPECT_EQ(result, true);
123 }
124
125 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest008, TestSize.Level0)
126 {
127 SCLOCK_HILOGD("Test power off screen");
128 std::string message = BEGIN_SLEEP;
129 int param = BEGIN_SLEEP_DEVICE_ADMIN_REASON;
130 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
131 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
132 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
133 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_SLEEP), true);
134 message = END_SLEEP;
135 param = END_SLEEP_USER_REASON;
136 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
137 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
138 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
139 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_SLEEP), true);
140 message = BEGIN_SCREEN_OFF;
141 param = 0;
142 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
143 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
144 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
145 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_OFF), true);
146 message = END_SCREEN_OFF;
147 param = 0;
148 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
149 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
150 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
151 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_END_OFF), true);
152 }
153
154 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest009, TestSize.Level0)
155 {
156 SCLOCK_HILOGD("Test context event");
157 bool status = ScreenLockManager::GetInstance()->IsScreenLocked();
158 SCLOCK_HILOGD("IsScreenLocked status is-------->%{public}d", status);
159 if (status) {
160 std::string message = BEGIN_WAKEUP;
161 int param = 0;
162 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
163 SCLOCK_HILOGD("Test_RuntimeNotify beginWakeUp result is-------->%{public}d", result);
164 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
165 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_WAKEUP), true);
166 message = END_WAKEUP;
167 param = 0;
168 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
169 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
170 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
171 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_WAKEUP), true);
172 message = BEGIN_SCREEN_ON;
173 param = 0;
174 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
175 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
176 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
177 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_ON), true);
178 message = END_SCREEN_ON;
179 param = 0;
180 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
181 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
182 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
183 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_END_ON), true);
184 } else {
185 EXPECT_EQ(status, false);
186 }
187 }
188
189 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest010, TestSize.Level0)
190 {
191 SCLOCK_HILOGD("Test app call event");
192 bool status = ScreenLockManager::GetInstance()->IsScreenLocked();
193 SCLOCK_HILOGD("IsScreenLocked status is-------->%{public}d", status);
194 if (status) {
195 std::string message = BEGIN_WAKEUP;
196 int param = 0;
197 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
198 SCLOCK_HILOGD("Test_RuntimeNotify beginWakeUp result is-------->%{public}d", result);
199 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
200 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_BEGIN_WAKEUP), true);
201 message = END_WAKEUP;
202 param = 0;
203 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
204 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
205 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
206 EXPECT_EQ(retVal == static_cast<int>(InteractiveState::INTERACTIVE_STATE_END_WAKEUP), true);
207 message = BEGIN_SCREEN_ON;
208 param = 0;
209 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
210 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
211 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
212 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_BEGIN_ON), true);
213 message = END_SCREEN_ON;
214 param = 0;
215 result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
216 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
217 retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
218 EXPECT_EQ(retVal == static_cast<int>(ScreenState::SCREEN_STATE_END_ON), true);
219 } else {
220 EXPECT_EQ(status, false);
221 }
222 }
223
224 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest011, TestSize.Level0)
225 {
226 SCLOCK_HILOGD("Test userid 10");
227 std::string message = CHANGE_USER;
228 int param = 10;
229 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
230 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
231 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
232 EXPECT_EQ(retVal == param, true);
233 }
234
235 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest012, TestSize.Level0)
236 {
237 SCLOCK_HILOGD("Test userid is 0");
238 std::string message = CHANGE_USER;
239 int param = 0;
240 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
241 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
242 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
243 EXPECT_EQ(retVal == param, true);
244 }
245
246 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest013, TestSize.Level0)
247 {
248 SCLOCK_HILOGD("Test userid -2");
249 const int MINUSERID = 0;
250 int param = -2;
251 EXPECT_EQ(param >= MINUSERID, false);
252 }
253
254 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest014, TestSize.Level0)
255 {
256 SCLOCK_HILOGD("Test userid 999999999");
257 const int MAXUSERID = 999999999;
258 int param = 999999999;
259 EXPECT_EQ(param < MAXUSERID, false);
260 }
261
262 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest015, TestSize.Level0)
263 {
264 std::string message = SCREENLOCK_ENABLED;
265 int param = SCREENLOCK_APP_CAN_USE;
266 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
267 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
268 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
269 EXPECT_EQ(retVal == param, true);
270 }
271
272 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest016, TestSize.Level0)
273 {
274 std::string message = SCREENLOCK_ENABLED;
275 int param = SCREENLOCK_APP_CAN_NOT_USE;
276 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
277 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
278 int retVal = ScreenLockManager::GetInstance()->Test_GetRuntimeState(message);
279 EXPECT_EQ(retVal == param, true);
280 }
281
282 HWTEST_F(ScreenLockServiceTest, SetScreenLockTest017, TestSize.Level0)
283 {
284 std::string message = EXIT_ANIMATION;
285 int param = 0;
286 bool result = ScreenLockManager::GetInstance()->Test_RuntimeNotify(message, param);
287 SCLOCK_HILOGD("Test_RuntimeNotify message=%{public}s,result =%{public}d", message.c_str(), result);
288 EXPECT_EQ(result, true);
289 }
290 } // namespace ScreenLock
291 } // namespace OHOS