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 "user_auth_interface_service_test.h"
17 
18 #include <memory>
19 
20 #include "iam_ptr.h"
21 #include "securec.h"
22 
23 #include "executor_message.h"
24 #include "user_auth_hdi.h"
25 #include "user_sign_centre.h"
26 #include "signature_operation.h"
27 
28 namespace OHOS {
29 namespace HDI {
30 namespace UserAuth {
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace OHOS::HDI::UserAuth::V3_0;
34 namespace {
35 constexpr int32_t ATL1 = 10000;
36 uint64_t g_pinIndex = 0;
37 uint64_t g_faceIndex = 0;
38 uint64_t g_fingerprintIndex = 0;
39 } // namespace
40 
SetUpTestCase()41 void UserAuthInterfaceServiceTest::SetUpTestCase()
42 {
43 }
44 
TearDownTestCase()45 void UserAuthInterfaceServiceTest::TearDownTestCase()
46 {
47 }
48 
SetUp()49 void UserAuthInterfaceServiceTest::SetUp()
50 {
51 }
52 
TearDown()53 void UserAuthInterfaceServiceTest::TearDown()
54 {
55 }
56 
57 struct EnrollResultTest {
58     int32_t result;
59     uint64_t credentialId;
60 };
61 
62 struct AuthResultTest {
63     int32_t result;
64     std::vector<uint8_t> token;
65 };
66 
DoOnceExecutorRegister(const std::shared_ptr<UserAuthInterfaceService> & service,AuthType authType,uint64_t & index)67 int32_t DoOnceExecutorRegister(const std::shared_ptr<UserAuthInterfaceService> &service, AuthType authType,
68     uint64_t &index)
69 {
70     ExecutorRegisterInfo info = {};
71     info.authType = authType;
72     info.executorRole = ExecutorRole::ALL_IN_ONE;
73     info.esl = ExecutorSecureLevel::ESL0;
74     EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
75     std::vector<uint8_t> publicKey;
76     std::vector<uint64_t> templateIds;
77 
78     return service->AddExecutor(info, index, publicKey, templateIds);
79 }
80 
RegisterAllExecutor(const std::shared_ptr<UserAuthInterfaceService> & service)81 void RegisterAllExecutor(const std::shared_ptr<UserAuthInterfaceService> &service)
82 {
83     EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::PIN, g_pinIndex), 0);
84     EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::FACE, g_faceIndex), 0);
85     EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::FINGERPRINT, g_fingerprintIndex), 0);
86 }
87 
DeleteAllExecutor(const std::shared_ptr<UserAuthInterfaceService> & service)88 void DeleteAllExecutor(const std::shared_ptr<UserAuthInterfaceService> &service)
89 {
90     EXPECT_EQ(service->DeleteExecutor(g_pinIndex), 0);
91     EXPECT_EQ(service->DeleteExecutor(g_faceIndex), 0);
92     EXPECT_EQ(service->DeleteExecutor(g_fingerprintIndex), 0);
93 }
94 
DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,const std::vector<uint8_t> & authToken,EnrollResultTest & enrollResultTest)95 void DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
96     const std::vector<uint8_t> &authToken, EnrollResultTest &enrollResultTest)
97 {
98     EnrollParam enrollParam = {};
99     enrollParam.authType = authType;
100     enrollParam.userId = userId;
101     ScheduleInfo scheduleInfo = {};
102     EXPECT_EQ(service->BeginEnrollment(authToken, enrollParam, scheduleInfo), 0);
103 
104     EnrollResultInfo enrolledResultInfo = {};
105     std::vector<uint8_t> enrollScheduleResult;
106     TlvRequiredPara para = {};
107     para.result = 0;
108     para.scheduleId = scheduleInfo.scheduleId;
109     para.subType = 10000;
110     para.templateId = 20;
111     para.remainAttempts = 5;
112     EXPECT_EQ(GetExecutorResultTlv(para, enrollScheduleResult), 0);
113 
114     enrollResultTest.result = service->UpdateEnrollmentResult(userId, enrollScheduleResult, enrolledResultInfo);
115     enrollResultTest.credentialId = enrolledResultInfo.credentialId;
116     EXPECT_EQ(enrollResultTest.result, 0);
117 }
118 
DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,std::vector<uint8_t> & challenge,AuthResultTest & authResultTest)119 void DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
120     std::vector<uint8_t> &challenge, AuthResultTest &authResultTest)
121 {
122     constexpr uint64_t contextId = 636548;
123     AuthParam authParam = {};
124     authParam.baseParam.userId = userId;
125     authParam.baseParam.authTrustLevel = ATL1;
126     authParam.authType = authType;
127     authParam.baseParam.challenge = challenge;
128     std::vector<ScheduleInfo> scheduleInfos;
129     EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
130     EXPECT_TRUE(!scheduleInfos.empty());
131 
132     std::vector<uint8_t> authScheduleResult;
133     TlvRequiredPara para = {};
134     para.result = 0;
135     para.scheduleId = scheduleInfos[0].scheduleId;
136     para.subType = 10000;
137     para.templateId = 20;
138     para.remainAttempts = 5;
139     EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
140     AuthResultInfo authResultInfo = {};
141     HdiEnrolledState enrolledState = {};
142 
143     authResultTest.result = service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo,
144         enrolledState);
145     EXPECT_EQ(authResultTest.result, 0);
146     EXPECT_EQ(authResultInfo.userId, authParam.baseParam.userId);
147     authResultTest.token = authResultInfo.token;
148 }
149 
150 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_001, TestSize.Level0)
151 {
152     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
153     EXPECT_NE(service, nullptr);
154     constexpr int32_t userId = 1245;
155     constexpr uint32_t challengeSize = 32;
156     std::vector<uint8_t> challenge;
157     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
158     EXPECT_EQ(challenge.size(), challengeSize);
159     EXPECT_EQ(service->CloseSession(userId), 0);
160 }
161 
162 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_002, TestSize.Level0)
163 {
164     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
165     EXPECT_NE(service, nullptr);
166 
167     constexpr int32_t userId1 = 1245;
168     std::vector<uint8_t> challenge1;
169     EXPECT_EQ(service->OpenSession(userId1, challenge1), 0);
170     EXPECT_EQ(challenge1.size(), 32);
171 
172     constexpr int32_t userId2 = 2245;
173     std::vector<uint8_t> challenge2;
174     EXPECT_EQ(service->OpenSession(userId2, challenge2), 0);
175     EXPECT_EQ(challenge2.size(), 32);
176 
177     EXPECT_EQ(service->CloseSession(userId1), 0);
178     EXPECT_EQ(service->CloseSession(userId2), 2);
179 }
180 
181 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_001, TestSize.Level0)
182 {
183     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
184     EXPECT_NE(service, nullptr);
185 
186     ExecutorRegisterInfo info = {};
187     uint64_t index = 0;
188     std::vector<uint8_t> publicKey;
189     std::vector<uint64_t> templateIds;
190     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 8);
191 }
192 
193 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_002, TestSize.Level0)
194 {
195     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
196     EXPECT_NE(service, nullptr);
197 
198     const std::string deviceUdid = std::string(64, ' ');
199     EXPECT_EQ(service->Init(deviceUdid), 0);
200 
201     constexpr uint32_t publicKeySize = 32;
202     ExecutorRegisterInfo info = {};
203     info.authType = AuthType::FACE;
204     info.publicKey.resize(publicKeySize);
205     uint64_t index = 0;
206     std::vector<uint8_t> publicKey;
207     std::vector<uint64_t> templateIds;
208 
209     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
210     EXPECT_NE(index, 0);
211     EXPECT_TRUE(!publicKey.empty());
212 
213     EXPECT_EQ(service->DeleteExecutor(index), 0);
214 }
215 
216 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_003, TestSize.Level0)
217 {
218     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
219     EXPECT_NE(service, nullptr);
220 
221     const std::string deviceUdid = std::string(64, ' ');
222     EXPECT_EQ(service->Init(deviceUdid), 0);
223 
224     constexpr uint32_t publicKeySize = 32;
225     ExecutorRegisterInfo info = {};
226     info.authType = AuthType::FACE;
227     info.publicKey.resize(publicKeySize);
228     uint64_t index = 0;
229     std::vector<uint8_t> publicKey;
230     std::vector<uint64_t> templateIds;
231 
232     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
233     EXPECT_NE(index, 0);
234     EXPECT_TRUE(!publicKey.empty());
235 
236     index = 0;
237     publicKey.clear();
238     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
239     EXPECT_NE(index, 0);
240     EXPECT_TRUE(!publicKey.empty());
241 
242     EXPECT_EQ(service->DeleteExecutor(index), 0);
243 }
244 
245 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteExecutor_001, TestSize.Level0)
246 {
247     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
248     EXPECT_NE(service, nullptr);
249 
250     const std::string deviceUdid = std::string(64, ' ');
251     EXPECT_EQ(service->Init(deviceUdid), 0);
252 
253     constexpr uint64_t index1 = 1236584;
254     constexpr uint64_t index2 = 9895255;
255     EXPECT_EQ(service->DeleteExecutor(index1), 10006);
256     EXPECT_EQ(service->DeleteExecutor(index2), 10006);
257 }
258 
259 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_001, TestSize.Level0)
260 {
261     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
262     EXPECT_NE(service, nullptr);
263 
264     const std::string deviceUdid = std::string(64, ' ');
265     EXPECT_EQ(service->Init(deviceUdid), 0);
266 
267     constexpr int32_t userId = 123456;
268     std::vector<uint8_t> authToken(10, 1);
269     EnrollParam param = {};
270     param.userId = userId;
271     ScheduleInfo scheduleInfo = {};
272     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 8);
273 }
274 
275 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_002, TestSize.Level0)
276 {
277     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
278     EXPECT_NE(service, nullptr);
279 
280     const std::string deviceUdid = std::string(64, ' ');
281     EXPECT_EQ(service->Init(deviceUdid), 0);
282 
283     constexpr int32_t userId = 123456;
284     std::vector<uint8_t> authToken;
285     EnrollParam param = {};
286     param.userId = userId;
287     ScheduleInfo scheduleInfo = {};
288     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), RESULT_NEED_INIT);
289 }
290 
291 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_003, TestSize.Level0)
292 {
293     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
294     EXPECT_NE(service, nullptr);
295 
296     const std::string deviceUdid = std::string(64, ' ');
297     EXPECT_EQ(service->Init(deviceUdid), 0);
298 
299     constexpr int32_t userId = 123456;
300 
301     std::vector<uint8_t> challenge;
302     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
303 
304     std::vector<uint8_t> authToken;
305     EnrollParam param = {};
306     param.userId = userId;
307     ScheduleInfo scheduleInfo = {};
308     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 10018);
309 
310     EXPECT_EQ(service->CloseSession(userId), 0);
311 }
312 
313 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_004, TestSize.Level0)
314 {
315     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
316     EXPECT_NE(service, nullptr);
317 
318     const std::string deviceUdid = std::string(64, ' ');
319     EXPECT_EQ(service->Init(deviceUdid), 0);
320 
321     constexpr int32_t userId = 123456;
322 
323     std::vector<uint8_t> challenge;
324     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
325 
326     std::vector<uint8_t> authToken;
327     EnrollParam param = {};
328     param.userId = userId;
329     param.authType = AuthType::PIN;
330     ScheduleInfo scheduleInfo = {};
331     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 10004);
332 
333     EXPECT_EQ(service->CloseSession(userId), 0);
334 }
335 
336 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_005, TestSize.Level0)
337 {
338     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
339     EXPECT_NE(service, nullptr);
340 
341     const std::string deviceUdid = std::string(64, ' ');
342     EXPECT_EQ(service->Init(deviceUdid), 0);
343 
344     constexpr int32_t userId = 123456;
345 
346     std::vector<uint8_t> challenge;
347     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
348 
349     ExecutorRegisterInfo info = {};
350     info.authType = AuthType::PIN;
351     info.executorRole = ExecutorRole::ALL_IN_ONE;
352     info.esl = ExecutorSecureLevel::ESL0;
353     info.publicKey.resize(32);
354     uint64_t index = 0;
355     std::vector<uint8_t> publicKey;
356     std::vector<uint64_t> templateIds;
357 
358     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
359     EXPECT_NE(index, 0);
360     EXPECT_FALSE(publicKey.empty());
361 
362     std::vector<uint8_t> authToken;
363     EnrollParam param = {};
364     param.userId = userId;
365     param.authType = AuthType::PIN;
366     ScheduleInfo scheduleInfo = {};
367     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 0);
368     EXPECT_EQ(service->CancelEnrollment(userId), 0);
369 
370     EXPECT_EQ(service->DeleteExecutor(index), 0);
371     EXPECT_EQ(service->CloseSession(userId), 0);
372 }
373 
374 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_006, TestSize.Level0)
375 {
376     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
377     EXPECT_NE(service, nullptr);
378 
379     const std::string deviceUdid = std::string(64, ' ');
380     EXPECT_EQ(service->Init(deviceUdid), 0);
381 
382     constexpr int32_t userId = 123456;
383     constexpr int32_t publicKeySize = 32;
384 
385     std::vector<uint8_t> challenge;
386     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
387 
388     ExecutorRegisterInfo info = {};
389     info.authType = AuthType::PIN;
390     info.executorRole = ExecutorRole::ALL_IN_ONE;
391     info.esl = ExecutorSecureLevel::ESL0;
392     info.publicKey.resize(publicKeySize);
393     uint64_t index = 0;
394     std::vector<uint8_t> publicKey;
395     std::vector<uint64_t> templateIds;
396 
397     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
398     EXPECT_NE(index, 0);
399     EXPECT_FALSE(publicKey.empty());
400 
401     constexpr uint32_t apiVersion = 10000;
402     std::vector<uint8_t> authToken;
403     EnrollParam param = {};
404     param.userId = userId;
405     param.authType = AuthType::PIN;
406     param.callerName = "com.ohos.settings";
407     param.apiVersion = apiVersion;
408     ScheduleInfo scheduleInfo = {};
409     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 0);
410     EXPECT_EQ(service->CancelEnrollment(userId), 0);
411 
412     EXPECT_EQ(service->DeleteExecutor(index), 0);
413     EXPECT_EQ(service->CloseSession(userId), 0);
414 }
415 
416 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_001, TestSize.Level0)
417 {
418     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
419     EXPECT_NE(service, nullptr);
420 
421     const std::string deviceUdid = std::string(64, ' ');
422     EXPECT_EQ(service->Init(deviceUdid), 0);
423 
424     constexpr int32_t userId = 6978465;
425     std::vector<uint8_t> scheduleResult;
426     EnrollResultInfo enrolledResultInfo = {};
427     EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 8);
428 }
429 
430 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_002, TestSize.Level0)
431 {
432     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
433     EXPECT_NE(service, nullptr);
434 
435     const std::string deviceUdid = std::string(64, ' ');
436     EXPECT_EQ(service->Init(deviceUdid), 0);
437 
438     constexpr int32_t userId = 6978465;
439     std::vector<uint8_t> scheduleResult(600000, 1);
440     EnrollResultInfo enrolledResultInfo = {};
441     EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10004);
442 }
443 
444 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_003, TestSize.Level0)
445 {
446     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
447     EXPECT_NE(service, nullptr);
448 
449     const std::string deviceUdid = std::string(64, ' ');
450     EXPECT_EQ(service->Init(deviceUdid), 0);
451 
452     constexpr int32_t userId = 6978465;
453     std::vector<uint8_t> scheduleResult(100, 1);
454     EnrollResultInfo enrolledResultInfo = {};
455     EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
456 }
457 
458 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_004, TestSize.Level0)
459 {
460     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
461     EXPECT_NE(service, nullptr);
462 
463     const std::string deviceUdid = std::string(64, ' ');
464     EXPECT_EQ(service->Init(deviceUdid), 0);
465 
466     constexpr int32_t userId = 6978465;
467     std::vector<uint8_t> challenge;
468     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
469 
470     std::vector<uint8_t> scheduleResult(100, 1);
471     EnrollResultInfo enrolledResultInfo = {};
472     EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
473 
474     EXPECT_EQ(service->CloseSession(userId), 0);
475 }
476 
477 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_005, TestSize.Level0)
478 {
479     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
480     EXPECT_NE(service, nullptr);
481 
482     const std::string deviceUdid = std::string(64, ' ');
483     EXPECT_EQ(service->Init(deviceUdid), 0);
484 
485     constexpr int32_t userId = 6978465;
486     std::vector<uint8_t> challenge;
487     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
488 
489     ExecutorRegisterInfo info = {};
490     info.authType = AuthType::PIN;
491     info.executorRole = ExecutorRole::ALL_IN_ONE;
492     info.esl = ExecutorSecureLevel::ESL0;
493     info.publicKey.resize(32);
494     uint64_t index = 0;
495     std::vector<uint8_t> publicKey;
496     std::vector<uint64_t> templateIds;
497 
498     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
499 
500     std::vector<uint8_t> authToken;
501     EnrollParam param = {};
502     param.userId = userId;
503     param.authType = AuthType::PIN;
504     ScheduleInfo scheduleInfo = {};
505     EXPECT_EQ(service->BeginEnrollment(authToken, param, scheduleInfo), 0);
506 
507     std::vector<uint8_t> scheduleResult(100, 1);
508     EnrollResultInfo enrolledResultInfo = {};
509     EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10012);
510 
511     EXPECT_EQ(service->DeleteExecutor(index), 0);
512     EXPECT_EQ(service->CloseSession(userId), 0);
513 }
514 
515 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_006, TestSize.Level0)
516 {
517     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
518     EXPECT_NE(service, nullptr);
519 
520     const std::string deviceUdid = std::string(64, ' ');
521     EXPECT_EQ(service->Init(deviceUdid), 0);
522 
523     constexpr int32_t userId = 6978465;
524     std::vector<uint8_t> challenge;
525     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
526 
527     RegisterAllExecutor(service);
528 
529     AuthType authType = AuthType::PIN;
530     std::vector<uint8_t> authToken;
531     EnrollResultTest enrollResultTest = {};
532     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
533     EXPECT_EQ(enrollResultTest.result, 0);
534 
535     std::vector<CredentialInfo> deletedCredInfos;
536     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
537     EXPECT_TRUE(!deletedCredInfos.empty());
538 
539     DeleteAllExecutor(service);
540     EXPECT_EQ(service->CloseSession(userId), 0);
541 }
542 
543 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_001, TestSize.Level0)
544 {
545     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
546     EXPECT_NE(service, nullptr);
547 
548     const std::string deviceUdid = std::string(64, ' ');
549     EXPECT_EQ(service->Init(deviceUdid), 0);
550 
551     constexpr int32_t userId = 6978465;
552     EXPECT_EQ(service->CancelEnrollment(userId), 0);
553 }
554 
555 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_002, TestSize.Level0)
556 {
557     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
558     EXPECT_NE(service, nullptr);
559 
560     const std::string deviceUdid = std::string(64, ' ');
561     EXPECT_EQ(service->Init(deviceUdid), 0);
562 
563     constexpr int32_t userId = 6978465;
564     std::vector<uint8_t> challenge;
565     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
566     EXPECT_EQ(service->CancelEnrollment(userId), 0);
567     EXPECT_EQ(service->CloseSession(userId), 0);
568 }
569 
570 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_001, TestSize.Level0)
571 {
572     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
573     EXPECT_NE(service, nullptr);
574 
575     const std::string deviceUdid = std::string(64, ' ');
576     EXPECT_EQ(service->Init(deviceUdid), 0);
577 
578     constexpr uint64_t contextId = 123456;
579     constexpr uint32_t challengeSize = 100;
580     constexpr uint32_t apiVersion = 11;
581     AuthParam param = {};
582     param.baseParam.challenge.resize(challengeSize);
583     param.baseParam.apiVersion = apiVersion;
584     param.baseParam.callerName = "";
585     param.baseParam.callerType = 0;
586     std::vector<ScheduleInfo> scheduleInfos;
587     EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10003);
588 }
589 
590 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_002, TestSize.Level0)
591 {
592     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
593     EXPECT_NE(service, nullptr);
594 
595     const std::string deviceUdid = std::string(64, ' ');
596     EXPECT_EQ(service->Init(deviceUdid), 0);
597 
598     constexpr uint64_t contextId = 123456;
599     constexpr uint32_t challengeSize = 100;
600     constexpr uint32_t apiVersion = 10000;
601     AuthParam param = {};
602     param.baseParam.challenge.resize(challengeSize);
603     param.baseParam.apiVersion = apiVersion;
604     param.baseParam.callerName = "com.ohos.systemui";
605     param.baseParam.callerType = 0;
606     std::vector<ScheduleInfo> scheduleInfos;
607     EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10003);
608 }
609 
610 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_001, TestSize.Level0)
611 {
612     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
613     EXPECT_NE(service, nullptr);
614 
615     const std::string deviceUdid = std::string(64, ' ');
616     EXPECT_EQ(service->Init(deviceUdid), 0);
617 
618     constexpr uint64_t contextId = 123456;
619     std::vector<uint8_t> scheduleResult;
620     AuthResultInfo authResultInfo = {};
621     EnrolledState enrolledState = {};
622     EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo,
623         enrolledState), 8);
624 }
625 
626 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_002, TestSize.Level0)
627 {
628     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
629     EXPECT_NE(service, nullptr);
630 
631     const std::string deviceUdid = std::string(64, ' ');
632     EXPECT_EQ(service->Init(deviceUdid), 0);
633 
634     constexpr uint64_t contextId = 123456;
635     std::vector<uint8_t> scheduleResult(600000, 1);
636     AuthResultInfo authResultInfo = {};
637     EnrolledState enrolledState = {};
638     EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo,
639         enrolledState), 10004);
640 }
641 
642 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_003, TestSize.Level0)
643 {
644     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
645     EXPECT_NE(service, nullptr);
646 
647     const std::string deviceUdid = std::string(64, ' ');
648     EXPECT_EQ(service->Init(deviceUdid), 0);
649 
650     constexpr uint64_t contextId = 123456;
651     std::vector<uint8_t> scheduleResult;
652     scheduleResult.resize(sizeof(ExecutorResultInfo));
653     AuthResultInfo authResultInfo = {};
654     EnrolledState enrolledState = {};
655     EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo,
656         enrolledState), RESULT_GENERAL_ERROR);
657 }
658 
659 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_004, TestSize.Level0)
660 {
661     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
662     EXPECT_NE(service, nullptr);
663 
664     const std::string deviceUdid = std::string(64, ' ');
665     EXPECT_EQ(service->Init(deviceUdid), 0);
666 
667     constexpr int32_t userId = 314265;
668     std::vector<uint8_t> challenge;
669     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
670 
671     RegisterAllExecutor(service);
672 
673     AuthType authType = AuthType::PIN;
674     std::vector<uint8_t> authToken;
675     EnrollResultTest enrollResultTest = {};
676     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
677     EXPECT_EQ(enrollResultTest.result, 0);
678 
679     AuthResultTest authResultTest = {};
680     DoOnceAuth(service, userId, authType, challenge, authResultTest);
681     EXPECT_EQ(authResultTest.result, 0);
682 
683     std::vector<CredentialInfo> deletedCredInfos;
684     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
685     EXPECT_TRUE(!deletedCredInfos.empty());
686 
687     DeleteAllExecutor(service);
688     EXPECT_EQ(service->CloseSession(userId), 0);
689 }
690 
691 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_001, TestSize.Level0)
692 {
693     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
694     EXPECT_NE(service, nullptr);
695 
696     const std::string deviceUdid = std::string(64, ' ');
697     EXPECT_EQ(service->Init(deviceUdid), 0);
698 
699     constexpr uint64_t contextId = 256487;
700     EXPECT_EQ(service->CancelAuthentication(contextId), 10006);
701 }
702 
703 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_002, TestSize.Level0)
704 {
705     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
706     EXPECT_NE(service, nullptr);
707 
708     const std::string deviceUdid = std::string(64, ' ');
709     EXPECT_EQ(service->Init(deviceUdid), 0);
710 
711     constexpr int32_t userId = 314265;
712     std::vector<uint8_t> challenge;
713     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
714 
715     RegisterAllExecutor(service);
716 
717     AuthType authType = AuthType::PIN;
718     std::vector<uint8_t> authToken;
719     EnrollResultTest enrollResultTest = {};
720     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
721     EXPECT_EQ(enrollResultTest.result, 0);
722 
723     constexpr uint64_t contextId = 653497;
724     AuthParam authParam = {};
725     authParam.baseParam.userId = userId;
726     authParam.baseParam.authTrustLevel = ATL1;
727     authParam.authType = authType;
728     authParam.baseParam.challenge = challenge;
729     std::vector<ScheduleInfo> scheduleInfos;
730     EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
731     EXPECT_TRUE(!scheduleInfos.empty());
732 
733     EXPECT_EQ(service->CancelAuthentication(contextId), 0);
734 
735     std::vector<CredentialInfo> deletedCredInfos;
736     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
737     EXPECT_TRUE(!deletedCredInfos.empty());
738 
739     DeleteAllExecutor(service);
740     EXPECT_EQ(service->CloseSession(userId), 0);
741 }
742 
743 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_001, TestSize.Level0)
744 {
745     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
746     EXPECT_NE(service, nullptr);
747 
748     const std::string deviceUdid = std::string(64, ' ');
749     EXPECT_EQ(service->Init(deviceUdid), 0);
750 
751     constexpr uint64_t contextId = 123456;
752     AuthType authType = AuthType::PIN;
753     std::vector<uint8_t> challenge;
754     uint32_t executorSensorHint = 0;
755     ScheduleInfo scheduleInfo = {};
756 
757     EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 8);
758 }
759 
760 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_002, TestSize.Level0)
761 {
762     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
763     EXPECT_NE(service, nullptr);
764 
765     const std::string deviceUdid = std::string(64, ' ');
766     EXPECT_EQ(service->Init(deviceUdid), 0);
767 
768     constexpr uint64_t contextId = 623159;
769     AuthType authType = AuthType::FACE;
770     std::vector<uint8_t> challenge;
771     uint32_t executorSensorHint = 0;
772     ScheduleInfo scheduleInfo = {};
773 
774     EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 2);
775 }
776 
777 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_003, TestSize.Level0)
778 {
779     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
780     EXPECT_NE(service, nullptr);
781 
782     const std::string deviceUdid = std::string(64, ' ');
783     EXPECT_EQ(service->Init(deviceUdid), 0);
784 
785     ExecutorRegisterInfo info = {};
786     info.authType = AuthType::FACE;
787     info.executorRole = ExecutorRole::ALL_IN_ONE;
788     info.esl = ExecutorSecureLevel::ESL0;
789     EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
790     uint64_t index = 0;
791     std::vector<uint8_t> publicKey;
792     std::vector<uint64_t> templateIds;
793     EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
794 
795     constexpr uint64_t contextId = 623159;
796     AuthType authType = AuthType::FACE;
797     std::vector<uint8_t> challenge;
798     uint32_t executorSensorHint = 0;
799     ScheduleInfo scheduleInfo = {};
800     EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
801 
802     EXPECT_EQ(service->DeleteExecutor(index), 0);
803 }
804 
805 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_001, TestSize.Level0)
806 {
807     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
808     EXPECT_NE(service, nullptr);
809 
810     const std::string deviceUdid = std::string(64, ' ');
811     EXPECT_EQ(service->Init(deviceUdid), 0);
812 
813     constexpr uint64_t contextId = 621327;
814     std::vector<uint8_t> scheduleResult;
815     IdentifyResultInfo identityResultInfo = {};
816     EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), 8);
817 
818     scheduleResult.resize(240);
819     EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo),
820         RESULT_GENERAL_ERROR);
821 }
822 
823 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_002, TestSize.Level0)
824 {
825     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
826     EXPECT_NE(service, nullptr);
827 
828     const std::string deviceUdid = std::string(64, ' ');
829     EXPECT_EQ(service->Init(deviceUdid), 0);
830 
831     constexpr int32_t userId = 314265;
832     std::vector<uint8_t> challenge;
833     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
834 
835     RegisterAllExecutor(service);
836 
837     EnrollResultTest enrollPinResultTest = {};
838     std::vector<uint8_t> authToken;
839     DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
840     EXPECT_EQ(enrollPinResultTest.result, 0);
841 
842     AuthResultTest authResultTest = {};
843     DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
844     EXPECT_EQ(authResultTest.result, 0);
845 
846     EnrollResultTest enrollFaceResultTest = {};
847     DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
848     EXPECT_EQ(enrollFaceResultTest.result, 0);
849 
850     constexpr uint64_t contextId = 623159;
851     AuthType authType = AuthType::FACE;
852     uint32_t executorSensorHint = 0;
853     ScheduleInfo scheduleInfo = {};
854     EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
855 
856     std::vector<uint8_t> identityScheduleResult;
857     TlvRequiredPara para = {};
858     para.result = 0;
859     para.scheduleId = scheduleInfo.scheduleId;
860     para.subType = 10000;
861     para.templateId = 20;
862     para.remainAttempts = 5;
863     EXPECT_EQ(GetExecutorResultTlv(para, identityScheduleResult), 0);
864     IdentifyResultInfo identityResultInfo = {};
865     EXPECT_EQ(service->UpdateIdentificationResult(contextId, identityScheduleResult, identityResultInfo), 0);
866 
867     std::vector<CredentialInfo> deletedCredInfos;
868     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
869     EXPECT_TRUE(!deletedCredInfos.empty());
870 
871     DeleteAllExecutor(service);
872     EXPECT_EQ(service->CloseSession(userId), 0);
873 }
874 
875 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_001, TestSize.Level0)
876 {
877     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
878     EXPECT_NE(service, nullptr);
879 
880     const std::string deviceUdid = std::string(64, ' ');
881     EXPECT_EQ(service->Init(deviceUdid), 0);
882 
883     constexpr uint64_t contextId = 653215;
884     EXPECT_EQ(service->CancelIdentification(contextId), 10006);
885 }
886 
887 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_002, TestSize.Level0)
888 {
889     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
890     EXPECT_NE(service, nullptr);
891 
892     const std::string deviceUdid = std::string(64, ' ');
893     EXPECT_EQ(service->Init(deviceUdid), 0);
894 
895     constexpr int32_t userId = 314265;
896     std::vector<uint8_t> challenge;
897     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
898 
899     RegisterAllExecutor(service);
900 
901     EnrollResultTest enrollPinResultTest = {};
902     std::vector<uint8_t> authToken;
903     DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
904     EXPECT_EQ(enrollPinResultTest.result, 0);
905 
906     AuthResultTest authResultTest = {};
907     DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
908     EXPECT_EQ(authResultTest.result, 0);
909 
910     EnrollResultTest enrollFaceResultTest = {};
911     DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
912     EXPECT_EQ(enrollFaceResultTest.result, 0);
913 
914     constexpr uint64_t contextId = 623159;
915     AuthType authType = AuthType::FACE;
916     uint32_t executorSensorHint = 0;
917     ScheduleInfo scheduleInfo = {};
918     EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
919 
920     EXPECT_EQ(service->CancelIdentification(contextId), 0);
921 
922     std::vector<CredentialInfo> deletedCredInfos;
923     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
924     EXPECT_TRUE(!deletedCredInfos.empty());
925 
926     DeleteAllExecutor(service);
927     EXPECT_EQ(service->CloseSession(userId), 0);
928 }
929 
930 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_001, TestSize.Level0)
931 {
932     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
933     EXPECT_NE(service, nullptr);
934 
935     const std::string deviceUdid = std::string(64, ' ');
936     EXPECT_EQ(service->Init(deviceUdid), 0);
937 
938     constexpr int32_t userId = 635648;
939     AuthType authType = AuthType::PIN;
940     std::vector<CredentialInfo> credInfos;
941 
942     EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
943     EXPECT_TRUE(credInfos.empty());
944 }
945 
946 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_002, TestSize.Level0)
947 {
948     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
949     EXPECT_NE(service, nullptr);
950 
951     const std::string deviceUdid = std::string(64, ' ');
952     EXPECT_EQ(service->Init(deviceUdid), 0);
953 
954     constexpr int32_t userId = 635648;
955     AuthType authType = AuthType::PIN;
956     std::vector<uint8_t> challenge;
957     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
958 
959     RegisterAllExecutor(service);
960 
961     std::vector<uint8_t> authToken;
962     EnrollResultTest enrollResultTest = {};
963     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
964     EXPECT_EQ(enrollResultTest.result, 0);
965 
966     std::vector<CredentialInfo> credInfos;
967     EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
968     EXPECT_TRUE(!credInfos.empty());
969 
970     std::vector<CredentialInfo> deletedCredInfos;
971     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
972     EXPECT_TRUE(!deletedCredInfos.empty());
973 
974     DeleteAllExecutor(service);
975     EXPECT_EQ(service->CloseSession(userId), 0);
976 }
977 
978 HWTEST_F(UserAuthInterfaceServiceTest, TestGetUserInfo_001, TestSize.Level0)
979 {
980     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
981     EXPECT_NE(service, nullptr);
982 
983     const std::string deviceUdid = std::string(64, ' ');
984     EXPECT_EQ(service->Init(deviceUdid), 0);
985 
986     constexpr int32_t userId = 635648;
987     AuthType authType = AuthType::PIN;
988     std::vector<uint8_t> challenge;
989     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
990 
991     RegisterAllExecutor(service);
992 
993     std::vector<uint8_t> authToken;
994     EnrollResultTest enrollResultTest = {};
995     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
996     EXPECT_EQ(enrollResultTest.result, 0);
997 
998     uint64_t secureUid = 0;
999     int32_t subType = PinSubType::PIN_SIX;
1000     std::vector<EnrolledInfo> enrolledInfos;
1001     EXPECT_EQ(service->GetUserInfo(userId, secureUid, subType, enrolledInfos), 0);
1002     EXPECT_TRUE(!enrolledInfos.empty());
1003 
1004     std::vector<CredentialInfo> deletedCredInfos;
1005     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1006     EXPECT_TRUE(!deletedCredInfos.empty());
1007 
1008     DeleteAllExecutor(service);
1009     EXPECT_EQ(service->CloseSession(userId), 0);
1010 }
1011 
1012 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_001, TestSize.Level0)
1013 {
1014     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1015     EXPECT_NE(service, nullptr);
1016 
1017     const std::string deviceUdid = std::string(64, ' ');
1018     EXPECT_EQ(service->Init(deviceUdid), 0);
1019 
1020     constexpr int32_t userId = 321657;
1021     std::vector<uint8_t> authToken;
1022     std::vector<CredentialInfo> deletedCredInfos;
1023     std::vector<uint8_t> rootSecret;
1024     EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos, rootSecret), 8);
1025 
1026     authToken.resize(sizeof(UserAuthTokenHal));
1027     EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos, rootSecret), 10017);
1028 }
1029 
1030 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_002, TestSize.Level0)
1031 {
1032     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1033     EXPECT_NE(service, nullptr);
1034 
1035     const std::string deviceUdid = std::string(64, ' ');
1036     EXPECT_EQ(service->Init(deviceUdid), 0);
1037 
1038     constexpr int32_t userId = 321657;
1039     AuthType authType = AuthType::PIN;
1040     std::vector<uint8_t> challenge;
1041     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1042 
1043     RegisterAllExecutor(service);
1044 
1045     std::vector<uint8_t> authToken;
1046     EnrollResultTest enrollResultTest = {};
1047     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1048     EXPECT_EQ(enrollResultTest.result, 0);
1049 
1050     AuthResultTest authResultTest = {};
1051     DoOnceAuth(service, userId, authType, challenge, authResultTest);
1052     EXPECT_EQ(authResultTest.result, 0);
1053 
1054     std::vector<CredentialInfo> deletedCredInfos;
1055     std::vector<uint8_t> rootSecret;
1056     EXPECT_EQ(service->DeleteUser(userId, authResultTest.token, deletedCredInfos, rootSecret), 0);
1057     EXPECT_TRUE(!deletedCredInfos.empty());
1058 
1059     DeleteAllExecutor(service);
1060     EXPECT_EQ(service->CloseSession(userId), 0);
1061 }
1062 
1063 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_001, TestSize.Level0)
1064 {
1065     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1066     EXPECT_NE(service, nullptr);
1067 
1068     const std::string deviceUdid = std::string(64, ' ');
1069     EXPECT_EQ(service->Init(deviceUdid), 0);
1070 
1071     constexpr int32_t userId = 635678;
1072     std::vector<CredentialInfo> deletedCredInfos;
1073     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 10006);
1074     EXPECT_TRUE(deletedCredInfos.empty());
1075 }
1076 
1077 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_002, TestSize.Level0)
1078 {
1079     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1080     EXPECT_NE(service, nullptr);
1081 
1082     const std::string deviceUdid = std::string(64, ' ');
1083     EXPECT_EQ(service->Init(deviceUdid), 0);
1084 
1085     constexpr int32_t userId = 635678;
1086     AuthType authType = AuthType::PIN;
1087     std::vector<uint8_t> challenge;
1088     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1089 
1090     RegisterAllExecutor(service);
1091 
1092     std::vector<uint8_t> authToken;
1093     EnrollResultTest enrollResultTest = {};
1094     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1095     EXPECT_EQ(enrollResultTest.result, 0);
1096 
1097     std::vector<CredentialInfo> deletedCredInfos;
1098     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1099     EXPECT_TRUE(!deletedCredInfos.empty());
1100 
1101     DeleteAllExecutor(service);
1102     EXPECT_EQ(service->CloseSession(userId), 0);
1103 }
1104 
1105 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAvailableStatus_001, TestSize.Level0)
1106 {
1107     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1108     EXPECT_NE(service, nullptr);
1109 
1110     const std::string deviceUdid = std::string(64, ' ');
1111     EXPECT_EQ(service->Init(deviceUdid), 0);
1112 
1113     constexpr int32_t userId = 325614;
1114     AuthType authType = AuthType::PIN;
1115     uint32_t authTrustLevel = 0;
1116     int32_t checkRet;
1117     EXPECT_EQ(service->GetAvailableStatus(userId, authType, authTrustLevel, checkRet), RESULT_SUCCESS);
1118     EXPECT_EQ(checkRet, RESULT_TYPE_NOT_SUPPORT);
1119 }
1120 
1121 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAvailableStatus_002, TestSize.Level0)
1122 {
1123     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1124     EXPECT_NE(service, nullptr);
1125 
1126     const std::string deviceUdid = std::string(64, ' ');
1127     EXPECT_EQ(service->Init(deviceUdid), 0);
1128 
1129     constexpr int32_t userId = 325614;
1130     AuthType authType = AuthType::PIN;
1131     std::vector<uint8_t> challenge;
1132     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1133 
1134     RegisterAllExecutor(service);
1135 
1136     std::vector<uint8_t> authToken;
1137     EnrollResultTest enrollResultTest = {};
1138     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1139     EXPECT_EQ(enrollResultTest.result, 0);
1140 
1141     uint32_t authTrustLevel = 0;
1142     int32_t checkRet;
1143     EXPECT_EQ(service->GetAvailableStatus(userId, authType, authTrustLevel, checkRet), 0);
1144 
1145     std::vector<CredentialInfo> deletedCredInfos;
1146     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1147     EXPECT_TRUE(!deletedCredInfos.empty());
1148 
1149     DeleteAllExecutor(service);
1150     EXPECT_EQ(service->CloseSession(userId), 0);
1151 }
1152 
1153 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdatePin, TestSize.Level0)
1154 {
1155     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1156     EXPECT_NE(service, nullptr);
1157 
1158     const std::string deviceUdid = std::string(64, ' ');
1159     EXPECT_EQ(service->Init(deviceUdid), 0);
1160 
1161     constexpr int32_t userId = 325678;
1162     AuthType authType = AuthType::PIN;
1163     std::vector<uint8_t> challenge;
1164     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1165 
1166     RegisterAllExecutor(service);
1167 
1168     std::vector<uint8_t> authToken;
1169     EnrollResultTest enrollResultTest = {};
1170     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1171     EXPECT_EQ(enrollResultTest.result, 0);
1172 
1173     AuthResultTest authResultTest = {};
1174     DoOnceAuth(service, userId, authType, challenge, authResultTest);
1175     EXPECT_EQ(authResultTest.result, 0);
1176 
1177     DoOnceEnroll(service, userId, authType, authResultTest.token, enrollResultTest);
1178     EXPECT_EQ(enrollResultTest.result, 0);
1179 
1180     std::vector<CredentialInfo> deletedCredInfos;
1181     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1182     EXPECT_TRUE(!deletedCredInfos.empty());
1183 
1184     DeleteAllExecutor(service);
1185     EXPECT_EQ(service->CloseSession(userId), 0);
1186 }
1187 
1188 HWTEST_F(UserAuthInterfaceServiceTest, TestEnrollTwice, TestSize.Level0)
1189 {
1190     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1191     EXPECT_NE(service, nullptr);
1192 
1193     const std::string deviceUdid = std::string(64, ' ');
1194     EXPECT_EQ(service->Init(deviceUdid), 0);
1195 
1196     constexpr int32_t userId = 363156;
1197     AuthType authType = AuthType::PIN;
1198     std::vector<uint8_t> challenge;
1199     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1200 
1201     RegisterAllExecutor(service);
1202 
1203     std::vector<uint8_t> authToken;
1204     EnrollResultTest enrollResultTest = {};
1205     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1206     EXPECT_EQ(enrollResultTest.result, 0);
1207 
1208     EnrollParam enrollParam = {};
1209     enrollParam.userId = userId;
1210     enrollParam.authType = authType;
1211     ScheduleInfo scheduleInfo = {};
1212     EXPECT_EQ(service->BeginEnrollment(authToken, enrollParam, scheduleInfo), 10018);
1213 
1214     std::vector<CredentialInfo> deletedCredInfos;
1215     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1216     EXPECT_TRUE(!deletedCredInfos.empty());
1217 
1218     DeleteAllExecutor(service);
1219     EXPECT_EQ(service->CloseSession(userId), 0);
1220 }
1221 
1222 HWTEST_F(UserAuthInterfaceServiceTest, TestInitTwice, TestSize.Level0)
1223 {
1224     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1225     EXPECT_NE(service, nullptr);
1226 
1227     const std::string deviceUdid = std::string(64, ' ');
1228     EXPECT_EQ(service->Init(deviceUdid), 0);
1229 
1230     constexpr int32_t userId = 368635;
1231     AuthType authType = AuthType::PIN;
1232     std::vector<uint8_t> challenge;
1233     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1234 
1235     RegisterAllExecutor(service);
1236 
1237     std::vector<uint8_t> authToken;
1238     EnrollResultTest enrollResultTest = {};
1239     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1240     EXPECT_EQ(enrollResultTest.result, 0);
1241 
1242     EXPECT_EQ(service->Init(deviceUdid), 0);
1243 
1244     std::vector<CredentialInfo> deletedCredInfos;
1245     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1246     EXPECT_TRUE(!deletedCredInfos.empty());
1247 
1248     EXPECT_EQ(service->CloseSession(userId), 0);
1249 }
1250 
1251 HWTEST_F(UserAuthInterfaceServiceTest, TestAuthLock, TestSize.Level0)
1252 {
1253     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1254     EXPECT_NE(service, nullptr);
1255 
1256     const std::string deviceUdid = std::string(64, ' ');
1257     EXPECT_EQ(service->Init(deviceUdid), 0);
1258 
1259     constexpr int32_t userId = 365861;
1260     AuthType authType = AuthType::PIN;
1261     std::vector<uint8_t> challenge;
1262     EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1263 
1264     RegisterAllExecutor(service);
1265 
1266     std::vector<uint8_t> authToken;
1267     EnrollResultTest enrollResultTest = {};
1268     DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1269     EXPECT_EQ(enrollResultTest.result, 0);
1270 
1271     constexpr uint64_t contextId = 636548;
1272     AuthParam authParam = {};
1273     authParam.baseParam.userId = userId;
1274     authParam.baseParam.authTrustLevel = ATL1;
1275     authParam.authType = authType;
1276     authParam.baseParam.challenge = challenge;
1277     std::vector<ScheduleInfo> scheduleInfos;
1278     EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
1279     EXPECT_TRUE(!scheduleInfos.empty());
1280 
1281     std::vector<uint8_t> authScheduleResult;
1282     TlvRequiredPara para = {};
1283     para.result = 2;
1284     para.scheduleId = scheduleInfos[0].scheduleId;
1285     para.subType = 10000;
1286     para.templateId = 20;
1287     para.remainAttempts = 0;
1288     EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
1289     AuthResultInfo authResultInfo = {};
1290     EnrolledState enrolledState = {};
1291 
1292     EXPECT_EQ(service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo, enrolledState),
1293         RESULT_SUCCESS);
1294 
1295     std::vector<CredentialInfo> deletedCredInfos;
1296     EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1297     EXPECT_TRUE(!deletedCredInfos.empty());
1298 
1299     DeleteAllExecutor(service);
1300     EXPECT_EQ(service->CloseSession(userId), 0);
1301 }
1302 
1303 HWTEST_F(UserAuthInterfaceServiceTest, TestCheckReuseUnlockResult_001, TestSize.Level0)
1304 {
1305     auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1306     EXPECT_NE(service, nullptr);
1307 
1308     const std::string deviceUdid = std::string(64, ' ');
1309     EXPECT_EQ(service->Init(deviceUdid), 0);
1310 
1311     ReuseUnlockParam param;
1312     ReuseUnlockInfo info;
1313     param.baseParam.userId = 1;
1314     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1315 
1316     param.authTypes.push_back(static_cast<AuthType>(PIN));
1317     param.authTypes.push_back(static_cast<AuthType>(FACE));
1318     param.authTypes.push_back(static_cast<AuthType>(FINGERPRINT));
1319     param.authTypes.push_back(static_cast<AuthType>(0));
1320     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1321     param.authTypes.pop_back();
1322     param.reuseUnlockResultDuration = 0;
1323     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1324     param.reuseUnlockResultDuration = 6 * 60 *1000;
1325     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1326     param.reuseUnlockResultDuration = 5 * 60 *1000;
1327     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1328     param.reuseUnlockResultMode = 0;
1329     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1330     param.reuseUnlockResultMode = 1;
1331     EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_GENERAL_ERROR);
1332 }
1333 } // namespace UserAuth
1334 } // namespace HDI
1335 } // namespace OHOS