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
16 #include <cstdint>
17 #include <list>
18 #include <string>
19 #include <sys/time.h>
20
21 #include "accesstoken_kit.h"
22 #include "sclock_log.h"
23 #include "screenlock_callback_test.h"
24 #include "screenlock_common.h"
25 #include "screenlock_event_list_test.h"
26 #include "screenlock_notify_test_instance.h"
27 #include "screenlock_manager_stub_test.h"
28 #include "screenlock_system_ability.h"
29 #include "screenlock_system_ability_stub.h"
30 #include "securec.h"
31 #include "token_setproc.h"
32 #include "message_option.h"
33 #include "message_parcel.h"
34 #include "iremote_stub.h"
35
36 #include "ipc_skeleton.h"
37 #include "parcel.h"
38 #include "screenlock_callback_interface.h"
39 #include "screenlock_server_ipc_interface_code.h"
40
41 namespace OHOS {
42 namespace ScreenLock {
43 using namespace testing::ext;
44 const std::u16string SLMGRSTUB_INTERFACE_TOKEN = u"ohos.screenlock.ScreenLockManagerInterface";
45 const std::u16string SLMGRSTUB_INTERFACE_BAD_TOKEN = u"ohos.screenlock.ScreenLockManagerInterfaceA";
46 const int ERR_INVALID_DATA = 305;
SetUpTestCase()47 void ScreenLockManagerStubWrapTest::SetUpTestCase()
48 {}
49
TearDownTestCase()50 void ScreenLockManagerStubWrapTest::TearDownTestCase()
51 {}
52
SetUp()53 void ScreenLockManagerStubWrapTest::SetUp()
54 {}
55
TearDown()56 void ScreenLockManagerStubWrapTest::TearDown()
57 {}
58
59 /**
60 * @tc.name: ScreenLockManagerStubTest
61 * @tc.desc: OnRemoteRequest.
62 * @tc.type: FUNC
63 * @tc.require:
64 * @tc.author:
65 */
66 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrap001, TestSize.Level0)
67 {
68 SCLOCK_HILOGD("ScreenLockManagerStubWrap001");
69 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
70 ASSERT_NE(instance, nullptr);
71 MessageParcel data;
72 MessageParcel reply;
73 MessageOption option;
74 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_BAD_TOKEN);
75 int result = instance->OnRemoteRequest(
76 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_LOCKED), data, reply, option);
77 SCLOCK_HILOGI("ScreenLockManagerStubWrap001, result = %{public}d", result);
78 EXPECT_EQ(result, ERR_INVALID_DATA);
79 }
80
81 /**
82 * @tc.name: ScreenLockTest003
83 * @tc.desc: beginSleep event.
84 * @tc.type: FUNC
85 * @tc.require:
86 * @tc.author:
87 */
88 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrap002, TestSize.Level0)
89 {
90 SCLOCK_HILOGD("ScreenLockManagerStubWrap002");
91 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
92 ASSERT_NE(instance, nullptr);
93 MessageParcel data;
94 MessageParcel reply;
95 MessageOption option;
96 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
97 int result = instance->OnRemoteRequest(
98 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_LOCKED), data, reply, option);
99 SCLOCK_HILOGI("ScreenLockManagerStubWrap002, result = %{public}d %{public}d", result, ERR_NONE);
100 EXPECT_EQ(result, ERR_NONE);
101 }
102
103 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrap002_1, TestSize.Level0)
104 {
105 SCLOCK_HILOGD("ScreenLockManagerStubWrap002_1");
106 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
107 ASSERT_NE(instance, nullptr);
108 MessageParcel data;
109 MessageParcel reply;
110 MessageOption option;
111 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
112 int result = instance->OnRemoteRequest(
113 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_LOCKED), data, reply, option);
114 SCLOCK_HILOGI("ScreenLockManagerStubWrap002_1, result = %{public}d %{public}d", result, ERR_NONE);
115 EXPECT_EQ(result, ERR_NONE);
116 }
117
118 /**
119 * @tc.name: ScreenLockTest004
120 * @tc.desc: beginScreenOn event.
121 * @tc.type: FUNC
122 * @tc.require:
123 * @tc.author:
124 */
125 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrap003, TestSize.Level0)
126 {
127 SCLOCK_HILOGD("ScreenLockManagerStubWrap003");
128 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
129 ASSERT_NE(instance, nullptr);
130 MessageParcel data;
131 MessageParcel reply;
132 MessageOption option;
133 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
134 int result = instance->OnRemoteRequest(
135 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_SCREEN_LOCKED), data, reply, option);
136 SCLOCK_HILOGI("ScreenLockManagerStubWrap003, result = %{public}d %{public}d", result, ERR_NONE);
137 EXPECT_EQ(result, ERR_NONE);
138 }
139
140 /**
141 * @tc.name: ScreenLockTest005
142 * @tc.desc: beginScreenOff event.
143 * @tc.type: FUNC
144 * @tc.require:
145 * @tc.author:
146 */
147 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest004, TestSize.Level0)
148 {
149 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest004");
150 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
151 ASSERT_NE(instance, nullptr);
152 MessageParcel data;
153 MessageParcel reply;
154 MessageOption option;
155 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
156 int result = instance->OnRemoteRequest(
157 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_SECURE_MODE), data, reply, option);
158 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest004, result = %{public}d %{public}d", result, ERR_NONE);
159 EXPECT_EQ(result, ERR_NONE);
160 }
161
162 /**
163 * @tc.name: ScreenLockTest005
164 * @tc.desc: beginScreenOff event.
165 * @tc.type: FUNC
166 * @tc.require:
167 * @tc.author:
168 */
169 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest005, TestSize.Level0)
170 {
171 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest005");
172 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
173 ASSERT_NE(instance, nullptr);
174 MessageParcel data;
175 MessageParcel reply;
176 MessageOption option;
177 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
178 data.WriteRemoteObject(nullptr);
179 int result =
180 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK), data, reply, option);
181 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest005, result = %{public}d %{public}d", result, ERR_NONE);
182 EXPECT_EQ(result, ERR_NONE);
183 }
184
185 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest006, TestSize.Level0)
186 {
187 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest006");
188 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
189 ASSERT_NE(instance, nullptr);
190 MessageParcel data;
191 MessageParcel reply;
192 MessageOption option;
193 EventListenerTest eventListener;
194 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
195 sptr<ScreenlockCallbackTest> callback = new ScreenlockCallbackTest(eventListener);
196 data.WriteRemoteObject(callback->AsObject());
197 int result =
198 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK), data, reply, option);
199 SCLOCK_HILOGE("ScreenLockManagerStubWrapTest006, result = %{public}d %{public}d", result, ERR_NONE);
200 EXPECT_EQ(result, ERR_NONE);
201 }
202
203 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest007, TestSize.Level0)
204 {
205 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest007");
206 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
207 ASSERT_NE(instance, nullptr);
208 MessageParcel data;
209 MessageParcel reply;
210 MessageOption option;
211 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
212 data.WriteRemoteObject(instance->AsObject());
213 int result =
214 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK), data, reply, option);
215 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest007, result = %{public}d %{public}d", result, ERR_NONE);
216 EXPECT_EQ(result, ERR_NONE);
217 }
218
219 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest008, TestSize.Level0)
220 {
221 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest008");
222 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
223 ASSERT_NE(instance, nullptr);
224 MessageParcel data;
225 MessageParcel reply;
226 MessageOption option;
227 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
228 data.WriteRemoteObject(nullptr);
229 int result = instance->OnRemoteRequest(
230 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK_SCREEN), data, reply, option);
231 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest008, result = %{public}d %{public}d", result, ERR_NONE);
232 EXPECT_EQ(result, ERR_NONE);
233 }
234
235 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest009, TestSize.Level0)
236 {
237 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest009");
238 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
239 ASSERT_NE(instance, nullptr);
240 MessageParcel data;
241 MessageParcel reply;
242 MessageOption option;
243 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
244 EventListenerTest eventListener;
245 sptr<ScreenlockCallbackTest> callback = new ScreenlockCallbackTest(eventListener);
246 data.WriteRemoteObject(callback->AsObject());
247 int result = instance->OnRemoteRequest(
248 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK_SCREEN), data, reply, option);
249 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest009, result = %{public}d %{public}d", result, ERR_NONE);
250 EXPECT_EQ(result, ERR_NONE);
251 }
252
253 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest010, TestSize.Level0)
254 {
255 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest010");
256 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
257 ASSERT_NE(instance, nullptr);
258 MessageParcel data;
259 MessageParcel reply;
260 MessageOption option;
261 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
262 data.WriteRemoteObject(instance->AsObject());
263 int result = instance->OnRemoteRequest(
264 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNLOCK_SCREEN), data, reply, option);
265 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest010, result = %{public}d %{public}d", result, ERR_NONE);
266 EXPECT_EQ(result, ERR_NONE);
267 }
268
269 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest011, TestSize.Level0)
270 {
271 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest011");
272 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
273 ASSERT_NE(instance, nullptr);
274 MessageParcel data;
275 MessageParcel reply;
276 MessageOption option;
277 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
278 data.WriteRemoteObject(nullptr);
279 int result =
280 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::LOCK), data, reply, option);
281 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest011, result = %{public}d %{public}d", result, ERR_NONE);
282 EXPECT_EQ(result, ERR_NONE);
283 }
284
285 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest012, TestSize.Level0)
286 {
287 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest012");
288 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
289 ASSERT_NE(instance, nullptr);
290 MessageParcel data;
291 MessageParcel reply;
292 MessageOption option;
293 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
294 EventListenerTest eventListener;
295 sptr<ScreenlockCallbackTest> callback = new ScreenlockCallbackTest(eventListener);
296 data.WriteRemoteObject(callback->AsObject());
297 int result =
298 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::LOCK), data, reply, option);
299 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest012, result = %{public}d %{public}d", result, ERR_NONE);
300 EXPECT_EQ(result, ERR_NONE);
301 }
302
303 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest013, TestSize.Level0)
304 {
305 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest013");
306 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
307 ASSERT_NE(instance, nullptr);
308 MessageParcel data;
309 MessageParcel reply;
310 MessageOption option;
311 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
312 data.WriteRemoteObject(instance->AsObject());
313 int result =
314 instance->OnRemoteRequest(static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::LOCK), data, reply, option);
315 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest013, result = %{public}d %{public}d", result, ERR_NONE);
316 EXPECT_EQ(result, ERR_NONE);
317 }
318
319 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest014, TestSize.Level0)
320 {
321 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest014");
322 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
323 ASSERT_NE(instance, nullptr);
324 MessageParcel data;
325 MessageParcel reply;
326 MessageOption option;
327 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
328 data.WriteString("{invalid json}");
329 data.WriteInt32(0);
330 int result = instance->OnRemoteRequest(
331 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::SEND_SCREENLOCK_EVENT), data, reply, option);
332 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest014, result = %{public}d %{public}d", result, ERR_NONE);
333 EXPECT_EQ(result, ERR_NONE);
334 }
335
336 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest015, TestSize.Level0)
337 {
338 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest015");
339 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
340 ASSERT_NE(instance, nullptr);
341 MessageParcel data;
342 MessageParcel reply;
343 MessageOption option;
344 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
345 data.WriteRemoteObject(nullptr);
346 int result = instance->OnRemoteRequest(
347 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::ONSYSTEMEVENT), data, reply, option);
348 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest015, result = %{public}d %{public}d", result, ERR_NONE);
349 EXPECT_EQ(result, ERR_NONE);
350 }
351
352 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest0151, TestSize.Level0)
353 {
354 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest0151");
355 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
356 ASSERT_NE(instance, nullptr);
357 MessageParcel data;
358 MessageParcel reply;
359 MessageOption option;
360 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
361 data.WriteRemoteObject(instance->AsObject());
362 int result = instance->OnRemoteRequest(
363 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::ONSYSTEMEVENT), data, reply, option);
364 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest0151, result = %{public}d %{public}d", result, ERR_NONE);
365 EXPECT_EQ(result, ERR_NONE);
366 }
367
368 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest016, TestSize.Level0)
369 {
370 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest016");
371 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
372 ASSERT_NE(instance, nullptr);
373 MessageParcel data;
374 MessageParcel reply;
375 MessageOption option;
376 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
377 data.WriteInt32(0);
378 int result = instance->OnRemoteRequest(
379 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::LOCK_SCREEN), data, reply, option);
380 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest016, result = %{public}d %{public}d", result, ERR_NONE);
381 EXPECT_EQ(result, ERR_NONE);
382 }
383
384 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest017, TestSize.Level0)
385 {
386 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest017");
387 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
388 ASSERT_NE(instance, nullptr);
389 MessageParcel data;
390 MessageParcel reply;
391 MessageOption option;
392 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
393 data.WriteInt32(0);
394 int result = instance->OnRemoteRequest(
395 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_SCREENLOCK_DISABLED), data, reply, option);
396 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest017, result = %{public}d %{public}d", result, ERR_NONE);
397 EXPECT_EQ(result, ERR_NONE);
398 }
399
400 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest017_1, TestSize.Level0)
401 {
402 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest017_1");
403 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
404 ASSERT_NE(instance, nullptr);
405 MessageParcel data;
406 MessageParcel reply;
407 MessageOption option;
408 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
409 data.WriteInt32(0);
410 int result = instance->OnRemoteRequest(
411 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_SCREENLOCK_DISABLED), data, reply, option);
412 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest017_1, result = %{public}d %{public}d", result, ERR_NONE);
413 EXPECT_EQ(result, ERR_NONE);
414 }
415
416 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest018, TestSize.Level0)
417 {
418 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest018");
419 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
420 ASSERT_NE(instance, nullptr);
421 MessageParcel data;
422 MessageParcel reply;
423 MessageOption option;
424 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
425 data.WriteBool(true);
426 data.WriteInt32(0);
427 int result = instance->OnRemoteRequest(
428 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::SET_SCREENLOCK_DISABLED), data, reply, option);
429 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest018, result = %{public}d %{public}d", result, ERR_NONE);
430 EXPECT_EQ(result, ERR_NONE);
431 }
432
433 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest019, TestSize.Level0)
434 {
435 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest019");
436 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
437 ASSERT_NE(instance, nullptr);
438 MessageParcel data;
439 MessageParcel reply;
440 MessageOption option;
441 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
442 data.WriteInt32(0);
443 data.WriteInt32(0);
444 data.WriteString("{invalid json}");
445 int result = instance->OnRemoteRequest(
446 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::SET_SCREENLOCK_AUTHSTATE), data, reply, option);
447 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest019, result = %{public}d %{public}d", result, ERR_NONE);
448 EXPECT_EQ(result, ERR_NONE);
449 }
450
451 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest020, TestSize.Level0)
452 {
453 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest020");
454 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
455 ASSERT_NE(instance, nullptr);
456 MessageParcel data;
457 MessageParcel reply;
458 MessageOption option;
459 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
460 data.WriteInt32(0);
461 int result = instance->OnRemoteRequest(
462 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::GET_SCREENLOCK_AUTHSTATE), data, reply, option);
463 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest020, result = %{public}d %{public}d", result, ERR_NONE);
464 EXPECT_EQ(result, ERR_NONE);
465 }
466
467 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest021, TestSize.Level0)
468 {
469 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest021");
470 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
471 ASSERT_NE(instance, nullptr);
472 MessageParcel data;
473 MessageParcel reply;
474 MessageOption option;
475 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
476 data.WriteInt32(0);
477 data.WriteInt32(0);
478 int result = instance->OnRemoteRequest(
479 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::REQUEST_STRONG_AUTHSTATE), data, reply, option);
480 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest021, result = %{public}d %{public}d", result, ERR_NONE);
481 EXPECT_EQ(result, ERR_NONE);
482 }
483
484 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest021_1, TestSize.Level0)
485 {
486 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest021_1");
487 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
488 ASSERT_NE(instance, nullptr);
489 MessageParcel data;
490 MessageParcel reply;
491 MessageOption option;
492 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
493 data.WriteInt32(0);
494 data.WriteInt32(0);
495 int result = instance->OnRemoteRequest(
496 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::REQUEST_STRONG_AUTHSTATE), data, reply, option);
497 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest021_1, result = %{public}d %{public}d", result, ERR_NONE);
498 EXPECT_EQ(result, ERR_NONE);
499 }
500
501 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest022, TestSize.Level0)
502 {
503 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest022");
504 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
505 ASSERT_NE(instance, nullptr);
506 MessageParcel data;
507 MessageParcel reply;
508 MessageOption option;
509 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
510 data.WriteInt32(0);
511 int result = instance->OnRemoteRequest(
512 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::GET_STRONG_AUTHSTATE), data, reply, option);
513 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest022, result = %{public}d %{public}d", result, ERR_NONE);
514 EXPECT_EQ(result, ERR_NONE);
515 }
516
517 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest022_1, TestSize.Level0)
518 {
519 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest022_1");
520 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
521 ASSERT_NE(instance, nullptr);
522 MessageParcel data;
523 MessageParcel reply;
524 MessageOption option;
525 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
526 data.WriteInt32(0);
527 int result = instance->OnRemoteRequest(
528 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::GET_STRONG_AUTHSTATE), data, reply, option);
529 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest022_1, result = %{public}d %{public}d", result, ERR_NONE);
530 EXPECT_EQ(result, ERR_NONE);
531 }
532
533 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest023, TestSize.Level0)
534 {
535 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest023");
536 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
537 ASSERT_NE(instance, nullptr);
538 MessageParcel data;
539 MessageParcel reply;
540 MessageOption option;
541 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
542 data.WriteInt32(0);
543 int result = instance->OnRemoteRequest(
544 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_DEVICE_LOCKED), data, reply, option);
545 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest023, result = %{public}d %{public}d", result, ERR_NONE);
546 EXPECT_EQ(result, ERR_NONE);
547 }
548
549 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest023_1, TestSize.Level0)
550 {
551 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest023_1");
552 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
553 ASSERT_NE(instance, nullptr);
554 MessageParcel data;
555 MessageParcel reply;
556 MessageOption option;
557 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
558 data.WriteInt32(0);
559 int result = instance->OnRemoteRequest(
560 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_DEVICE_LOCKED), data, reply, option);
561 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest023_1, result = %{public}d %{public}d", result, ERR_NONE);
562 EXPECT_EQ(result, ERR_NONE);
563 }
564
565 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest024, TestSize.Level0)
566 {
567 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest024");
568 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
569 ASSERT_NE(instance, nullptr);
570 MessageParcel data;
571 MessageParcel reply;
572 MessageOption option;
573 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
574 data.WriteInt32(0);
575 data.WriteInt32(0);
576 data.WriteRemoteObject(nullptr);
577 int result = instance->OnRemoteRequest(
578 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::REGISTER_INNER_LISTENER), data, reply, option);
579 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest024, result = %{public}d %{public}d", result, ERR_NONE);
580 EXPECT_EQ(result, ERR_NONE);
581 }
582
583 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest024_1, TestSize.Level0)
584 {
585 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest024_1");
586 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
587 ASSERT_NE(instance, nullptr);
588 MessageParcel data;
589 MessageParcel reply;
590 MessageOption option;
591 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
592 data.WriteInt32(0);
593 data.WriteInt32(0);
594 data.WriteRemoteObject(instance->AsObject());
595 int result = instance->OnRemoteRequest(
596 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::REGISTER_INNER_LISTENER), data, reply, option);
597 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest024_1, result = %{public}d %{public}d", result, ERR_NONE);
598 EXPECT_EQ(result, ERR_NONE);
599 }
600
601 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest025, TestSize.Level0)
602 {
603 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest025");
604 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
605 ASSERT_NE(instance, nullptr);
606 MessageParcel data;
607 MessageParcel reply;
608 MessageOption option;
609 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
610 data.WriteInt32(0);
611 data.WriteInt32(0);
612 data.WriteRemoteObject(nullptr);
613 int result = instance->OnRemoteRequest(
614 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNREGISTER_INNER_LISTENER), data, reply, option);
615 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest025, result = %{public}d %{public}d", result, ERR_NONE);
616 EXPECT_EQ(result, ERR_NONE);
617 }
618
619 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest025_1, TestSize.Level0)
620 {
621 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest025_1");
622 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
623 ASSERT_NE(instance, nullptr);
624 MessageParcel data;
625 MessageParcel reply;
626 MessageOption option;
627 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
628 data.WriteInt32(0);
629 data.WriteInt32(0);
630 data.WriteRemoteObject(instance->AsObject());
631 int result = instance->OnRemoteRequest(
632 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::UNREGISTER_INNER_LISTENER), data, reply, option);
633 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest025_1, result = %{public}d %{public}d", result, ERR_NONE);
634 EXPECT_EQ(result, ERR_NONE);
635 }
636
637 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest026, TestSize.Level0)
638 {
639 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest026");
640 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
641 ASSERT_NE(instance, nullptr);
642 MessageParcel data;
643 MessageParcel reply;
644 MessageOption option;
645 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
646 data.WriteInt32(0);
647 int result = instance->OnRemoteRequest(
648 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_USER_SCREEN_LOCKED), data, reply, option);
649 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest026, result = %{public}d %{public}d", result, ERR_NONE);
650 EXPECT_EQ(result, ERR_NONE);
651 }
652
653 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest026_1, TestSize.Level0)
654 {
655 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest026_1");
656 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest(true);
657 ASSERT_NE(instance, nullptr);
658 MessageParcel data;
659 MessageParcel reply;
660 MessageOption option;
661 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
662 data.WriteInt32(0);
663 int result = instance->OnRemoteRequest(
664 static_cast<uint32_t>(ScreenLockServerIpcInterfaceCode::IS_USER_SCREEN_LOCKED), data, reply, option);
665 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest026_1, result = %{public}d %{public}d", result, ERR_NONE);
666 EXPECT_EQ(result, ERR_NONE);
667 }
668
669 HWTEST_F(ScreenLockManagerStubWrapTest, ScreenLockManagerStubWrapTest027, TestSize.Level0)
670 {
671 SCLOCK_HILOGD("ScreenLockManagerStubWrapTest027");
672 sptr<ScreenLockManagerStubTest> instance = new ScreenLockManagerStubTest();
673 ASSERT_NE(instance, nullptr);
674 MessageParcel data;
675 MessageParcel reply;
676 MessageOption option;
677 data.WriteInterfaceToken(SLMGRSTUB_INTERFACE_TOKEN);
678 data.WriteInt32(0);
679 int result = instance->OnRemoteRequest(100, data, reply, option);
680 SCLOCK_HILOGI("ScreenLockManagerStubWrapTest027, result = %{public}d %{public}d", result, ERR_INVALID_DATA);
681 EXPECT_EQ(result, ERR_INVALID_DATA);
682 }
683
684 } // namespace ScreenLock
685 } // namespace OHOS