1 /*
2  * Copyright (C) 2022-2023 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_idm_client_test.h"
17 
18 #include "iam_ptr.h"
19 #include "user_idm_client.h"
20 
21 namespace OHOS {
22 namespace UserIam {
23 namespace UserAuth {
24 using namespace testing;
25 using namespace testing::ext;
26 
SetUpTestCase()27 void UserIdmClientTest::SetUpTestCase()
28 {
29 }
30 
TearDownTestCase()31 void UserIdmClientTest::TearDownTestCase()
32 {
33 }
34 
SetUp()35 void UserIdmClientTest::SetUp()
36 {
37 }
38 
TearDown()39 void UserIdmClientTest::TearDown()
40 {
41 }
42 
43 HWTEST_F(UserIdmClientTest, UserIdmClientOpenSession001, TestSize.Level0)
44 {
45     int32_t testUserId = 21200;
46 
47     IpcClientUtils::ResetObj();
48     std::vector<uint8_t> challenge = UserIdmClient::GetInstance().OpenSession(testUserId);
49     EXPECT_TRUE(challenge.empty());
50 }
51 
52 HWTEST_F(UserIdmClientTest, UserIdmClientOpenSession002, TestSize.Level0)
53 {
54     int32_t testUserId = 21200;
55     std::vector<uint8_t> testChallenge = {1, 3, 4, 7};
56 
57     auto service = Common::MakeShared<MockUserIdmService>();
58     EXPECT_NE(service, nullptr);
59     EXPECT_CALL(*service, OpenSession(_, _)).Times(1);
60     ON_CALL(*service, OpenSession)
61         .WillByDefault(
__anond6b7591b0102(int32_t userId, std::vector<uint8_t> &challenge) 62             [&testUserId, &testChallenge](int32_t userId, std::vector<uint8_t> &challenge) {
63                 EXPECT_EQ(userId, testUserId);
64                 challenge = testChallenge;
65                 return SUCCESS;
66             }
67         );
68     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
69     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
70     CallRemoteObject(service, obj, dr);
71 
72     std::vector<uint8_t> challenge = UserIdmClient::GetInstance().OpenSession(testUserId);
73     EXPECT_THAT(challenge, ElementsAreArray(testChallenge));
74     EXPECT_NE(dr, nullptr);
75     dr->OnRemoteDied(obj);
76     IpcClientUtils::ResetObj();
77 }
78 
79 HWTEST_F(UserIdmClientTest, UserIdmClientCloseSession001, TestSize.Level0)
80 {
81     int32_t testUserId = 200;
82 
83     IpcClientUtils::ResetObj();
84     UserIdmClient::GetInstance().CloseSession(testUserId);
85 }
86 
87 HWTEST_F(UserIdmClientTest, UserIdmClientCloseSession002, TestSize.Level0)
88 {
89     int32_t testUserId = 200;
90 
91     auto service = Common::MakeShared<MockUserIdmService>();
92     EXPECT_NE(service, nullptr);
93     EXPECT_CALL(*service, CloseSession(_)).Times(1);
94     ON_CALL(*service, CloseSession)
95         .WillByDefault(
__anond6b7591b0202(int32_t userId) 96             [&testUserId](int32_t userId) {
97                 EXPECT_EQ(userId, testUserId);
98                 return;
99             }
100         );
101     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
102     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
103     CallRemoteObject(service, obj, dr);
104 
105     UserIdmClient::GetInstance().CloseSession(testUserId);
106     EXPECT_NE(dr, nullptr);
107     dr->OnRemoteDied(obj);
108     IpcClientUtils::ResetObj();
109 }
110 
111 HWTEST_F(UserIdmClientTest, UserIdmClientCloseSession003, TestSize.Level0)
112 {
113     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
114     EXPECT_NE(obj, nullptr);
115     EXPECT_CALL(*obj, IsProxyObject()).WillRepeatedly(Return(true));
116 
117     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
118     EXPECT_CALL(*obj, RemoveDeathRecipient(_)).WillRepeatedly(Return(true));
119     EXPECT_CALL(*obj, AddDeathRecipient(_))
120         .WillOnce(Return(false))
__anond6b7591b0302(const sptr<IRemoteObject::DeathRecipient> &recipient) 121         .WillRepeatedly([&dr](const sptr<IRemoteObject::DeathRecipient> &recipient) {
122             dr = recipient;
123             return true;
124         });
125 
126     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).WillRepeatedly(Return(OHOS::NO_ERROR));
127 
128     IpcClientUtils::SetObj(obj);
129 
130     int32_t testUserId = 1326;
131     UserIdmClient::GetInstance().CloseSession(testUserId);
132     UserIdmClient::GetInstance().CloseSession(testUserId);
133     UserIdmClient::GetInstance().CloseSession(testUserId);
134 
135     EXPECT_NE(dr, nullptr);
136     sptr<IRemoteObject> remote(nullptr);
137     dr->OnRemoteDied(remote);
138     dr->OnRemoteDied(obj);
139     IpcClientUtils::ResetObj();
140 }
141 
142 HWTEST_F(UserIdmClientTest, UserIdmClientAddCredential001, TestSize.Level0)
143 {
144     int32_t testUserId = 200;
145     CredentialParameters testPara = {};
146     std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
147     UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
148 
149     testCallback = Common::MakeShared<MockUserIdmClientCallback>();
150     EXPECT_NE(testCallback, nullptr);
151     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
152     IpcClientUtils::ResetObj();
153     UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
154 }
155 
156 HWTEST_F(UserIdmClientTest, UserIdmClientAddCredential002, TestSize.Level0)
157 {
158     int32_t testUserId = 200;
159     CredentialParameters testPara = {};
160     testPara.authType = FACE;
161     testPara.pinType = std::nullopt;
162     testPara.token = {1, 4, 7, 0};
163     auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
164     EXPECT_NE(testCallback, nullptr);
165     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
166 
167     auto service = Common::MakeShared<MockUserIdmService>();
168     EXPECT_NE(service, nullptr);
169     EXPECT_CALL(*service, AddCredential(_, _, _, _)).Times(1);
170     ON_CALL(*service, AddCredential)
171         .WillByDefault(
172             [&testUserId, &testPara](int32_t userId, const UserIdmInterface::CredentialPara &credPara,
__anond6b7591b0402(int32_t userId, const UserIdmInterface::CredentialPara &credPara, const sptr<IdmCallbackInterface> &callback, bool isUpdate) 173                 const sptr<IdmCallbackInterface> &callback, bool isUpdate) {
174                 EXPECT_EQ(userId, testUserId);
175                 EXPECT_EQ(credPara.authType, testPara.authType);
176                 EXPECT_THAT(credPara.token, ElementsAreArray(testPara.token));
177                 EXPECT_EQ(isUpdate, false);
178                 if (callback != nullptr) {
179                     Attributes extraInfo;
180                     callback->OnResult(SUCCESS, extraInfo);
181                 }
182             }
183         );
184     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
185     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
186     CallRemoteObject(service, obj, dr);
187 
188     UserIdmClient::GetInstance().AddCredential(testUserId, testPara, testCallback);
189     EXPECT_NE(dr, nullptr);
190     dr->OnRemoteDied(obj);
191     IpcClientUtils::ResetObj();
192 }
193 
194 HWTEST_F(UserIdmClientTest, UserIdmClientUpdateCredential001, TestSize.Level0)
195 {
196     int32_t testUserId = 200;
197     CredentialParameters testPara = {};
198     std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
199     UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
200 
201     testCallback = Common::MakeShared<MockUserIdmClientCallback>();
202     EXPECT_NE(testCallback, nullptr);
203     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
204     IpcClientUtils::ResetObj();
205     UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
206 }
207 
208 HWTEST_F(UserIdmClientTest, UserIdmClientUpdateCredential002, TestSize.Level0)
209 {
210     int32_t testUserId = 200;
211     CredentialParameters testPara = {};
212     testPara.authType = PIN;
213     testPara.pinType = PIN_SIX;
214     testPara.token = {1, 4, 7, 0};
215     auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
216     EXPECT_NE(testCallback, nullptr);
217     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
218 
219     auto service = Common::MakeShared<MockUserIdmService>();
220     EXPECT_NE(service, nullptr);
221     EXPECT_CALL(*service, UpdateCredential(_, _, _)).Times(1);
222     ON_CALL(*service, UpdateCredential)
223         .WillByDefault(
224             [&testUserId, &testPara](int32_t userId, const UserIdmInterface::CredentialPara &credPara,
__anond6b7591b0502(int32_t userId, const UserIdmInterface::CredentialPara &credPara, const sptr<IdmCallbackInterface> &callback) 225                 const sptr<IdmCallbackInterface> &callback) {
226                 EXPECT_EQ(userId, testUserId);
227                 EXPECT_EQ(credPara.authType, testPara.authType);
228                 EXPECT_TRUE(testPara.pinType.has_value());
229                 EXPECT_EQ(credPara.pinType, testPara.pinType.value());
230                 EXPECT_THAT(credPara.token, ElementsAreArray(testPara.token));
231                 if (callback != nullptr) {
232                     Attributes extraInfo;
233                     callback->OnResult(SUCCESS, extraInfo);
234                 }
235             }
236         );
237     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
238     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
239     CallRemoteObject(service, obj, dr);
240 
241     UserIdmClient::GetInstance().UpdateCredential(testUserId, testPara, testCallback);
242     EXPECT_NE(dr, nullptr);
243     dr->OnRemoteDied(obj);
244     IpcClientUtils::ResetObj();
245 }
246 
247 HWTEST_F(UserIdmClientTest, UserIdmClientCancel001, TestSize.Level0)
248 {
249     int32_t testUserId = 200;
250 
251     IpcClientUtils::ResetObj();
252     int32_t ret = UserIdmClient::GetInstance().Cancel(testUserId);
253     EXPECT_EQ(ret, GENERAL_ERROR);
254 }
255 
256 HWTEST_F(UserIdmClientTest, UserIdmClientCancel002, TestSize.Level0)
257 {
258     int32_t testUserId = 200;
259 
260     auto service = Common::MakeShared<MockUserIdmService>();
261     EXPECT_NE(service, nullptr);
262     EXPECT_CALL(*service, Cancel(_)).Times(1);
263     ON_CALL(*service, Cancel)
264         .WillByDefault(
__anond6b7591b0602(int32_t userId) 265             [&testUserId](int32_t userId) {
266                 EXPECT_EQ(userId, testUserId);
267                 return SUCCESS;
268             }
269         );
270     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
271     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
272     CallRemoteObject(service, obj, dr);
273 
274     int32_t ret = UserIdmClient::GetInstance().Cancel(testUserId);
275     EXPECT_EQ(ret, SUCCESS);
276     EXPECT_NE(dr, nullptr);
277     dr->OnRemoteDied(obj);
278     IpcClientUtils::ResetObj();
279 }
280 
281 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteCredential001, TestSize.Level0)
282 {
283     int32_t testUserId = 200;
284     uint64_t testCredentialId = 111;
285     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
286     std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
287     UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
288 
289     IpcClientUtils::ResetObj();
290     testCallback = Common::MakeShared<MockUserIdmClientCallback>();
291     EXPECT_NE(testCallback, nullptr);
292     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
293     UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
294 }
295 
296 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteCredential002, TestSize.Level0)
297 {
298     int32_t testUserId = 200;
299     uint64_t testCredentialId = 111;
300     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
301     auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
302     EXPECT_NE(testCallback, nullptr);
303     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
304 
305     auto service = Common::MakeShared<MockUserIdmService>();
306     EXPECT_NE(service, nullptr);
307     EXPECT_CALL(*service, DelCredential(_, _, _, _)).Times(1);
308     ON_CALL(*service, DelCredential)
309         .WillByDefault(
310             [&testUserId, &testCredentialId, &testAuthToken](int32_t userId, uint64_t credentialId,
__anond6b7591b0702(int32_t userId, uint64_t credentialId, const std::vector<uint8_t> &authToken, const sptr<IdmCallbackInterface> &callback) 311                 const std::vector<uint8_t> &authToken, const sptr<IdmCallbackInterface> &callback) {
312                 EXPECT_EQ(userId, testUserId);
313                 EXPECT_EQ(credentialId, testCredentialId);
314                 EXPECT_THAT(authToken, ElementsAreArray(testAuthToken));
315                 if (callback != nullptr) {
316                     Attributes extraInfo;
317                     callback->OnResult(SUCCESS, extraInfo);
318                 }
319             }
320         );
321     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
322     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
323     CallRemoteObject(service, obj, dr);
324 
325     UserIdmClient::GetInstance().DeleteCredential(testUserId, testCredentialId, testAuthToken, testCallback);
326     EXPECT_NE(dr, nullptr);
327     dr->OnRemoteDied(obj);
328     IpcClientUtils::ResetObj();
329 }
330 
331 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteUser001, TestSize.Level0)
332 {
333     int32_t testUserId = 200;
334     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
335     std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
336     UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
337 
338     IpcClientUtils::ResetObj();
339     testCallback = Common::MakeShared<MockUserIdmClientCallback>();
340     EXPECT_NE(testCallback, nullptr);
341     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
342     UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
343 }
344 
345 HWTEST_F(UserIdmClientTest, UserIdmClientDeleteUser002, TestSize.Level0)
346 {
347     int32_t testUserId = 200;
348     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
349     auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
350     EXPECT_NE(testCallback, nullptr);
351     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
352 
353     auto service = Common::MakeShared<MockUserIdmService>();
354     EXPECT_NE(service, nullptr);
355     EXPECT_CALL(*service, DelUser(_, _, _)).Times(1);
356     ON_CALL(*service, DelUser)
357         .WillByDefault(
358             [&testUserId, &testAuthToken](int32_t userId, const std::vector<uint8_t> authToken,
__anond6b7591b0802(int32_t userId, const std::vector<uint8_t> authToken, const sptr<IdmCallbackInterface> &callback) 359                 const sptr<IdmCallbackInterface> &callback) {
360                 EXPECT_EQ(userId, testUserId);
361                 EXPECT_THAT(authToken, ElementsAreArray(testAuthToken));
362                 if (callback != nullptr) {
363                     Attributes extraInfo;
364                     callback->OnResult(SUCCESS, extraInfo);
365                 }
366             }
367         );
368     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
369     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
370     CallRemoteObject(service, obj, dr);
371 
372     UserIdmClient::GetInstance().DeleteUser(testUserId, testAuthToken, testCallback);
373     EXPECT_NE(dr, nullptr);
374     dr->OnRemoteDied(obj);
375     IpcClientUtils::ResetObj();
376 }
377 
378 HWTEST_F(UserIdmClientTest, UserIdmClientEraseUser001, TestSize.Level0)
379 {
380     int32_t testUserId = 200;
381     std::shared_ptr<MockUserIdmClientCallback> testCallback = nullptr;
382     int32_t ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
383     EXPECT_EQ(ret, GENERAL_ERROR);
384 
385     IpcClientUtils::ResetObj();
386     testCallback = Common::MakeShared<MockUserIdmClientCallback>();
387     EXPECT_NE(testCallback, nullptr);
388     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
389     ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
390     EXPECT_EQ(ret, GENERAL_ERROR);
391 }
392 
393 HWTEST_F(UserIdmClientTest, UserIdmClientEraseUser002, TestSize.Level0)
394 {
395     int32_t testUserId = 200;
396     auto testCallback = Common::MakeShared<MockUserIdmClientCallback>();
397     EXPECT_NE(testCallback, nullptr);
398     EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
399 
400     auto service = Common::MakeShared<MockUserIdmService>();
401     EXPECT_NE(service, nullptr);
402     EXPECT_CALL(*service, EnforceDelUser(_, _)).Times(1);
403     ON_CALL(*service, EnforceDelUser)
404         .WillByDefault(
__anond6b7591b0902(int32_t userId, const sptr<IdmCallbackInterface> &callback) 405             [&testUserId](int32_t userId, const sptr<IdmCallbackInterface> &callback) {
406                 EXPECT_EQ(userId, testUserId);
407                 if (callback != nullptr) {
408                     Attributes extraInfo;
409                     callback->OnResult(SUCCESS, extraInfo);
410                 }
411                 return SUCCESS;
412             }
413         );
414     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
415     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
416     CallRemoteObject(service, obj, dr);
417 
418     int32_t ret = UserIdmClient::GetInstance().EraseUser(testUserId, testCallback);
419     EXPECT_EQ(ret, SUCCESS);
420     EXPECT_NE(dr, nullptr);
421     dr->OnRemoteDied(obj);
422     IpcClientUtils::ResetObj();
423 }
424 
425 HWTEST_F(UserIdmClientTest, UserIdmClientGetCredentialInfo001, TestSize.Level0)
426 {
427     int32_t testUserId = 200;
428     AuthType testAuthType = PIN;
429     std::shared_ptr<MockGetCredentialInfoCallback> testCallback = nullptr;
430     int32_t ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
431     EXPECT_EQ(ret, GENERAL_ERROR);
432 
433     IpcClientUtils::ResetObj();
434     testCallback = Common::MakeShared<MockGetCredentialInfoCallback>();
435     EXPECT_NE(testCallback, nullptr);
436     EXPECT_CALL(*testCallback, OnCredentialInfo(_)).Times(1);
437     ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
438     EXPECT_EQ(ret, GENERAL_ERROR);
439 }
440 
441 HWTEST_F(UserIdmClientTest, UserIdmClientGetCredentialInfo002, TestSize.Level0)
442 {
443     int32_t testUserId = 200;
444     AuthType testAuthType = PIN;
445     auto testCallback = Common::MakeShared<MockGetCredentialInfoCallback>();
446     EXPECT_NE(testCallback, nullptr);
447     EXPECT_CALL(*testCallback, OnCredentialInfo(_)).Times(1);
448 
449     auto service = Common::MakeShared<MockUserIdmService>();
450     EXPECT_NE(service, nullptr);
451     EXPECT_CALL(*service, GetCredentialInfo(_, _, _)).Times(1);
452     ON_CALL(*service, GetCredentialInfo)
453         .WillByDefault(
454             [&testUserId, &testAuthType](int32_t userId, AuthType authType,
__anond6b7591b0a02(int32_t userId, AuthType authType, const sptr<IdmGetCredInfoCallbackInterface> &callback) 455                 const sptr<IdmGetCredInfoCallbackInterface> &callback) {
456                 EXPECT_EQ(userId, testUserId);
457                 EXPECT_EQ(authType, testAuthType);
458                 if (callback != nullptr) {
459                     std::vector<CredentialInfo> credInfoList;
460                     callback->OnCredentialInfos(credInfoList);
461                 }
462                 return SUCCESS;
463             }
464         );
465     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
466     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
467     CallRemoteObject(service, obj, dr);
468 
469     int32_t ret = UserIdmClient::GetInstance().GetCredentialInfo(testUserId, testAuthType, testCallback);
470     EXPECT_EQ(ret, SUCCESS);
471     EXPECT_NE(dr, nullptr);
472     dr->OnRemoteDied(obj);
473     IpcClientUtils::ResetObj();
474 }
475 
476 HWTEST_F(UserIdmClientTest, UserIdmClientGetSecUserInfo001, TestSize.Level0)
477 {
478     int32_t testUserId = 200;
479     std::shared_ptr<MockGetSecUserInfoCallback> testCallback = nullptr;
480     int32_t ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
481     EXPECT_EQ(ret, GENERAL_ERROR);
482 
483     IpcClientUtils::ResetObj();
484     testCallback = Common::MakeShared<MockGetSecUserInfoCallback>();
485     EXPECT_NE(testCallback, nullptr);
486     EXPECT_CALL(*testCallback, OnSecUserInfo(_)).Times(1);
487     ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
488     EXPECT_EQ(ret, GENERAL_ERROR);
489 }
490 
491 HWTEST_F(UserIdmClientTest, UserIdmClientGetSecUserInfo002, TestSize.Level0)
492 {
493     int32_t testUserId = 200;
494     auto testCallback = Common::MakeShared<MockGetSecUserInfoCallback>();
495     EXPECT_NE(testCallback, nullptr);
496 
497     auto service = Common::MakeShared<MockUserIdmService>();
498     EXPECT_NE(service, nullptr);
499     EXPECT_CALL(*service, GetSecInfo(_, _)).Times(1);
500     ON_CALL(*service, GetSecInfo)
501         .WillByDefault(
__anond6b7591b0b02(int32_t userId, const sptr<IdmGetSecureUserInfoCallbackInterface> &callback) 502             [&testUserId](int32_t userId, const sptr<IdmGetSecureUserInfoCallbackInterface> &callback) {
503                 EXPECT_EQ(userId, testUserId);
504                 EXPECT_NE(callback, nullptr);
505                 return SUCCESS;
506             }
507         );
508     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
509     sptr<IRemoteObject::DeathRecipient> dr(nullptr);
510     CallRemoteObject(service, obj, dr);
511 
512     int32_t ret = UserIdmClient::GetInstance().GetSecUserInfo(testUserId, testCallback);
513     EXPECT_EQ(ret, SUCCESS);
514     EXPECT_NE(dr, nullptr);
515     dr->OnRemoteDied(obj);
516     IpcClientUtils::ResetObj();
517 }
518 
CallRemoteObject(const std::shared_ptr<MockUserIdmService> service,const sptr<MockRemoteObject> & obj,sptr<IRemoteObject::DeathRecipient> & dr)519 void UserIdmClientTest::CallRemoteObject(const std::shared_ptr<MockUserIdmService> service,
520     const sptr<MockRemoteObject> &obj, sptr<IRemoteObject::DeathRecipient> &dr)
521 {
522     EXPECT_NE(obj, nullptr);
523     EXPECT_CALL(*obj, IsProxyObject()).WillRepeatedly(Return(true));
524     EXPECT_CALL(*obj, RemoveDeathRecipient(_)).WillRepeatedly(Return(true));
525     EXPECT_CALL(*obj, AddDeathRecipient(_))
526         .WillRepeatedly([&dr](const sptr<IRemoteObject::DeathRecipient> &recipient) {
527             dr = recipient;
528             return true;
529         });
530 
531     IpcClientUtils::SetObj(obj);
532     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
533     ON_CALL(*obj, SendRequest)
534         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
535             service->OnRemoteRequest(code, data, reply, option);
536             return OHOS::NO_ERROR;
537         });
538 }
539 } // namespace UserAuth
540 } // namespace UserIam
541 } // namespace OHOS