• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022-2024 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_stub_test.h"
17 
18 #include "iam_common_defines.h"
19 #include "mock_auth_event_listener.h"
20 #include "mock_user_auth_callback.h"
21 #include "mock_user_access_ctrl_callback.h"
22 #include "mock_user_auth_service.h"
23 
24 namespace OHOS {
25 namespace UserIam {
26 namespace UserAuth {
27 using namespace testing;
28 using namespace testing::ext;
29 
SetUpTestCase()30 void UserAuthStubTest::SetUpTestCase()
31 {
32 }
33 
TearDownTestCase()34 void UserAuthStubTest::TearDownTestCase()
35 {
36 }
37 
SetUp()38 void UserAuthStubTest::SetUp()
39 {
40 }
41 
TearDown()42 void UserAuthStubTest::TearDown()
43 {
44 }
45 
46 HWTEST_F(UserAuthStubTest, UserAuthStubDefault, TestSize.Level0)
47 {
48     MessageParcel data;
49     MessageParcel reply;
50     MessageOption option(MessageOption::TF_SYNC);
51     uint32_t code = UserAuthInterfaceCode::USER_AUTH_ON_SEND_COMMAND;
52 
53     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
54 
55     MockUserAuthService service;
56     EXPECT_EQ(305, service.OnRemoteRequest(code, data, reply, option));
57 }
58 
59 HWTEST_F(UserAuthStubTest, UserAuthStubGetEnrolledStateStub001, TestSize.Level0)
60 {
61     MessageParcel data;
62     MessageParcel reply;
63     MessageOption option(MessageOption::TF_SYNC);
64     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_ENROLLED_STATE;
65 
66     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
67 
68     MockUserAuthService service;
69     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
70 }
71 
72 HWTEST_F(UserAuthStubTest, UserAuthStubGetEnrolledStateStub002, TestSize.Level0)
73 {
74     MessageParcel data;
75     MessageParcel reply;
76     MockUserAuthService service;
77     int32_t testApiVersion = 12;
78     AuthType testAuthType = FACE;
79     uint64_t expectCredentialDigest = 23962;
80     uint16_t expectCredentialCount = 1;
81     EXPECT_CALL(service, GetEnrolledState(_, _, _)).Times(1);
82     ON_CALL(service, GetEnrolledState)
83         .WillByDefault(
84             [testApiVersion, testAuthType, expectCredentialDigest, expectCredentialCount](int32_t apiVersion,
__anon6b1778890102(int32_t apiVersion, AuthType authType, EnrolledState &enrolledState) 85                 AuthType authType, EnrolledState &enrolledState) {
86                 EXPECT_EQ(apiVersion, testApiVersion);
87                 EXPECT_EQ(authType, testAuthType);
88                 enrolledState.credentialDigest = expectCredentialDigest;
89                 enrolledState.credentialCount = expectCredentialCount;
90                 return SUCCESS;
91             }
92         );
93 
94     MessageOption option(MessageOption::TF_SYNC);
95     uint32_t code = static_cast<uint32_t>(UserAuthInterfaceCode::USER_AUTH_GET_ENROLLED_STATE);
96 
97     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
98     EXPECT_TRUE(data.WriteInt32(testApiVersion));
99     EXPECT_TRUE(data.WriteUint32(testAuthType));
100 
101     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
102     int32_t result = FAIL;
103     EXPECT_TRUE(reply.ReadInt32(result));
104     EXPECT_EQ(SUCCESS, result);
105     uint64_t actualCredentialDigest;
106     EXPECT_TRUE(reply.ReadUint64(actualCredentialDigest));
107     EXPECT_EQ(expectCredentialDigest, actualCredentialDigest);
108     uint16_t actualCredentialCount;
109     EXPECT_TRUE(reply.ReadUint16(actualCredentialCount));
110     EXPECT_EQ(expectCredentialCount, actualCredentialCount);
111 }
112 
113 HWTEST_F(UserAuthStubTest, UserAuthStubGetAvailableStatusStub001, TestSize.Level0)
114 {
115     MessageParcel data;
116     MessageParcel reply;
117     MessageOption option(MessageOption::TF_SYNC);
118     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_AVAILABLE_STATUS;
119 
120     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
121 
122     MockUserAuthService service;
123     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
124 }
125 
126 HWTEST_F(UserAuthStubTest, UserAuthStubGetAvailableStatusStub002, TestSize.Level0)
127 {
128     MockUserAuthService service;
129     AuthType testAuthType = FACE;
130     AuthTrustLevel testAuthTrustLevel = ATL3;
131     int32_t testApiVersion = 8;
132     int32_t testUserId = 100;
__anon6b1778890202() 133     EXPECT_CALL(service, GetAvailableStatus(_, _, _, _)).WillRepeatedly([]() {
134         return SUCCESS;
135     });
136 
137     MessageParcel data;
138     MessageParcel reply;
139     MessageOption option(MessageOption::TF_SYNC);
140     uint32_t code = static_cast<uint32_t>(UserAuthInterfaceCode::USER_AUTH_GET_AVAILABLE_STATUS);
141 
142     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
143     EXPECT_TRUE(data.WriteBool(true));
144     EXPECT_TRUE(data.WriteInt32(testUserId));
145     EXPECT_TRUE(data.WriteInt32(testAuthType));
146     EXPECT_TRUE(data.WriteUint32(testAuthTrustLevel));
147     EXPECT_TRUE(data.WriteInt32(testApiVersion));
148 
149     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
150     int32_t result = FAIL;
151     EXPECT_TRUE(reply.ReadInt32(result));
152     EXPECT_EQ(result, SUCCESS);
153 }
154 
155 HWTEST_F(UserAuthStubTest, UserAuthStubGetPropertyStub001, TestSize.Level0)
156 {
157     MessageParcel data;
158     MessageParcel reply;
159     MessageOption option(MessageOption::TF_SYNC);
160     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_PROPERTY;
161 
162     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
163 
164     MockUserAuthService service;
165     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
166 }
167 
168 HWTEST_F(UserAuthStubTest, UserAuthStubGetPropertyStub002, TestSize.Level0)
169 {
170     int32_t testUserId = 1232666;
171     AuthType testAuthType = FACE;
172     std::vector<Attributes::AttributeKey> testAttrKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
173         Attributes::ATTR_SCHEDULE_MODE};
174     std::vector<uint32_t> tempKeys;
175     for (auto &attrKey : testAttrKeys) {
176         tempKeys.push_back(static_cast<uint32_t>(attrKey));
177     }
178     sptr<MockGetExecutorPropertyCallback> callback(new (std::nothrow) MockGetExecutorPropertyCallback());
179     EXPECT_NE(callback, nullptr);
180     MockUserAuthService service;
181     EXPECT_CALL(service, GetProperty(_, _, _, _)).Times(1);
182     ON_CALL(service, GetProperty)
183         .WillByDefault(
184             [&testUserId, &testAuthType, &testAttrKeys](int32_t userId, AuthType authType,
185                 const std::vector<Attributes::AttributeKey> &keys,
__anon6b1778890302(int32_t userId, AuthType authType, const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) 186                 sptr<GetExecutorPropertyCallbackInterface> &callback) {
187                 EXPECT_EQ(userId, testUserId);
188                 EXPECT_EQ(authType, testAuthType);
189                 EXPECT_THAT(keys, ElementsAreArray(testAttrKeys));
190                 if (callback != nullptr) {
191                     Attributes attr;
192                     callback->OnGetExecutorPropertyResult(SUCCESS, attr);
193                 }
194             }
195         );
196     EXPECT_CALL(*callback, OnGetExecutorPropertyResult(_, _)).Times(1);
197 
198     MessageParcel data;
199     MessageParcel reply;
200     MessageOption option(MessageOption::TF_SYNC);
201     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_PROPERTY;
202 
203     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
204     EXPECT_TRUE(data.WriteInt32(testUserId));
205     EXPECT_TRUE(data.WriteInt32(testAuthType));
206     EXPECT_TRUE(data.WriteUInt32Vector(tempKeys));
207     EXPECT_NE(callback->AsObject(), nullptr);
208     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
209 
210     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
211 }
212 
213 HWTEST_F(UserAuthStubTest, UserAuthStubSetPropertyStub001, TestSize.Level0)
214 {
215     MessageParcel data;
216     MessageParcel reply;
217     MessageOption option(MessageOption::TF_SYNC);
218     uint32_t code = UserAuthInterfaceCode::USER_AUTH_SET_PROPERTY;
219 
220     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
221 
222     MockUserAuthService service;
223     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
224 }
225 
226 HWTEST_F(UserAuthStubTest, UserAuthStubSetPropertyStub002, TestSize.Level0)
227 {
228     int32_t testUserId = 132282;
229     AuthType testAuthType = FACE;
230     Attributes attributes;
231 
232     uint64_t testTemplateId = 3364734;
233     EXPECT_TRUE(attributes.SetUint64Value(Attributes::ATTR_TEMPLATE_ID, testTemplateId));
234 
235     sptr<MockSetExecutorPropertyCallback> callback(new (std::nothrow) MockSetExecutorPropertyCallback());
236     EXPECT_NE(callback, nullptr);
237     MockUserAuthService service;
238     EXPECT_CALL(service, SetProperty(_, _, _, _)).Times(1);
239     ON_CALL(service, SetProperty)
240         .WillByDefault(
241             [&testUserId, &testAuthType, &testTemplateId](int32_t userId, AuthType authType,
__anon6b1778890402(int32_t userId, AuthType authType, const Attributes &attributes, sptr<SetExecutorPropertyCallbackInterface> &callback) 242                 const Attributes &attributes, sptr<SetExecutorPropertyCallbackInterface> &callback) {
243                 EXPECT_EQ(userId, testUserId);
244                 EXPECT_EQ(authType, testAuthType);
245                 uint64_t tempTemplateId = 0;
246                 EXPECT_TRUE(attributes.GetUint64Value(Attributes::ATTR_TEMPLATE_ID, tempTemplateId));
247                 EXPECT_EQ(tempTemplateId, testTemplateId);
248                 if (callback != nullptr) {
249                     callback->OnSetExecutorPropertyResult(SUCCESS);
250                 }
251             }
252         );
253     EXPECT_CALL(*callback, OnSetExecutorPropertyResult(_)).Times(1);
254 
255     MessageParcel data;
256     MessageParcel reply;
257     MessageOption option(MessageOption::TF_SYNC);
258     uint32_t code = UserAuthInterfaceCode::USER_AUTH_SET_PROPERTY;
259 
260     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
261     EXPECT_TRUE(data.WriteInt32(testUserId));
262     EXPECT_TRUE(data.WriteInt32(testAuthType));
263     EXPECT_TRUE(data.WriteUInt8Vector(attributes.Serialize()));
264     EXPECT_NE(callback->AsObject(), nullptr);
265     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
266 
267     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
268 }
269 
270 HWTEST_F(UserAuthStubTest, UserAuthStubAuthStub001, TestSize.Level0)
271 {
272     MessageParcel data;
273     MessageParcel reply;
274     MessageOption option(MessageOption::TF_SYNC);
275     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH;
276 
277     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
278 
279     MockUserAuthService service;
280     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
281 }
282 
283 HWTEST_F(UserAuthStubTest, UserAuthStubAuthStub002, TestSize.Level0)
284 {
285     int32_t testUserId = 3467;
286     int32_t testApiVersion = 9;
287     std::vector<uint8_t> testChallenge = {1, 2, 4, 5};
288     AuthType testAuthType = FACE;
289     AuthTrustLevel testAtl = ATL2;
290     uint64_t testContextId = 2346782;
291 
292     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
293     EXPECT_NE(callback, nullptr);
294     MockUserAuthService service;
295     EXPECT_CALL(service, Auth(_, _, _, _, _)).Times(1);
296     ON_CALL(service, Auth)
297         .WillByDefault(
298             [&testChallenge, &testAuthType, &testAtl, &testContextId, &testApiVersion](int32_t apiVersion,
299                 const std::vector<uint8_t> &challenge, AuthType authType, AuthTrustLevel authTrustLevel,
__anon6b1778890502(int32_t apiVersion, const std::vector<uint8_t> &challenge, AuthType authType, AuthTrustLevel authTrustLevel, sptr<UserAuthCallbackInterface> &callback) 300                 sptr<UserAuthCallbackInterface> &callback) {
301                 EXPECT_EQ(apiVersion, testApiVersion);
302                 EXPECT_THAT(challenge, ElementsAreArray(testChallenge));
303                 EXPECT_EQ(authType, testAuthType);
304                 EXPECT_EQ(authTrustLevel, testAtl);
305                 if (callback != nullptr) {
306                     Attributes attr;
307                     callback->OnResult(SUCCESS, attr);
308                 }
309                 return testContextId;
310             }
311         );
312     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
313 
314     MessageParcel data;
315     MessageParcel reply;
316     MessageOption option(MessageOption::TF_SYNC);
317     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH;
318     std::vector<int32_t> testAuthTypeInts;
319     testAuthTypeInts.push_back(static_cast<AuthType>(1));
320     uint32_t authIntent = 0;
321     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
322     EXPECT_TRUE(data.WriteInt32(testApiVersion));
323     EXPECT_TRUE(data.WriteInt32(testUserId));
324     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
325     EXPECT_TRUE(data.WriteInt32(testAuthType));
326     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
327     EXPECT_TRUE(data.WriteUint32(testAtl));
328     EXPECT_TRUE(data.WriteUint32(authIntent));
329     EXPECT_NE(callback->AsObject(), nullptr);
330     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
331 
332     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
333     uint64_t contextId = 0;
334     EXPECT_TRUE(reply.ReadUint64(contextId));
335     EXPECT_EQ(contextId, testContextId);
336 }
337 
338 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub001, TestSize.Level0)
339 {
340     MessageParcel data;
341     MessageParcel reply;
342     MessageOption option(MessageOption::TF_SYNC);
343     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
344 
345     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
346 
347     MockUserAuthService service;
348     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
349 }
350 
351 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub002, TestSize.Level0)
352 {
353     int32_t testUserId = 3467;
354     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
355     AuthType testAuthType = FACE;
356     AuthTrustLevel testAtl = ATL2;
357     uint64_t testContextId = 2346728;
358 
359     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
360     EXPECT_NE(callback, nullptr);
361     MockUserAuthService service;
362     EXPECT_CALL(service, AuthUser(_, _, _)).Times(1);
363     ON_CALL(service, AuthUser)
364         .WillByDefault(
365             [&testUserId, &testChallenge, &testAuthType, &testAtl, &testContextId](AuthParamInner &authParam,
__anon6b1778890602(AuthParamInner &authParam, std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) 366             std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) {
367                 EXPECT_EQ(authParam.userId, testUserId);
368                 EXPECT_THAT(authParam.challenge, ElementsAreArray(testChallenge));
369                 EXPECT_EQ(authParam.authType, testAuthType);
370                 EXPECT_EQ(authParam.authTrustLevel, testAtl);
371                 if (callback != nullptr) {
372                     Attributes attr;
373                     callback->OnResult(SUCCESS, attr);
374                 }
375                 return testContextId;
376             }
377         );
378     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
379 
380     MessageParcel data;
381     MessageParcel reply;
382     MessageOption option(MessageOption::TF_SYNC);
383     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
384     uint32_t testAuthTrustLevel = 0;
385     std::vector<int32_t> testAuthTypeInts;
386     testAuthTypeInts.push_back(static_cast<AuthType>(1));
387     uint32_t authIntent = 0;
388     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
389     EXPECT_TRUE(data.WriteInt32(testUserId));
390     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
391     EXPECT_TRUE(data.WriteInt32(testAuthType));
392     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
393     EXPECT_TRUE(data.WriteUint32(testAtl));
394     EXPECT_TRUE(data.WriteUint32(testAuthTrustLevel));
395     EXPECT_TRUE(data.WriteUint32(authIntent));
396     EXPECT_NE(callback->AsObject(), nullptr);
397     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
398 
399     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
400     uint64_t contextId = 0;
401     EXPECT_TRUE(reply.ReadUint64(contextId));
402     EXPECT_EQ(contextId, testContextId);
403 }
404 
405 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub003, TestSize.Level0)
406 {
407     int32_t testUserId = 3467;
408     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
409     AuthType testAuthType = FACE;
410     AuthTrustLevel testAtl = ATL2;
411     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
412     EXPECT_NE(callback, nullptr);
413     MockUserAuthService service;
414     MessageParcel data;
415     MessageParcel reply;
416     MessageOption option(MessageOption::TF_SYNC);
417     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
418     std::vector<int32_t> testAuthTypeInts;
419     testAuthTypeInts.push_back(static_cast<AuthType>(1));
420     uint32_t authIntent = 0;
421     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
422     EXPECT_TRUE(data.WriteInt32(testUserId));
423     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
424     EXPECT_TRUE(data.WriteInt32(testAuthType));
425     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
426     EXPECT_TRUE(data.WriteUint32(testAtl));
427     EXPECT_TRUE(data.WriteUint32(authIntent));
428     EXPECT_NE(callback->AsObject(), nullptr);
429     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
430     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
431 }
432 
433 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub004, TestSize.Level0)
434 {
435     int32_t testUserId = 3467;
436     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
437     AuthType testAuthType = FACE;
438     AuthTrustLevel testAtl = ATL2;
439     uint64_t testContextId = 2346728;
440     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
441     EXPECT_NE(callback, nullptr);
442     MockUserAuthService service;
443     EXPECT_CALL(service, AuthUser(_, _, _)).Times(1);
444     ON_CALL(service, AuthUser)
445         .WillByDefault(
446             [&testUserId, &testChallenge, &testAuthType, &testAtl, &testContextId](AuthParamInner &authParam,
__anon6b1778890702(AuthParamInner &authParam, std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) 447             std::optional<RemoteAuthParam> &remoteAuthParam, sptr<UserAuthCallbackInterface> &callback) {
448                 EXPECT_THAT(authParam.challenge, ElementsAreArray(testChallenge));
449                 if (callback != nullptr) {
450                     Attributes attr;
451                     callback->OnResult(SUCCESS, attr);
452                 }
453                 return testContextId;
454             }
455         );
456     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
457     MessageParcel data;
458     MessageParcel reply;
459     MessageOption option(MessageOption::TF_SYNC);
460     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
461     std::vector<int32_t> testAuthTypeInts;
462     testAuthTypeInts.push_back(static_cast<AuthType>(1));
463     uint32_t authIntent = 0;
464     uint32_t collectorTokenId = 123;
465     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
466     EXPECT_TRUE(data.WriteInt32(testUserId));
467     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
468     EXPECT_TRUE(data.WriteInt32(testAuthType));
469     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
470     EXPECT_TRUE(data.WriteUint32(testAtl));
471     EXPECT_TRUE(data.WriteUint32(authIntent));
472     EXPECT_TRUE(data.WriteBool(true));
473     EXPECT_TRUE(data.WriteBool(true));
474     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
475     EXPECT_TRUE(data.WriteBool(true));
476     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
477     EXPECT_TRUE(data.WriteBool(true));
478     EXPECT_TRUE(data.WriteUint32(collectorTokenId));
479     EXPECT_NE(callback->AsObject(), nullptr);
480     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
481     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
482 }
483 
484 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub005, TestSize.Level0)
485 {
486     int32_t testUserId = 3467;
487     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
488     AuthType testAuthType = FACE;
489     AuthTrustLevel testAtl = ATL2;
490     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
491     EXPECT_NE(callback, nullptr);
492     MockUserAuthService service;
493     MessageParcel data;
494     MessageParcel reply;
495     MessageOption option(MessageOption::TF_SYNC);
496     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
497     std::vector<int32_t> testAuthTypeInts;
498     testAuthTypeInts.push_back(static_cast<AuthType>(1));
499     uint32_t authIntent = 0;
500     uint32_t collectorTokenId = 123;
501     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
502     EXPECT_TRUE(data.WriteInt32(testUserId));
503     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
504     EXPECT_TRUE(data.WriteInt32(testAuthType));
505     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
506     EXPECT_TRUE(data.WriteUint32(testAtl));
507     EXPECT_TRUE(data.WriteUint32(authIntent));
508     EXPECT_TRUE(data.WriteBool(true));
509     EXPECT_TRUE(data.WriteBool(true));
510     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
511     EXPECT_TRUE(data.WriteBool(true));
512     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
513     EXPECT_TRUE(data.WriteBool(false));
514     EXPECT_TRUE(data.WriteUint32(collectorTokenId));
515     EXPECT_NE(callback->AsObject(), nullptr);
516     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
517     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
518 }
519 
520 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub006, TestSize.Level0)
521 {
522     int32_t testUserId = 3467;
523     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
524     AuthType testAuthType = FACE;
525     AuthTrustLevel testAtl = ATL2;
526     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
527     EXPECT_NE(callback, nullptr);
528     MockUserAuthService service;
529     MessageParcel data;
530     MessageParcel reply;
531     MessageOption option(MessageOption::TF_SYNC);
532     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
533     std::vector<int32_t> testAuthTypeInts;
534     testAuthTypeInts.push_back(static_cast<AuthType>(1));
535     uint32_t authIntent = 0;
536     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
537     EXPECT_TRUE(data.WriteInt32(testUserId));
538     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
539     EXPECT_TRUE(data.WriteInt32(testAuthType));
540     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
541     EXPECT_TRUE(data.WriteUint32(testAtl));
542     EXPECT_TRUE(data.WriteUint32(authIntent));
543     EXPECT_TRUE(data.WriteBool(true));
544     EXPECT_TRUE(data.WriteBool(true));
545     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
546     EXPECT_TRUE(data.WriteBool(true));
547     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
548     EXPECT_TRUE(data.WriteBool(false));
549     EXPECT_NE(callback->AsObject(), nullptr);
550     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
551     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
552 }
553 
554 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub007, TestSize.Level0)
555 {
556     int32_t testUserId = 3467;
557     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
558     AuthType testAuthType = FACE;
559     AuthTrustLevel testAtl = ATL2;
560     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
561     EXPECT_NE(callback, nullptr);
562     MockUserAuthService service;
563     MessageParcel data;
564     MessageParcel reply;
565     MessageOption option(MessageOption::TF_SYNC);
566     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
567     std::vector<int32_t> testAuthTypeInts;
568     testAuthTypeInts.push_back(static_cast<AuthType>(1));
569     uint32_t authIntent = 0;
570     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
571     EXPECT_TRUE(data.WriteInt32(testUserId));
572     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
573     EXPECT_TRUE(data.WriteInt32(testAuthType));
574     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
575     EXPECT_TRUE(data.WriteUint32(testAtl));
576     EXPECT_TRUE(data.WriteUint32(authIntent));
577     EXPECT_TRUE(data.WriteBool(true));
578     EXPECT_TRUE(data.WriteBool(true));
579     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
580     EXPECT_TRUE(data.WriteBool(true));
581     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
582     EXPECT_NE(callback->AsObject(), nullptr);
583     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
584     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
585 }
586 
587 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub008, TestSize.Level0)
588 {
589     int32_t testUserId = 3467;
590     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
591     AuthType testAuthType = FACE;
592     AuthTrustLevel testAtl = ATL2;
593     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
594     EXPECT_NE(callback, nullptr);
595     MockUserAuthService service;
596     MessageParcel data;
597     MessageParcel reply;
598     MessageOption option(MessageOption::TF_SYNC);
599     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
600     std::vector<int32_t> testAuthTypeInts;
601     testAuthTypeInts.push_back(static_cast<AuthType>(1));
602     uint32_t authIntent = 0;
603     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
604     EXPECT_TRUE(data.WriteInt32(testUserId));
605     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
606     EXPECT_TRUE(data.WriteInt32(testAuthType));
607     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
608     EXPECT_TRUE(data.WriteUint32(testAtl));
609     EXPECT_TRUE(data.WriteUint32(authIntent));
610     EXPECT_TRUE(data.WriteBool(true));
611     EXPECT_TRUE(data.WriteBool(true));
612     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
613     EXPECT_TRUE(data.WriteBool(false));
614     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
615     EXPECT_NE(callback->AsObject(), nullptr);
616     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
617     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
618 }
619 
620 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub009, TestSize.Level0)
621 {
622     int32_t testUserId = 3467;
623     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
624     AuthType testAuthType = FACE;
625     AuthTrustLevel testAtl = ATL2;
626     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
627     EXPECT_NE(callback, nullptr);
628     MockUserAuthService service;
629     MessageParcel data;
630     MessageParcel reply;
631     MessageOption option(MessageOption::TF_SYNC);
632     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
633     std::vector<int32_t> testAuthTypeInts;
634     testAuthTypeInts.push_back(static_cast<AuthType>(1));
635     uint32_t authIntent = 0;
636     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
637     EXPECT_TRUE(data.WriteInt32(testUserId));
638     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
639     EXPECT_TRUE(data.WriteInt32(testAuthType));
640     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
641     EXPECT_TRUE(data.WriteUint32(testAtl));
642     EXPECT_TRUE(data.WriteUint32(authIntent));
643     EXPECT_TRUE(data.WriteBool(true));
644     EXPECT_TRUE(data.WriteBool(true));
645     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
646     EXPECT_TRUE(data.WriteBool(true));
647     EXPECT_NE(callback->AsObject(), nullptr);
648     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
649     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
650 }
651 
652 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub010, TestSize.Level0)
653 {
654     int32_t testUserId = 3467;
655     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
656     AuthType testAuthType = FACE;
657     AuthTrustLevel testAtl = ATL2;
658     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
659     EXPECT_NE(callback, nullptr);
660     MockUserAuthService service;
661     MessageParcel data;
662     MessageParcel reply;
663     MessageOption option(MessageOption::TF_SYNC);
664     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
665     std::vector<int32_t> testAuthTypeInts;
666     testAuthTypeInts.push_back(static_cast<AuthType>(1));
667     uint32_t authIntent = 0;
668     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
669     EXPECT_TRUE(data.WriteInt32(testUserId));
670     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
671     EXPECT_TRUE(data.WriteInt32(testAuthType));
672     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
673     EXPECT_TRUE(data.WriteUint32(testAtl));
674     EXPECT_TRUE(data.WriteUint32(authIntent));
675     EXPECT_TRUE(data.WriteBool(true));
676     EXPECT_NE(callback->AsObject(), nullptr);
677     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
678     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
679 }
680 
681 HWTEST_F(UserAuthStubTest, UserAuthStubAuthUserStub011, TestSize.Level0)
682 {
683     int32_t testUserId = 3467;
684     std::vector<uint8_t> testChallenge = {1, 2, 5, 9};
685     AuthType testAuthType = FACE;
686     AuthTrustLevel testAtl = ATL2;
687     sptr<MockAuthEventListenerService> callback(new (std::nothrow) MockAuthEventListenerService());
688     EXPECT_NE(callback, nullptr);
689     MockUserAuthService service;
690     MessageParcel data;
691     MessageParcel reply;
692     MessageOption option(MessageOption::TF_SYNC);
693     uint32_t code = UserAuthInterfaceCode::USER_AUTH_AUTH_USER;
694     std::vector<int32_t> testAuthTypeInts;
695     testAuthTypeInts.push_back(static_cast<AuthType>(1));
696     uint32_t authIntent = 0;
697     uint32_t collectorTokenId = 123;
698     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
699     EXPECT_TRUE(data.WriteInt32(testUserId));
700     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
701     EXPECT_TRUE(data.WriteInt32(testAuthType));
702     EXPECT_TRUE(data.WriteInt32Vector(testAuthTypeInts));
703     EXPECT_TRUE(data.WriteUint32(testAtl));
704     EXPECT_TRUE(data.WriteUint32(authIntent));
705     EXPECT_TRUE(data.WriteBool(true));
706     EXPECT_TRUE(data.WriteBool(true));
707     EXPECT_TRUE(data.WriteString("verifierNetworkId"));
708     EXPECT_TRUE(data.WriteBool(true));
709     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
710     EXPECT_TRUE(data.WriteBool(true));
711     EXPECT_TRUE(data.WriteUint32(collectorTokenId));
712     EXPECT_NE(callback->AsObject(), nullptr);
713     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
714     EXPECT_EQ(GENERAL_ERROR, service.OnRemoteRequest(code, data, reply, option));
715 }
716 
717 HWTEST_F(UserAuthStubTest, UserAuthStubIdentifyStub001, TestSize.Level0)
718 {
719     MessageParcel data;
720     MessageParcel reply;
721     MessageOption option(MessageOption::TF_SYNC);
722     uint32_t code = UserAuthInterfaceCode::USER_AUTH_IDENTIFY;
723 
724     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
725 
726     MockUserAuthService service;
727     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
728 }
729 
730 HWTEST_F(UserAuthStubTest, UserAuthStubIdentifyStub002, TestSize.Level0)
731 {
732     std::vector<uint8_t> testChallenge = {1, 2, 5, 8, 9};
733     AuthType testAuthType = FACE;
734     uint64_t testContextId = 76374284;
735 
736     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
737     EXPECT_NE(callback, nullptr);
738     MockUserAuthService service;
739     EXPECT_CALL(service, Identify(_, _, _)).Times(1);
740     ON_CALL(service, Identify)
741         .WillByDefault(
742             [&testChallenge, &testAuthType, &testContextId](const std::vector<uint8_t> &challenge, AuthType authType,
__anon6b1778890802(const std::vector<uint8_t> &challenge, AuthType authType, sptr<UserAuthCallbackInterface> &callback) 743                 sptr<UserAuthCallbackInterface> &callback) {
744                 EXPECT_THAT(challenge, ElementsAreArray(testChallenge));
745                 EXPECT_EQ(authType, testAuthType);
746                 if (callback != nullptr) {
747                     Attributes attr;
748                     callback->OnResult(SUCCESS, attr);
749                 }
750                 return testContextId;
751             }
752         );
753     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
754 
755     MessageParcel data;
756     MessageParcel reply;
757     MessageOption option(MessageOption::TF_SYNC);
758     uint32_t code = UserAuthInterfaceCode::USER_AUTH_IDENTIFY;
759 
760     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
761     EXPECT_TRUE(data.WriteUInt8Vector(testChallenge));
762     EXPECT_TRUE(data.WriteInt32(testAuthType));
763     EXPECT_NE(callback->AsObject(), nullptr);
764     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
765 
766     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
767     uint64_t contextId = 0;
768     EXPECT_TRUE(reply.ReadUint64(contextId));
769     EXPECT_EQ(contextId, testContextId);
770 }
771 
772 HWTEST_F(UserAuthStubTest, UserAuthStubCancelAuthOrIdentifyStub001, TestSize.Level0)
773 {
774     MessageParcel data;
775     MessageParcel reply;
776     MessageOption option(MessageOption::TF_SYNC);
777     uint32_t code = UserAuthInterfaceCode::USER_AUTH_CANCEL_AUTH;
778 
779     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
780 
781     MockUserAuthService service;
782     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
783 }
784 
785 HWTEST_F(UserAuthStubTest, UserAuthStubCancelAuthOrIdentifyStub002, TestSize.Level0)
786 {
787     uint64_t testContextId = 9346248;
788     int32_t testCancelReason = 0;
789 
790     MockUserAuthService service;
791     EXPECT_CALL(service, CancelAuthOrIdentify(_, _)).Times(1);
792     ON_CALL(service, CancelAuthOrIdentify)
793         .WillByDefault(
__anon6b1778890902(uint64_t contextId, int32_t cancelReason) 794             [&testContextId, &testCancelReason](uint64_t contextId, int32_t cancelReason) {
795                 EXPECT_EQ(contextId, testContextId);
796                 EXPECT_EQ(cancelReason, testCancelReason);
797                 return SUCCESS;
798             }
799         );
800 
801     MessageParcel data;
802     MessageParcel reply;
803     MessageOption option(MessageOption::TF_SYNC);
804     uint32_t code = UserAuthInterfaceCode::USER_AUTH_CANCEL_AUTH;
805 
806     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
807     EXPECT_TRUE(data.WriteUint64(testContextId));
808     EXPECT_TRUE(data.WriteInt32(testCancelReason));
809 
810     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
811     int32_t result = FAIL;
812     EXPECT_TRUE(reply.ReadInt32(result));
813     EXPECT_EQ(result, SUCCESS);
814 }
815 
816 HWTEST_F(UserAuthStubTest, UserAuthStubCancelAuthOrIdentifyStub003, TestSize.Level0)
817 {
818     uint64_t testContextId = 9346248;
819     int32_t testCancelReason = 0;
820 
821     MockUserAuthService service;
822     EXPECT_CALL(service, CancelAuthOrIdentify(_, _)).Times(1);
823     ON_CALL(service, CancelAuthOrIdentify)
824         .WillByDefault(
__anon6b1778890a02(uint64_t contextId, int32_t cancelReason) 825             [&testContextId, &testCancelReason](uint64_t contextId, int32_t cancelReason) {
826                 EXPECT_EQ(contextId, testContextId);
827                 EXPECT_EQ(cancelReason, testCancelReason);
828                 return SUCCESS;
829             }
830         );
831 
832     MessageParcel data;
833     MessageParcel reply;
834     MessageOption option(MessageOption::TF_SYNC);
835     uint32_t code = UserAuthInterfaceCode::USER_AUTH_CANCEL_IDENTIFY;
836 
837     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
838     EXPECT_TRUE(data.WriteUint64(testContextId));
839     EXPECT_TRUE(data.WriteInt32(testCancelReason));
840 
841     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
842     int32_t result = FAIL;
843     EXPECT_TRUE(reply.ReadInt32(result));
844     EXPECT_EQ(result, SUCCESS);
845 }
846 
847 HWTEST_F(UserAuthStubTest, UserAuthStubGetVersionStub, TestSize.Level0)
848 {
849     int32_t testVersion = 1000;
850 
851     MockUserAuthService service;
852     EXPECT_CALL(service, GetVersion(_)).Times(1);
853     ON_CALL(service, GetVersion)
854         .WillByDefault(
__anon6b1778890b02(int32_t &version) 855             [&testVersion](int32_t &version) {
856                 version = testVersion;
857                 return SUCCESS;
858             }
859         );
860 
861     MessageParcel data;
862     MessageParcel reply;
863     MessageOption option(MessageOption::TF_SYNC);
864     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_VERSION;
865 
866     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
867 
868     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
869     int32_t version = -1;
870     EXPECT_TRUE(reply.ReadInt32(version));
871     EXPECT_EQ(version, testVersion);
872     int32_t result;
873     EXPECT_TRUE(reply.ReadInt32(result));
874     EXPECT_EQ(result, SUCCESS);
875 }
876 
877 HWTEST_F(UserAuthStubTest, UserAuthStubRegistUserAuthSuccessEventListenerStub, TestSize.Level0)
878 {
879     MockUserAuthService service;
880     sptr<MockAuthEventListenerService> callback(new (std::nothrow) MockAuthEventListenerService());
881     EXPECT_NE(callback, nullptr);
882     EXPECT_CALL(service, RegistUserAuthSuccessEventListener(_, _)).Times(1);
883     ON_CALL(service, RegistUserAuthSuccessEventListener)
884         .WillByDefault(
__anon6b1778890c02(const std::vector<AuthType> &authType, const sptr<AuthEventListenerInterface> &callback) 885             [](const std::vector<AuthType> &authType, const sptr<AuthEventListenerInterface> &callback) {
886                 return SUCCESS;
887             }
888         );
889 
890     MessageParcel data;
891     MessageParcel reply;
892     MessageOption option(MessageOption::TF_SYNC);
893     uint32_t code = UserAuthInterfaceCode::USER_AUTH_REG_EVENT_LISTENER;
894 
895     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
896     std::vector<int32_t> authType;
897     authType.push_back(static_cast<int32_t>(PIN));
898     authType.push_back(static_cast<int32_t>(FACE));
899     authType.push_back(static_cast<int32_t>(FINGERPRINT));
900 
901     EXPECT_TRUE(data.WriteInt32Vector(authType));
902     EXPECT_NE(callback->AsObject(), nullptr);
903     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
904     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
905     int32_t result;
906     EXPECT_TRUE(reply.ReadInt32(result));
907     EXPECT_EQ(result, SUCCESS);
908 }
909 
910 HWTEST_F(UserAuthStubTest, UserAuthStubUnRegistUserAuthSuccessEventListenerStub, TestSize.Level0)
911 {
912     MockUserAuthService service;
913     sptr<MockAuthEventListenerService> callback(new (std::nothrow) MockAuthEventListenerService());
914     EXPECT_NE(callback, nullptr);
915     EXPECT_CALL(service, UnRegistUserAuthSuccessEventListener(_)).Times(1);
916     ON_CALL(service, UnRegistUserAuthSuccessEventListener)
917         .WillByDefault(
__anon6b1778890d02(const sptr<AuthEventListenerInterface> &callback) 918             [](const sptr<AuthEventListenerInterface> &callback) {
919                 return SUCCESS;
920             }
921         );
922 
923     MessageParcel data;
924     MessageParcel reply;
925     MessageOption option(MessageOption::TF_SYNC);
926     uint32_t code = UserAuthInterfaceCode::USER_AUTH_UNREG_EVENT_LISTENER;
927 
928     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
929     EXPECT_NE(callback->AsObject(), nullptr);
930     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
931     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
932     int32_t result;
933     EXPECT_TRUE(reply.ReadInt32(result));
934     EXPECT_EQ(result, SUCCESS);
935 }
936 
937 HWTEST_F(UserAuthStubTest, UserAuthStubSetGlobalConfigParamStub001, TestSize.Level0)
938 {
939     MockUserAuthService service;
940     EXPECT_CALL(service, SetGlobalConfigParam(_)).Times(1);
941     ON_CALL(service, SetGlobalConfigParam)
942         .WillByDefault(
__anon6b1778890e02(const GlobalConfigParam &param) 943             [](const GlobalConfigParam &param) {
944                 return SUCCESS;
945             }
946         );
947 
948     MessageParcel data;
949     MessageParcel reply;
950     MessageOption option(MessageOption::TF_SYNC);
951     uint32_t code = UserAuthInterfaceCode::USER_AUTH_SET_CLOBAL_CONFIG_PARAM;
952 
953     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
954     GlobalConfigParam param = {};
955     param.type = PIN_EXPIRED_PERIOD;
956     param.value.pinExpiredPeriod = 1;
957     EXPECT_TRUE(data.WriteInt32(param.type));
958     EXPECT_TRUE(data.WriteInt64(param.value.pinExpiredPeriod));
959     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
960     int32_t result;
961     EXPECT_TRUE(reply.ReadInt32(result));
962     EXPECT_EQ(result, SUCCESS);
963 }
964 
965 HWTEST_F(UserAuthStubTest, UserAuthStubSetGlobalConfigParamStub002, TestSize.Level0)
966 {
967     MockUserAuthService service;
968     EXPECT_CALL(service, SetGlobalConfigParam(_)).Times(1);
969     ON_CALL(service, SetGlobalConfigParam)
970         .WillByDefault(
__anon6b1778890f02(const GlobalConfigParam &param) 971             [](const GlobalConfigParam &param) {
972                 return GENERAL_ERROR;
973             }
974         );
975 
976     MessageParcel data;
977     MessageParcel reply;
978     MessageOption option(MessageOption::TF_SYNC);
979     uint32_t code = UserAuthInterfaceCode::USER_AUTH_SET_CLOBAL_CONFIG_PARAM;
980 
981     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
982     GlobalConfigParam param = {};
983     param.type = ENABLE_STATUS;
984     param.value.enableStatus = true;
985     param.userIds.push_back(1);
986     std::vector<int32_t> authTypes = {1};
987     EXPECT_TRUE(data.WriteInt32(param.type));
988     EXPECT_TRUE(data.WriteInt64(param.value.pinExpiredPeriod));
989     EXPECT_TRUE(data.WriteInt32Vector(param.userIds));
990     EXPECT_TRUE(data.WriteInt32Vector(authTypes));
991     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
992     int32_t result;
993     EXPECT_TRUE(reply.ReadInt32(result));
994     EXPECT_EQ(result, GENERAL_ERROR);
995 }
996 
997 HWTEST_F(UserAuthStubTest, UserAuthStubPrepareRemoteAuthStub_001, TestSize.Level0)
998 {
999     MockUserAuthService service;
1000     sptr<MockAuthEventListenerService> callback(new (std::nothrow) MockAuthEventListenerService());
1001     EXPECT_NE(callback, nullptr);
1002 
1003     MessageParcel data;
1004     MessageParcel reply;
1005     MessageOption option(MessageOption::TF_SYNC);
1006     uint32_t code = UserAuthInterfaceCode::USER_AUTH_PREPARE_REMOTE_AUTH;
1007     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1008     EXPECT_NE(callback->AsObject(), nullptr);
1009     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
1010     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
1011     int32_t result;
1012     EXPECT_FALSE(reply.ReadInt32(result));
1013     EXPECT_EQ(result, SUCCESS);
1014 }
1015 
1016 HWTEST_F(UserAuthStubTest, UserAuthStubPrepareRemoteAuthStub_002, TestSize.Level0)
1017 {
1018     MockUserAuthService service;
1019     sptr<MockAuthEventListenerService> callback(new (std::nothrow) MockAuthEventListenerService());
1020     EXPECT_NE(callback, nullptr);
1021 
1022     MessageParcel data;
1023     MessageParcel reply;
1024     MessageOption option(MessageOption::TF_SYNC);
1025     uint32_t code = UserAuthInterfaceCode::USER_AUTH_PREPARE_REMOTE_AUTH;
1026     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1027     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
1028     EXPECT_NE(callback->AsObject(), nullptr);
1029     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
1030     EXPECT_EQ(GENERAL_ERROR, service.OnRemoteRequest(code, data, reply, option));
1031 }
1032 
1033 HWTEST_F(UserAuthStubTest, UserAuthStubPrepareRemoteAuthStub_003, TestSize.Level0)
1034 {
1035     MockUserAuthService service;
1036     sptr<MockUserAuthCallback> callback(new (std::nothrow) MockUserAuthCallback());
1037     EXPECT_NE(callback, nullptr);
1038 
1039     MessageParcel data;
1040     MessageParcel reply;
1041     MessageOption option(MessageOption::TF_SYNC);
1042     uint32_t code = UserAuthInterfaceCode::USER_AUTH_PREPARE_REMOTE_AUTH;
1043     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1044     EXPECT_TRUE(data.WriteString("collectorNetworkId"));
1045     EXPECT_NE(callback->AsObject(), nullptr);
1046     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
1047     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
1048     int32_t result;
1049     EXPECT_TRUE(reply.ReadInt32(result));
1050     EXPECT_EQ(result, SUCCESS);
1051 }
1052 
1053 HWTEST_F(UserAuthStubTest, UserAuthStubGetPropertyByIdStub001, TestSize.Level0)
1054 {
1055     MessageParcel data;
1056     MessageParcel reply;
1057     MessageOption option(MessageOption::TF_SYNC);
1058     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_PROPERTY_BY_ID;
1059 
1060     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1061 
1062     MockUserAuthService service;
1063     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
1064 }
1065 
1066 HWTEST_F(UserAuthStubTest, UserAuthStubGetPropertyByIdStub002, TestSize.Level0)
1067 {
1068     uint64_t testCredentialId = 1;
1069     std::vector<Attributes::AttributeKey> testAttrKeys = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
1070         Attributes::ATTR_SCHEDULE_MODE};
1071     std::vector<uint32_t> tempKeys;
1072     for (auto &attrKey : testAttrKeys) {
1073         tempKeys.push_back(static_cast<uint32_t>(attrKey));
1074     }
1075     sptr<MockGetExecutorPropertyCallback> callback(new (std::nothrow) MockGetExecutorPropertyCallback());
1076     EXPECT_NE(callback, nullptr);
1077     MockUserAuthService service;
1078     EXPECT_CALL(service, GetPropertyById(_, _, _)).Times(1);
1079     ON_CALL(service, GetPropertyById)
1080         .WillByDefault(
1081             [&testCredentialId, &testAttrKeys](uint64_t credentialId, const std::vector<Attributes::AttributeKey> &keys,
__anon6b1778891002(uint64_t credentialId, const std::vector<Attributes::AttributeKey> &keys, sptr<GetExecutorPropertyCallbackInterface> &callback) 1082             sptr<GetExecutorPropertyCallbackInterface> &callback) {
1083                 EXPECT_EQ(credentialId, testCredentialId);
1084                 EXPECT_THAT(keys, ElementsAreArray(testAttrKeys));
1085                 if (callback != nullptr) {
1086                     Attributes attr;
1087                     callback->OnGetExecutorPropertyResult(SUCCESS, attr);
1088                 }
1089             }
1090         );
1091     EXPECT_CALL(*callback, OnGetExecutorPropertyResult(_, _)).Times(1);
1092 
1093     MessageParcel data;
1094     MessageParcel reply;
1095     MessageOption option(MessageOption::TF_SYNC);
1096     uint32_t code = UserAuthInterfaceCode::USER_AUTH_GET_PROPERTY_BY_ID;
1097 
1098     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1099     EXPECT_TRUE(data.WriteUint64(testCredentialId));
1100     EXPECT_TRUE(data.WriteUInt32Vector(tempKeys));
1101     EXPECT_NE(callback->AsObject(), nullptr);
1102     EXPECT_TRUE(data.WriteRemoteObject(callback->AsObject()));
1103 
1104     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
1105 }
1106 
1107 HWTEST_F(UserAuthStubTest, UserAuthStubVerifyAuthTokenStub001, TestSize.Level0)
1108 {
1109     MessageParcel data;
1110     MessageParcel reply;
1111     MessageOption option(MessageOption::TF_SYNC);
1112     uint32_t code = UserAuthInterfaceCode::USER_ACCESS_CTRL_VERIFY_AUTH_TOKEN;
1113 
1114     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1115 
1116     MockUserAuthService service;
1117     EXPECT_EQ(READ_PARCEL_ERROR, service.OnRemoteRequest(code, data, reply, option));
1118 }
1119 
1120 HWTEST_F(UserAuthStubTest, UserAuthStubVerifyAuthTokenStub002, TestSize.Level0)
1121 {
1122     std::vector<uint8_t> testTokenIn = {};
1123     uint64_t testAllowableDuration = 0;
1124 
1125     sptr<MockVerifyTokenCallback> testCallback(new (std::nothrow) MockVerifyTokenCallback());
1126     EXPECT_NE(testCallback, nullptr);
1127     MockUserAuthService service;
1128     EXPECT_CALL(service, VerifyAuthToken(_, _, _)).Times(1);
1129     ON_CALL(service, VerifyAuthToken)
1130         .WillByDefault(
1131             [&testTokenIn, &testAllowableDuration, &testCallback](const std::vector<uint8_t> &tokenIn,
__anon6b1778891102(const std::vector<uint8_t> &tokenIn, uint64_t allowableDuration, const sptr<VerifyTokenCallbackInterface> &callback) 1132                 uint64_t allowableDuration, const sptr<VerifyTokenCallbackInterface> &callback) {
1133                 EXPECT_EQ(tokenIn, testTokenIn);
1134                 EXPECT_EQ(allowableDuration, testAllowableDuration);
1135             }
1136         );
1137 
1138     MessageParcel data;
1139     MessageParcel reply;
1140     MessageOption option(MessageOption::TF_SYNC);
1141     uint32_t code = UserAuthInterfaceCode::USER_ACCESS_CTRL_VERIFY_AUTH_TOKEN;
1142 
1143     EXPECT_TRUE(data.WriteInterfaceToken(UserAuthInterface::GetDescriptor()));
1144     EXPECT_TRUE(data.WriteUInt8Vector(testTokenIn));
1145     EXPECT_TRUE(data.WriteUint64(testAllowableDuration));
1146     EXPECT_NE(testCallback->AsObject(), nullptr);
1147     EXPECT_TRUE(data.WriteRemoteObject(testCallback->AsObject()));
1148 
1149     EXPECT_EQ(SUCCESS, service.OnRemoteRequest(code, data, reply, option));
1150 }
1151 } // namespace UserAuth
1152 } // namespace UserIam
1153 } // namespace OHOS