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 <gmock/gmock.h>
17 #include "accesstoken_kit.h"
18 #define private public
19 #include "account_iam_client.h"
20 #undef private
21 #include "account_iam_client_test_callback.h"
22 #include "account_log_wrapper.h"
23 #include "account_iam_callback_stub.h"
24 #include "account_iam_callback_service.h"
25 #ifdef PROXY_MOCK
26 #define private public
27 #include "account_iam_service.h"
28 #undef private
29 #endif
30 #include "account_iam_mgr_proxy.h"
31 #include "token_setproc.h"
32 #include "iam_common_defines.h"
33 #include "ipc_skeleton.h"
34 #include "test_common.h"
35 
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::AccountSA;
39 using namespace OHOS::Security::AccessToken;
40 using namespace OHOS::UserIam::UserAuth;
41 
42 static uint64_t g_selfTokenID = -1;
43 namespace OHOS {
44 namespace AccountTest {
45 namespace {
46 const int32_t TEST_USER_ID = 200;
47 const int32_t TEST_EXIST_ID = 100;
48 const int32_t DEFAULT_API_VERSION = 8;
49 const uint32_t INVALID_IPC_CODE = 1000;
50 const uint32_t INVALID_TOKEN_ID = 0;
51 const int32_t WAIT_TIME = 20;
52 const uint64_t TEST_CONTEXT_ID = 122;
53 const uint64_t TEST_CREDENTIAL_ID = 0;
54 const std::vector<uint8_t> TEST_CHALLENGE = {1, 2, 3, 4};
55 
56 static PermissionDef INFO_MANAGER_TEST_PERM_DEF1 = {
57     .permissionName = "ohos.permission.open_door",
58     .bundleName = "account_iam_client_test",
59     .grantMode = 1,
60     .availableLevel = APL_NORMAL,
61     .provisionEnable = true,
62     .distributedSceneEnable = false,
63     .label = "label",
64     .labelId = 1,
65     .description = "open the door",
66     .descriptionId = 1
67 };
68 
69 static PermissionDef INFO_MANAGER_TEST_PERM_DEF2 = {
70     .permissionName = "ohos.permission.break_door",
71     .bundleName = "account_iam_client_test",
72     .grantMode = 1,
73     .availableLevel = APL_NORMAL,
74     .provisionEnable = true,
75     .distributedSceneEnable = false,
76     .label = "label",
77     .labelId = 1,
78     .description = "break the door",
79     .descriptionId = 1
80 };
81 
82 static PermissionStateFull INFO_MANAGER_TEST_STATE1 = {
83     .permissionName = "ohos.permission.open_door",
84     .isGeneral = true,
85     .resDeviceID = {"local"},
86     .grantStatus = {1},
87     .grantFlags = {1}
88 };
89 
90 static PermissionStateFull INFO_MANAGER_TEST_STATE2 = {
91     .permissionName = "ohos.permission.open_door",
92     .isGeneral = true,
93     .resDeviceID = {"device 0", "device 1"},
94     .grantStatus = {1, 3},
95     .grantFlags = {1, 2}
96 };
97 
98 static HapPolicyParams INFO_MANAGER_TEST_POLICY_PRAMS = {
99     .apl = APL_NORMAL,
100     .domain = "account_iam",
101     .permList = {INFO_MANAGER_TEST_PERM_DEF1, INFO_MANAGER_TEST_PERM_DEF2},
102     .permStateList = {INFO_MANAGER_TEST_STATE1, INFO_MANAGER_TEST_STATE2}
103 };
104 
105 HapInfoParams infoManagerTestNormalInfoParms = {
106     .userID = 1,
107     .bundleName = "account_iam_client_test",
108     .instIndex = 0,
109     .appIDDesc = "test",
110     .apiVersion = DEFAULT_API_VERSION,
111     .isSystemApp = false
112 };
113 
114 HapInfoParams infoManagerTestSystemInfoParms = {
115     .userID = 1,
116     .bundleName = "account_iam_client_test",
117     .instIndex = 0,
118     .appIDDesc = "test",
119     .apiVersion = DEFAULT_API_VERSION,
120     .isSystemApp = true
121 };
122 } // namespace
123 
124 #ifdef HAS_PIN_AUTH_PART
125 class MockIInputer : public OHOS::AccountSA::IInputer {
126 public:
~MockIInputer()127     virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)128     void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
129         std::shared_ptr<IInputerData> inputerData) override
130     {
131         return;
132     }
133 };
134 #endif
135 
136 class AccountIAMClientTest : public testing::Test {
137 public:
138     static void SetUpTestCase(void);
139     static void TearDownTestCase(void);
140     void SetUp(void) override;
141     void TearDown(void) override;
142 };
143 
144 class CheckResultGetSetPropCallback final : public AccountSA::GetSetPropCallback {
145 public:
OnResult(int32_t result,const Attributes & extraInfo)146     void OnResult(int32_t result, const Attributes &extraInfo)
147     {
148         code_ = result;
149     }
GetResult()150     int GetResult()
151     {
152         if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
153             return ERR_OK;
154         }
155         return code_;
156     }
157 
158 private:
159     int code_;
160 };
161 
162 class CheckResultIDMCallback final : public AccountSA::IDMCallback {
163 public:
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)164     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo)
165     {
166         return;
167     }
OnResult(int32_t result,const Attributes & extraInfo)168     void OnResult(int32_t result, const Attributes &extraInfo)
169     {
170         code_ = result;
171     }
GetResult()172     int GetResult()
173     {
174         if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
175             return ERR_OK;
176         }
177         return code_;
178     }
179 
180 private:
181     int code_;
182 };
183 
184 class TestOnEnrolledIdCallback final : public AccountSA::GetEnrolledIdCallback {
185 public:
OnEnrolledId(int32_t result,uint64_t enrolledId)186     void OnEnrolledId(int32_t result, uint64_t enrolledId)
187     {
188         code_ = result;
189     }
GetResult()190     int GetResult()
191     {
192         if (code_ != ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR) {
193             return ERR_OK;
194         }
195         return code_;
196     }
197 
198 private:
199     int code_;
200 };
201 
202 #ifdef HAS_PIN_AUTH_PART
203 class TestIInputer : public OHOS::AccountSA::IInputer {
204 public:
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)205     void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
206         std::shared_ptr<IInputerData> inputerData) override
207     {
208         if (inputerData != nullptr) {
209             inputerData->OnSetData(authSubType, {0, 0, 0, 0, 0, 0});
210         }
211     }
212 
213     virtual ~TestIInputer() = default;
214 };
215 #endif
216 
SetUpTestCase(void)217 void AccountIAMClientTest::SetUpTestCase(void)
218 {
219     AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("accountmgr");
220     SetSelfTokenID(tokenId);
221     g_selfTokenID = tokenId;
222 #ifdef PROXY_MOCK
223     sptr<IAccountIAM> service = new (std::nothrow) AccountIAMService();
224     ASSERT_NE(service, nullptr);
225     AccountIAMClient::GetInstance().proxy_ = new (std::nothrow) AccountIAMMgrProxy(service->AsObject());
226     ASSERT_NE(AccountIAMClient::GetInstance().proxy_, nullptr);
227 #endif
228 }
229 
TearDownTestCase(void)230 void AccountIAMClientTest::TearDownTestCase(void)
231 {}
232 
SetUp(void)233 void AccountIAMClientTest::SetUp(void) __attribute__((no_sanitize("cfi")))
234 {
235     testing::UnitTest *test = testing::UnitTest::GetInstance();
236     ASSERT_NE(test, nullptr);
237     const testing::TestInfo *testinfo = test->current_test_info();
238     ASSERT_NE(testinfo, nullptr);
239     string testCaseName = string(testinfo->name());
240     ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
241 }
242 
TearDown(void)243 void AccountIAMClientTest::TearDown(void)
244 {}
245 
Wait(const std::shared_ptr<TestGetSetPropCallback> & ptr)246 void Wait(const std::shared_ptr<TestGetSetPropCallback> &ptr)
247 {
248     std::unique_lock<std::mutex> lock(ptr->mutex);
249     ptr->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
250         [lockPtr = ptr]() { return lockPtr->isReady; });
251 }
252 
Wait(const std::shared_ptr<TestIDMCallback> & ptr)253 void Wait(const std::shared_ptr<TestIDMCallback> &ptr)
254 {
255     std::unique_lock<std::mutex> lock(ptr->mutex);
256     ptr->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
257         [lockPtr = ptr]() { return lockPtr->isReady; });
258 }
259 
260 /**
261  * @tc.name: AccountIAMClient_OpenSession_0100
262  * @tc.desc: Open Session.
263  * @tc.type: FUNC
264  * @tc.require: issueI5N90O
265  */
266 HWTEST_F(AccountIAMClientTest, AccountIAMClient_OpenSession_0100, TestSize.Level0)
267 {
268     std::vector<uint8_t> challenge;
269     AccountIAMClient::GetInstance().OpenSession(-1, challenge);
270 #ifdef PROXY_MOCK
271     EXPECT_FALSE(challenge.size() != 0);
272 #else // BUNDLE_ADAPTER_MOCK
273     EXPECT_TRUE(challenge.size() != 0);
274 #endif
275     AccountIAMClient::GetInstance().CloseSession(-1);
276 }
277 
278 /**
279  * @tc.name: AccountIAMClient_AddCredential_0100
280  * @tc.desc: Add credential.
281  * @tc.type: FUNC
282  * @tc.require: issueI5N90O
283  */
284 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AddCredential_0100, TestSize.Level0)
285 {
286     CredentialParameters testPara = {};
287     auto callback = std::make_shared<MockIDMCallback>();
288     EXPECT_NE(callback, nullptr);
289 #ifdef PROXY_MOCK
290     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(0));
291 #else
292     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
293 #endif
294     auto testCallback = std::make_shared<TestIDMCallback>(callback);
295     EXPECT_NE(testCallback, nullptr);
296     AccountIAMClient::GetInstance().AddCredential(TEST_EXIST_ID, testPara, testCallback);
297 #ifndef PROXY_MOCK
298     std::unique_lock<std::mutex> lock(testCallback->mutex);
299     testCallback->cv.wait_for(
__anon438d7b4c0402() 300         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
301 #endif
302 }
303 
304 /**
305  * @tc.name: AccountIAMClient_AddCredential_0200
306  * @tc.desc: Add credential.
307  * @tc.type: FUNC
308  * @tc.require: issueI5N90O
309  */
310 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AddCredential_0200, TestSize.Level0)
311 {
312     CredentialParameters testPara = {};
313     testPara.authType = AuthType::PIN;
314     auto callback = std::make_shared<MockIDMCallback>();
315     EXPECT_NE(callback, nullptr);
316 #ifdef PROXY_MOCK
317     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(0));
318 #else
319     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
320 #endif
321     auto testCallback = std::make_shared<TestIDMCallback>(callback);
322     AccountIAMClient::GetInstance().AddCredential(-1, testPara, testCallback);
323 #ifndef PROXY_MOCK
324     {
325         std::unique_lock<std::mutex> lock(testCallback->mutex);
326         testCallback->cv.wait_for(
__anon438d7b4c0502() 327             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
328     }
329 #endif
330     AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, nullptr);
331     testCallback->isReady = false;
332     AccountIAMClient::GetInstance().AddCredential(TEST_EXIST_ID, testPara, testCallback);
333 #ifndef PROXY_MOCK
334     {
335         std::unique_lock<std::mutex> lock(testCallback->mutex);
336         testCallback->cv.wait_for(
__anon438d7b4c0602() 337             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
338     }
339 #endif
340 }
341 
342 /**
343  * @tc.name: AccountIAMClient_UpdateCredential_0100
344  * @tc.desc: Update credential.
345  * @tc.type: FUNC
346  * @tc.require: issueI5N90O
347  */
348 HWTEST_F(AccountIAMClientTest, AccountIAMClient_UpdateCredential_0100, TestSize.Level0)
349 {
350     CredentialParameters testPara = {};
351     auto callback = std::make_shared<MockIDMCallback>();
352     EXPECT_NE(callback, nullptr);
353     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
354     auto testCallback = std::make_shared<TestIDMCallback>(callback);
355     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testCallback);
356     std::unique_lock<std::mutex> lock(testCallback->mutex);
357     testCallback->cv.wait_for(
__anon438d7b4c0702() 358         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
359 }
360 
361 /**
362  * @tc.name: AccountIAMClient_UpdateCredential_200
363  * @tc.desc: Update credential.
364  * @tc.type: FUNC
365  * @tc.require: issueI5N90O
366  */
367 HWTEST_F(AccountIAMClientTest, AccountIAMClient_UpdateCredential_200, TestSize.Level0)
368 {
369     CredentialParameters testPara = {};
370     testPara.authType = AuthType::PIN;
371     auto callback = std::make_shared<MockIDMCallback>();
372     EXPECT_NE(callback, nullptr);
373     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
374     auto testCallback = std::make_shared<TestIDMCallback>(callback);
375     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, nullptr);
376     AccountIAMClient::GetInstance().UpdateCredential(0, testPara, testCallback);
377     {
378         std::unique_lock<std::mutex> lock(testCallback->mutex);
379         testCallback->cv.wait_for(
__anon438d7b4c0802() 380             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
381     }
382     testCallback->isReady = false;
383     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testCallback);
384     {
385         std::unique_lock<std::mutex> lock(testCallback->mutex);
386         testCallback->cv.wait_for(
__anon438d7b4c0902() 387             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
388     }
389 }
390 
391 /**
392  * @tc.name: AccountIAMClient_Cancel_0100
393  * @tc.desc: Cancel.
394  * @tc.type: FUNC
395  * @tc.require: issueI5N90O
396  */
397 HWTEST_F(AccountIAMClientTest, AccountIAMClient_Cancel_0100, TestSize.Level0)
398 {
399     int32_t ret = AccountIAMClient::GetInstance().Cancel(TEST_USER_ID);
400     EXPECT_NE(ret, 0);
401 }
402 
403 /**
404  * @tc.name: AccountIAMClient_DelCred_0100
405  * @tc.desc: Delete credential.
406  * @tc.type: FUNC
407  * @tc.require: issueI5N90O
408  */
409 HWTEST_F(AccountIAMClientTest, AccountIAMClient_DelCred_0100, TestSize.Level0)
410 {
411     uint64_t testCredentialId = 111;
412     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
413     auto callback = std::make_shared<MockIDMCallback>();
414     EXPECT_NE(callback, nullptr);
415     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
416     auto testCallback = std::make_shared<TestIDMCallback>(callback);
417     AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, nullptr);
418     AccountIAMClient::GetInstance().DelCred(0, testCredentialId, testAuthToken, testCallback);
419     {
420         std::unique_lock<std::mutex> lock(testCallback->mutex);
421         testCallback->cv.wait_for(
__anon438d7b4c0a02() 422             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
423     }
424     testCallback->isReady = false;
425     AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testCallback);
426     {
427         std::unique_lock<std::mutex> lock(testCallback->mutex);
428         testCallback->cv.wait_for(
__anon438d7b4c0b02() 429             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
430     }
431 }
432 
433 /**
434  * @tc.name: AccountIAMClient_DelUser_0100
435  * @tc.desc: Delete user.
436  * @tc.type: FUNC
437  * @tc.require: issueI5N90O
438  */
439 HWTEST_F(AccountIAMClientTest, AccountIAMClient_DelUser_0100, TestSize.Level0)
440 {
441     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
442     auto callback = std::make_shared<MockIDMCallback>();
443     EXPECT_NE(callback, nullptr);
444     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
445     auto testCallback = std::make_shared<TestIDMCallback>(callback);
446     AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, nullptr);
447     AccountIAMClient::GetInstance().DelUser(0, testAuthToken, testCallback);
448     {
449         std::unique_lock<std::mutex> lock(testCallback->mutex);
450         testCallback->cv.wait_for(
__anon438d7b4c0c02() 451             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
452     }
453     testCallback->isReady = false;
454     AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testCallback);
455     {
456         std::unique_lock<std::mutex> lock(testCallback->mutex);
457         testCallback->cv.wait_for(
__anon438d7b4c0d02() 458             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
459     }
460 }
461 
462 /**
463  * @tc.name: AccountIAMClient_GetCredentialInfo_0100
464  * @tc.desc: Get credential info.
465  * @tc.type: FUNC
466  * @tc.require: issueI5N90O
467  */
468 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetCredentialInfo_0100, TestSize.Level0)
469 {
470     auto callback = std::make_shared<MockGetCredInfoCallback>();
471     EXPECT_NE(callback, nullptr);
472     auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
473     EXPECT_CALL(*callback, OnCredentialInfo(_, _)).Times(Exactly(1));
474     AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback);
475     std::unique_lock<std::mutex> lock(testCallback->mutex);
476     testCallback->cv.wait_for(
__anon438d7b4c0e02() 477         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
478 }
479 
480 /**
481  * @tc.name: AccountIAMClient_GetEnrolledId_0100
482  * @tc.desc: Get enrolled id.
483  * @tc.type: FUNC
484  * @tc.require:
485  */
486 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetEnrolledId_0100, TestSize.Level0)
487 {
488     auto callback = std::make_shared<MockGetEnrolledIdCallback>();
489     ASSERT_NE(callback, nullptr);
490     auto testCallback = std::make_shared<TestGetEnrolledIdCallback>(callback);
491     EXPECT_CALL(*callback, OnEnrolledId(_, _)).Times(Exactly(1));
492     AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testCallback);
493     std::unique_lock<std::mutex> lock(testCallback->mutex);
494     testCallback->cv.wait_for(
__anon438d7b4c0f02() 495         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
496 }
497 
498 /**
499  * @tc.name: AccountIAMClient_GetAvailableStatus_0100
500  * @tc.desc: Get available status.
501  * @tc.type: FUNC
502  * @tc.require: issueI5N90O
503  */
504 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0100, TestSize.Level0)
505 {
506     int32_t status;
507     AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
508     AccountIAMClient::AccountIAMDeathRecipient recipient;
509     recipient.OnRemoteDied(nullptr);
510     EXPECT_NE(status, 0);
511 }
512 
513 /**
514  * @tc.name: AccountIAMClient_GetAvailableStatus_0200
515  * @tc.desc: Get available status.
516  * @tc.type: FUNC
517  * @tc.require: issueI5N90O
518  */
519 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0200, TestSize.Level0)
520 {
521     int32_t status;
522     AuthTrustLevel level = static_cast<AuthTrustLevel>(0);
523     int32_t ret = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, level, status);
524     EXPECT_EQ(ERR_ACCOUNT_COMMON_INVALID_PARAMETER, ret);
525 }
526 
527 /**
528  * @tc.name: AccountIAMClient_GetAvailableStatus_0300
529  * @tc.desc: AuthType is err.
530  * @tc.type: FUNC
531  * @tc.require: issueI5N90O
532  */
533 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetAvailableStatus_0300, TestSize.Level0)
534 {
535     int32_t status;
536     AuthTrustLevel level = static_cast<AuthTrustLevel>(20000);
537     AuthType authType = static_cast<AuthType>(-1);
538     int32_t ret = AccountIAMClient::GetInstance().GetAvailableStatus(authType, level, status);
539     EXPECT_EQ(ERR_ACCOUNT_COMMON_INVALID_PARAMETER, ret);
540 }
541 
542 /**
543  * @tc.name: AccountIAMClient_GetProperty_0100
544  * @tc.desc: Get property.
545  * @tc.type: FUNC
546  * @tc.require: issueI5N90O
547  */
548 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetProperty_0100, TestSize.Level0)
549 {
550     GetPropertyRequest testRequest = {
551         .keys = { Attributes::AttributeKey::ATTR_PIN_SUB_TYPE }
552     };
553     auto callback = std::make_shared<MockGetSetPropCallback>();
554     EXPECT_NE(callback, nullptr);
555     auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
556     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
557     AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, nullptr);
558     AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequest, testCallback);
559     std::unique_lock<std::mutex> lock(testCallback->mutex);
560     testCallback->cv.wait_for(
__anon438d7b4c1002() 561         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
562 }
563 
564 /**
565  * @tc.name: AccountIAMClient_GetPropertyById_0100
566  * @tc.desc: Get property by id.
567  * @tc.type: FUNC
568  * @tc.require:
569  */
570 HWTEST_F(AccountIAMClientTest, AccountIAMClient_GetPropertyById_0100, TestSize.Level0)
571 {
572     auto callback = std::make_shared<MockGetSetPropCallback>();
573     EXPECT_NE(callback, nullptr);
574     auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
575     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
576     std::vector<Attributes::AttributeKey> keys { Attributes::AttributeKey::ATTR_PIN_SUB_TYPE };
577     AccountIAMClient::GetInstance().GetPropertyByCredentialId(
578         TEST_CREDENTIAL_ID, keys, nullptr);
579     AccountIAMClient::GetInstance().GetPropertyByCredentialId(
580         TEST_CREDENTIAL_ID, keys, testCallback);
581     std::unique_lock<std::mutex> lock(testCallback->mutex);
582     testCallback->cv.wait_for(
__anon438d7b4c1102() 583         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
584 }
585 
586 /**
587  * @tc.name: AccountIAMClient_SetProperty_0100
588  * @tc.desc: Set property.
589  * @tc.type: FUNC
590  * @tc.require: issueI5N90O
591  */
592 HWTEST_F(AccountIAMClientTest, AccountIAMClient_SetProperty_0100, TestSize.Level0)
593 {
594     SetPropertyRequest testRequest = {};
595     auto callback = std::make_shared<MockGetSetPropCallback>();
596     EXPECT_NE(callback, nullptr);
597     auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
598     EXPECT_CALL(*callback, OnResult(_, _)).Times(1);
599     AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, nullptr);
600     AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequest, testCallback);
601     std::unique_lock<std::mutex> lock(testCallback->mutex);
602     testCallback->cv.wait_for(
__anon438d7b4c1202() 603         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
604 }
605 
606 /**
607  * @tc.name: AccountIAMClient_AuthUser_0100
608  * @tc.desc: Auth user.
609  * @tc.type: FUNC
610  * @tc.require: issueI5N90O
611  */
612 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0100, TestSize.Level0)
613 {
614     SetPropertyRequest testRequest = {};
615     auto callback = std::make_shared<MockIDMCallback>();
616     EXPECT_NE(callback, nullptr);
617     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(2));
618     auto testCallback = std::make_shared<TestIDMCallback>(callback);
619     AuthOptions authOptionsOne;
620     AccountIAMClient::GetInstance().AuthUser(
621         authOptionsOne, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
622     {
623         std::unique_lock<std::mutex> lock(testCallback->mutex);
624         testCallback->cv.wait_for(
__anon438d7b4c1302() 625             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
626     }
627     testCallback->isReady = false;
628     AuthOptions authOptionsTwo;
629     authOptionsTwo.accountId = TEST_USER_ID;
630     AccountIAMClient::GetInstance().AuthUser(
631         authOptionsTwo, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
632     {
633         std::unique_lock<std::mutex> lock(testCallback->mutex);
634         testCallback->cv.wait_for(
__anon438d7b4c1402() 635             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
636     }
637 }
638 
639 /**
640  * @tc.name: AccountIAMClient_AuthUser_0200
641  * @tc.desc: Auth callback is nullptr.
642  * @tc.type: FUNC
643  * @tc.require: issueI5N90O
644  */
645 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0200, TestSize.Level0)
646 {
647     AuthOptions authOptions;
648     uint64_t ret = AccountIAMClient::GetInstance().AuthUser(
649         authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, nullptr);
650     EXPECT_EQ(ret, 0);
651 }
652 
653 /**
654  * @tc.name: AccountIAMClient_Auth_0100
655  * @tc.desc: Auth current user.
656  * @tc.type: FUNC
657  * @tc.require: issueI5N90O
658  */
659 HWTEST_F(AccountIAMClientTest, AccountIAMClient_Auth_0100, TestSize.Level0)
660 {
661     SetPropertyRequest testRequest = {};
662     auto callback = std::make_shared<MockIDMCallback>();
663     EXPECT_NE(callback, nullptr);
664     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
665     auto testCallback = std::make_shared<TestIDMCallback>(callback);
666     AuthOptions authOptions;
667     AccountIAMClient::GetInstance().Auth(authOptions,
668         TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
669     std::unique_lock<std::mutex> lock(testCallback->mutex);
670     testCallback->cv.wait_for(
__anon438d7b4c1502() 671         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
672 }
673 
674 /**
675  * @tc.name: AccountIAMClient_CancelAuth_0100
676  * @tc.desc: Cancel authentication.
677  * @tc.type: FUNC
678  * @tc.require: issueI5N90O
679  */
680 HWTEST_F(AccountIAMClientTest, AccountIAMClient_CancelAuth_0100, TestSize.Level0)
681 {
682     EXPECT_NE(ERR_OK, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
683 }
684 
685 #ifdef HAS_PIN_AUTH_PART
686 /**
687  * @tc.name: AccountIAMClient_RegisterPINInputer_0100
688  * @tc.desc: Register inputer.
689  * @tc.type: FUNC
690  * @tc.require: issueI5N90O
691  */
692 HWTEST_F(AccountIAMClientTest, AccountIAMClient_RegisterPINInputer_0100, TestSize.Level0)
693 {
694     std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
695     EXPECT_NE(nullptr, inputer);
696     EXPECT_EQ(ERR_OK, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
697     EXPECT_EQ(ERR_ACCOUNT_IAM_KIT_INPUTER_ALREADY_REGISTERED,
698         AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
699 
700     AccountIAMClient::GetInstance().UnregisterPINInputer();
701 }
702 
703 /**
704  * @tc.name: AccountIAMClient_RegisterInputer_0100
705  * @tc.desc: Unregister/Register inputer failed for unsupported auth type.
706  * @tc.type: FUNC
707  * @tc.require: issueI5N90O
708  */
709 HWTEST_F(AccountIAMClientTest, AccountIAMClient_RegisterInputer_0100, TestSize.Level0)
710 {
711     std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
712     EXPECT_NE(nullptr, inputer);
713     EXPECT_EQ(ERR_ACCOUNT_IAM_UNSUPPORTED_AUTH_TYPE,
714         AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputer));
715     EXPECT_EQ(ERR_ACCOUNT_IAM_UNSUPPORTED_AUTH_TYPE, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
716 }
717 #endif
718 
719 /**
720  * @tc.name: AccountIAMClient_SetAuthSubType_0100
721  * @tc.desc: SetAuthSubType.
722  * @tc.type: FUNC
723  * @tc.require: issueI5N90O
724  */
725 HWTEST_F(AccountIAMClientTest, AccountIAMClient_SetAuthSubType_0100, TestSize.Level0)
726 {
727     int32_t userId = 1111; // 1111: userId
728     int32_t type = 11;
729     EXPECT_EQ(0, AccountIAMClient::GetInstance().GetAuthSubType(userId));
730     AccountIAMClient::GetInstance().SetAuthSubType(userId, type);
731     EXPECT_EQ(type, AccountIAMClient::GetInstance().GetAuthSubType(userId));
732 
733     AccountIAMClient::GetInstance().SetAuthSubType(userId, type + 1);
734     EXPECT_EQ(type, AccountIAMClient::GetInstance().GetAuthSubType(userId));
735 }
736 
737 /**
738  * @tc.name: IDMCallbackStub_OnRemoteRequest_0100
739  * @tc.desc: OnRemoteRequest with wrong message code.
740  * @tc.type: FUNC
741  * @tc.require:
742  */
743 HWTEST_F(AccountIAMClientTest, IDMCallbackStub_OnRemoteRequest_0100, TestSize.Level0)
744 {
745     MessageParcel data;
746     MessageParcel reply;
747     MessageOption option = {MessageOption::TF_SYNC};
748     data.WriteInterfaceToken(IDMCallbackStub::GetDescriptor());
749 
750     sptr<IDMCallbackStub> stub = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
751     ASSERT_NE(nullptr, stub);
752     int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
753     EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
754 }
755 
756 /**
757  * @tc.name: IDMCallbackStub_ProcOnAcquireInfo_0100
758  * @tc.desc: ProcOnAcquireInfo.
759  * @tc.type: FUNC
760  * @tc.require:
761  */
762 HWTEST_F(AccountIAMClientTest, IDMCallbackStub_ProcOnAcquireInfo_0100, TestSize.Level0)
763 {
764     MessageParcel data;
765     MessageParcel reply;
766     MessageOption option = {MessageOption::TF_SYNC};
767 
768     int32_t module = 0;
769     int32_t acquireInfo = 0;
770     std::vector<uint8_t> buffer;
771     data.WriteInterfaceToken(IDMCallbackStub::GetDescriptor());
772     data.WriteInt32(module);
773     data.WriteInt32(acquireInfo);
774     data.WriteUInt8Vector(buffer);
775 
776     sptr<IDMCallbackStub> stub = new (std::nothrow) IDMCallbackService(TEST_USER_ID, nullptr);
777     ASSERT_NE(nullptr, stub);
778     int32_t ret = stub->OnRemoteRequest(static_cast<uint32_t>(IDMCallbackInterfaceCode::ON_ACQUIRE_INFO), data, reply,
779         option);
780     EXPECT_EQ(ERR_OK, ret);
781 }
782 
783 /**
784  * @tc.name: GetCredInfoCallbackStub_OnRemoteRequest_0100
785  * @tc.desc: OnRemoteRequest with wrong message code.
786  * @tc.type: FUNC
787  * @tc.require:
788  */
789 HWTEST_F(AccountIAMClientTest, GetCredInfoCallbackStub_OnRemoteRequest_0100, TestSize.Level0)
790 {
791     MessageParcel data;
792     MessageParcel reply;
793     MessageOption option = {MessageOption::TF_SYNC};
794     data.WriteInterfaceToken(GetCredInfoCallbackStub::GetDescriptor());
795 
796     sptr<GetCredInfoCallbackStub> stub = new (std::nothrow) GetCredInfoCallbackService(nullptr);
797     ASSERT_NE(nullptr, stub);
798     int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
799     EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
800 }
801 
802 /**
803  * @tc.name: GetCredInfoCallbackStub_ProcOnCredentialInfo_0100
804  * @tc.desc: ProcOnCredentialInfo.
805  * @tc.type: FUNC
806  * @tc.require:
807  */
808 HWTEST_F(AccountIAMClientTest, GetCredInfoCallbackStub_ProcOnCredentialInfo_0100, TestSize.Level0)
809 {
810     MessageParcel data;
811     MessageParcel reply;
812     MessageOption option = {MessageOption::TF_SYNC};
813 
814     uint32_t vectorSize = 1;
815     CredentialInfo info;
816     std::vector<CredentialInfo> infoList = {info};
817     data.WriteInterfaceToken(GetCredInfoCallbackStub::GetDescriptor());
818     data.WriteUint32(vectorSize);
819     for (const auto &info : infoList) {
820         data.WriteUint64(info.credentialId);
821         data.WriteInt32(info.authType);
822         PinSubType pinType = info.pinType.value_or(PinSubType::PIN_MAX);
823         data.WriteInt32(pinType);
824         data.WriteUint64(info.templateId);
825     }
826 
827     sptr<GetCredInfoCallbackStub> stub = new (std::nothrow) GetCredInfoCallbackService(nullptr);
828     ASSERT_NE(nullptr, stub);
829     int32_t ret = stub->OnRemoteRequest(static_cast<uint32_t>(GetCredInfoCallbackInterfaceCode::ON_CREDENTIAL_INFO),
830         data, reply, option);
831     EXPECT_EQ(ERR_OK, ret);
832 }
833 
834 /**
835  * @tc.name: GetSetPropCallbackStub_OnRemoteRequest_0100
836  * @tc.desc: OnRemoteRequest with wrong message code.
837  * @tc.type: FUNC
838  * @tc.require:
839  */
840 HWTEST_F(AccountIAMClientTest, GetSetPropCallbackStub_OnRemoteRequest_0100, TestSize.Level0)
841 {
842     MessageParcel data;
843     MessageParcel reply;
844     MessageOption option = {MessageOption::TF_SYNC};
845     data.WriteInterfaceToken(GetSetPropCallbackStub::GetDescriptor());
846 
847     sptr<GetSetPropCallbackStub> stub = new (std::nothrow) GetSetPropCallbackService(nullptr);
848     ASSERT_NE(nullptr, stub);
849     int32_t ret = stub->OnRemoteRequest(INVALID_IPC_CODE, data, reply, option);
850     EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR, ret);
851 }
852 
853 /**
854  * @tc.name: AccountIAMClient001
855  * @tc.desc: Test the interface of the accountIAM calling the server not pass system applicaiton verify.
856  * @tc.type: FUNC
857  * @tc.require: issueI66BG5
858  */
859 HWTEST_F(AccountIAMClientTest, AccountIAMClient001, TestSize.Level0)
860 {
861     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
862     tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestNormalInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
863     ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
864     SetSelfTokenID(tokenIdEx.tokenIDEx);
865 
866     int32_t status;
867     int result = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
868     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, result);
869 
870     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
871 
872 #ifdef HAS_PIN_AUTH_PART
873     std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
874     ASSERT_NE(nullptr, inputer);
875     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
876 
877     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterPINInputer());
878 
879     std::shared_ptr<IInputer> inputerTwo = std::make_shared<TestIInputer>();
880     ASSERT_NE(nullptr, inputerTwo);
881     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR,
882         AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputerTwo));
883     ASSERT_EQ(
884         ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
885 #endif
886 
887     std::vector<uint8_t> challenge;
888     ASSERT_EQ(AccountIAMClient::GetInstance().OpenSession(0, challenge), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
889 
890     ASSERT_EQ(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CloseSession(TEST_USER_ID));
891 
892     ASSERT_EQ(AccountIAMClient::GetInstance().Cancel(TEST_USER_ID), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
893 
894     auto callback = std::make_shared<MockGetCredInfoCallback>();
895     auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
896     ASSERT_NE(testCallback, nullptr);
897     EXPECT_CALL(*callback, OnCredentialInfo(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
898     ASSERT_EQ(AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback),
899         ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
900     std::unique_lock<std::mutex> lock(testCallback->mutex);
901     testCallback->cv.wait_for(
__anon438d7b4c1602() 902         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
903 
904     auto getEnrolledIdCallback = std::make_shared<MockGetEnrolledIdCallback>();
905     auto testGetEnrolledIdCallback = std::make_shared<TestGetEnrolledIdCallback>(getEnrolledIdCallback);
906     ASSERT_NE(testGetEnrolledIdCallback, nullptr);
907     EXPECT_CALL(*getEnrolledIdCallback, OnEnrolledId(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
908     AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
909     std::unique_lock<std::mutex> cvLock(testGetEnrolledIdCallback->mutex);
910     testGetEnrolledIdCallback->cv.wait_for(cvLock, std::chrono::seconds(WAIT_TIME),
__anon438d7b4c1702() 911         [lockCallback = testGetEnrolledIdCallback]() { return lockCallback->isReady; });
912 
913     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestNormalInfoParms.userID,
914         infoManagerTestNormalInfoParms.bundleName, infoManagerTestNormalInfoParms.instIndex);
915     AccessTokenKit::DeleteToken(tokenID);
916     SetSelfTokenID(g_selfTokenID);
917 }
918 
919 /**
920  * @tc.name: AccountIAMClient002
921  * @tc.desc: Test accountIAM interface call server which result returned by the callback not pass system app verify.
922  * @tc.type: FUNC
923  * @tc.require: issueI66BG5
924  */
925 HWTEST_F(AccountIAMClientTest, AccountIAMClient002, TestSize.Level0)
926 {
927     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
928     tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestNormalInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
929     ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
930     SetSelfTokenID(tokenIdEx.tokenIDEx);
931 
932     GetPropertyRequest testRequestGet = {};
933     auto callback = std::make_shared<MockGetSetPropCallback>();
934     EXPECT_NE(callback, nullptr);
935     auto testCallback = std::make_shared<TestGetSetPropCallback>(callback);
936     EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
937     AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequestGet, testCallback);
938     Wait(testCallback);
939 
940     SetPropertyRequest testRequestSet = {};
941     EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(1);
942     testCallback->isReady = false;
943     AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequestSet, testCallback);
944     Wait(testCallback);
945 
946     CredentialParameters testPara = {};
947     auto idmCallback = std::make_shared<MockIDMCallback>();
948     ASSERT_NE(idmCallback, nullptr);
949     auto testIDMCallback = std::make_shared<TestIDMCallback>(idmCallback);
950     EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
951     AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, testIDMCallback);
952     Wait(testIDMCallback);
953 
954     EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
955     testIDMCallback->isReady = false;
956     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testIDMCallback);
957     Wait(testIDMCallback);
958 
959     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
960     uint64_t testCredentialId = 111;
961     EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
962     testIDMCallback->isReady = false;
963     AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testIDMCallback);
964     Wait(testIDMCallback);
965 
966     EXPECT_CALL(*idmCallback, OnResult(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, _)).Times(Exactly(1));
967     testIDMCallback->isReady = false;
968     AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testIDMCallback);
969     Wait(testIDMCallback);
970 
971     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestNormalInfoParms.userID,
972         infoManagerTestNormalInfoParms.bundleName, infoManagerTestNormalInfoParms.instIndex);
973     AccessTokenKit::DeleteToken(tokenID);
974     SetSelfTokenID(g_selfTokenID);
975 }
976 
977 /**
978  * @tc.name: AccountIAMClient003
979  * @tc.desc: Test the interface of the accountIAM calling the server pass system applicaiton verify.
980  * @tc.type: FUNC
981  * @tc.require: issueI66BG5
982  */
983 HWTEST_F(AccountIAMClientTest, AccountIAMClient003, TestSize.Level0)
984 {
985     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
986     tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestSystemInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
987     ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
988     SetSelfTokenID(tokenIdEx.tokenIDEx);
989 
990     int32_t status;
991     int result = AccountIAMClient::GetInstance().GetAvailableStatus(AuthType::FACE, AuthTrustLevel::ATL1, status);
992     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, result);
993 
994     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CancelAuth(TEST_CONTEXT_ID));
995 
996 #ifdef HAS_PIN_AUTH_PART
997     std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
998     ASSERT_NE(nullptr, inputer);
999     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().RegisterPINInputer(inputer));
1000 
1001     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterPINInputer());
1002 
1003     std::shared_ptr<IInputer> inputerTwo = std::make_shared<TestIInputer>();
1004     ASSERT_NE(nullptr, inputerTwo);
1005     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR,
1006         AccountIAMClient::GetInstance().RegisterInputer(AuthType::PIN, inputerTwo));
1007     ASSERT_NE(
1008         ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().UnregisterInputer(AuthType::PIN));
1009 #endif
1010 
1011     std::vector<uint8_t> challenge;
1012     ASSERT_NE(AccountIAMClient::GetInstance().OpenSession(0, challenge), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
1013 
1014     ASSERT_NE(ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR, AccountIAMClient::GetInstance().CloseSession(TEST_USER_ID));
1015 
1016     ASSERT_NE(AccountIAMClient::GetInstance().Cancel(TEST_USER_ID), ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
1017 
1018     auto callback = std::make_shared<MockGetCredInfoCallback>();
1019     auto testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
1020     ASSERT_NE(testCallback, nullptr);
1021     ASSERT_NE(AccountIAMClient::GetInstance().GetCredentialInfo(TEST_USER_ID, AuthType::PIN, testCallback),
1022         ERR_ACCOUNT_COMMON_NOT_SYSTEM_APP_ERROR);
1023 
1024     auto getEnrolledIdCallback = std::make_shared<MockGetEnrolledIdCallback>();
1025     auto testGetEnrolledIdCallback = std::make_shared<TestGetEnrolledIdCallback>(getEnrolledIdCallback);
1026     ASSERT_NE(testGetEnrolledIdCallback, nullptr);
1027     EXPECT_CALL(*getEnrolledIdCallback, OnEnrolledId(ERR_ACCOUNT_COMMON_PERMISSION_DENIED, _)).Times(1);
1028     AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
1029     std::unique_lock<std::mutex> lock(testGetEnrolledIdCallback->mutex);
1030     testGetEnrolledIdCallback->cv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
__anon438d7b4c1802() 1031         [lockCallback = testGetEnrolledIdCallback]() { return lockCallback->isReady; });
1032 
1033     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestSystemInfoParms.userID,
1034         infoManagerTestSystemInfoParms.bundleName, infoManagerTestSystemInfoParms.instIndex);
1035     AccessTokenKit::DeleteToken(tokenID);
1036     SetSelfTokenID(g_selfTokenID);
1037 }
1038 
1039 /**
1040  * @tc.name: AccountIAMClient004
1041  * @tc.desc: Test accountIAM interface call server which result returned by the callback pass system app verify.
1042  * @tc.type: FUNC
1043  * @tc.require: issueI66BG5
1044  */
1045 HWTEST_F(AccountIAMClientTest, AccountIAMClient004, TestSize.Level0)
1046 {
1047     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
1048     tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestSystemInfoParms, INFO_MANAGER_TEST_POLICY_PRAMS);
1049     ASSERT_NE(INVALID_TOKEN_ID, tokenIdEx.tokenIDEx);
1050     SetSelfTokenID(tokenIdEx.tokenIDEx);
1051 
1052     GetPropertyRequest testRequestGet = {};
1053     auto testCallback = std::make_shared<CheckResultGetSetPropCallback>();
1054     ASSERT_NE(testCallback, nullptr);
1055     AccountIAMClient::GetInstance().GetProperty(TEST_USER_ID, testRequestGet, testCallback);
1056     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1057 
1058     SetPropertyRequest testRequestSet = {};
1059     AccountIAMClient::GetInstance().SetProperty(TEST_USER_ID, testRequestSet, testCallback);
1060     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1061 
1062     CredentialParameters testPara = {};
1063     auto testIDMCallback = std::make_shared<CheckResultIDMCallback>();
1064     ASSERT_NE(testIDMCallback, nullptr);
1065     AccountIAMClient::GetInstance().AddCredential(TEST_USER_ID, testPara, testIDMCallback);
1066     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1067 
1068     AccountIAMClient::GetInstance().UpdateCredential(TEST_USER_ID, testPara, testIDMCallback);
1069     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1070 
1071     std::vector<uint8_t> testAuthToken = {1, 2, 3, 4};
1072     uint64_t testCredentialId = 111;
1073     AccountIAMClient::GetInstance().DelUser(TEST_USER_ID, testAuthToken, testIDMCallback);
1074     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1075 
1076     AccountIAMClient::GetInstance().DelCred(TEST_USER_ID, testCredentialId, testAuthToken, testIDMCallback);
1077     ASSERT_EQ(testCallback->GetResult(), ERR_OK);
1078 
1079     auto testGetEnrolledIdCallback = std::make_shared<TestOnEnrolledIdCallback>();
1080     ASSERT_NE(testGetEnrolledIdCallback, nullptr);
1081     AccountIAMClient::GetInstance().GetEnrolledId(TEST_USER_ID, AuthType::PIN, testGetEnrolledIdCallback);
1082     ASSERT_EQ(testGetEnrolledIdCallback->GetResult(), ERR_OK);
1083 
1084     AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoManagerTestSystemInfoParms.userID,
1085         infoManagerTestSystemInfoParms.bundleName, infoManagerTestSystemInfoParms.instIndex);
1086     AccessTokenKit::DeleteToken(tokenID);
1087     SetSelfTokenID(g_selfTokenID);
1088 }
1089 
1090 #ifdef HAS_PIN_AUTH_PART
1091 /**
1092  * @tc.name: StartDomainAuth001
1093  * @tc.desc: test StartDomainAuth.
1094  * @tc.type: FUNC
1095  * @tc.require:
1096  */
1097 HWTEST_F(AccountIAMClientTest, StartDomainAuth001, TestSize.Level0)
1098 {
1099     auto callback = std::make_shared<MockIDMCallback>();
1100     EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_IAM_KIT_INPUTER_NOT_REGISTERED, _)).Times(Exactly(1));
1101     auto testCallback = std::make_shared<TestIDMCallback>(callback);
1102     AccountIAMClient::GetInstance().domainInputer_ = nullptr;
1103     uint64_t ret = AccountIAMClient::GetInstance().StartDomainAuth(TEST_USER_ID, testCallback);
1104     std::unique_lock<std::mutex> lock(testCallback->mutex);
1105     testCallback->cv.wait_for(
__anon438d7b4c1902() 1106         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1107     EXPECT_EQ(0, ret);
1108 }
1109 
1110 /**
1111  * @tc.name: StartDomainAuth002
1112  * @tc.desc: test StartDomainAuth.
1113  * @tc.type: FUNC
1114  * @tc.require:
1115  */
1116 HWTEST_F(AccountIAMClientTest, StartDomainAuth002, TestSize.Level0)
1117 {
1118     auto callback = std::make_shared<MockIDMCallback>();
1119     EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_COMMON_ACCOUNT_NOT_EXIST_ERROR, _)).Times(Exactly(1));
1120     auto testCallback = std::make_shared<TestIDMCallback>(callback);
1121     std::shared_ptr<IInputer> inputer = std::make_shared<TestIInputer>();
1122     AccountIAMClient::GetInstance().domainInputer_ = inputer;
1123     uint64_t ret = AccountIAMClient::GetInstance().StartDomainAuth(TEST_USER_ID, testCallback);
1124     std::unique_lock<std::mutex> lock(testCallback->mutex);
1125     testCallback->cv.wait_for(
__anon438d7b4c1a02() 1126         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1127     EXPECT_EQ(0, ret);
1128     testing::Mock::AllowLeak(testCallback.get());
1129 }
1130 #endif
1131 
1132 /**
1133  * @tc.name: PrepareRemoteAuthTest001
1134  * @tc.desc: test PrepareRemoteAuth.
1135  * @tc.type: FUNC
1136  * @tc.require:
1137  */
1138 HWTEST_F(AccountIAMClientTest, PrepareRemoteAuthTest001, TestSize.Level0)
1139 {
1140     int32_t ret = AccountIAMClient::GetInstance().PrepareRemoteAuth("testString", nullptr);
1141     EXPECT_EQ(ret, ERR_ACCOUNT_COMMON_NULL_PTR_ERROR);
1142 }
1143 
1144 /**
1145  * @tc.name: AccountIAMClient_AuthUser_0300
1146  * @tc.desc: Auth user.
1147  * @tc.type: FUNC
1148  * @tc.require:
1149  */
1150 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0300, TestSize.Level0)
1151 {
1152     auto callback = std::make_shared<MockIDMCallback>();
1153     EXPECT_NE(callback, nullptr);
1154     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
1155     auto testCallback = std::make_shared<TestIDMCallback>(callback);
1156     AuthOptions authOptions;
1157 
1158     authOptions.hasRemoteAuthOptions = true;
1159 
1160     AccountIAMClient::GetInstance().AuthUser(
1161         authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
1162     {
1163         std::unique_lock<std::mutex> lock(testCallback->mutex);
1164         testCallback->cv.wait_for(
__anon438d7b4c1b02() 1165             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1166     }
1167 }
1168 
1169 /**
1170  * @tc.name: AccountIAMClient_AuthUser_0400
1171  * @tc.desc: Auth user.
1172  * @tc.type: FUNC
1173  * @tc.require:
1174  */
1175 HWTEST_F(AccountIAMClientTest, AccountIAMClient_AuthUser_0400, TestSize.Level0)
1176 {
1177     auto callback = std::make_shared<MockIDMCallback>();
1178     EXPECT_NE(callback, nullptr);
1179     EXPECT_CALL(*callback, OnResult(_, _)).Times(Exactly(1));
1180     auto testCallback = std::make_shared<TestIDMCallback>(callback);
1181     AuthOptions authOptions;
1182 
1183     authOptions.hasRemoteAuthOptions = true;
1184     authOptions.remoteAuthOptions.hasVerifierNetworkId = true;
1185     authOptions.remoteAuthOptions.verifierNetworkId = "testVerifierNetworkId";
1186     authOptions.remoteAuthOptions.hasCollectorNetworkId = true;
1187     authOptions.remoteAuthOptions.collectorNetworkId = "testCollectorNetworkId";
1188     authOptions.remoteAuthOptions.hasCollectorTokenId = true;
1189     authOptions.remoteAuthOptions.collectorTokenId = 0;
1190 
1191     AccountIAMClient::GetInstance().AuthUser(
1192         authOptions, TEST_CHALLENGE, AuthType::PIN, AuthTrustLevel::ATL1, testCallback);
1193     {
1194         std::unique_lock<std::mutex> lock(testCallback->mutex);
1195         testCallback->cv.wait_for(
__anon438d7b4c1c02() 1196             lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
1197     }
1198 }
1199 
1200 /**
1201  * @tc.name: ResetAccountIAMProxy001
1202  * @tc.desc: test ResetAccountIAMProxy.
1203  * @tc.type: FUNC
1204  * @tc.require:
1205  */
1206 HWTEST_F(AccountIAMClientTest, ResetAccountIAMProxy001, TestSize.Level0)
1207 {
1208     wptr<IRemoteObject> remote;
1209     sptr<IAccountIAM> proxy = AccountIAMClient::GetInstance().proxy_;
1210     AccountIAMClient::GetInstance().proxy_ = nullptr;
1211     AccountIAMClient::GetInstance().ResetAccountIAMProxy(remote);
1212     sptr<IAccountIAM> testIAccountIAM = new (std::nothrow) AccountIAMMgrProxy(nullptr);
1213     AccountIAMClient::GetInstance().proxy_ = testIAccountIAM;
1214     EXPECT_NE(AccountIAMClient::GetInstance().proxy_, nullptr);
1215     AccountIAMClient::GetInstance().ResetAccountIAMProxy(remote);
1216     AccountIAMClient::GetInstance().proxy_ = proxy;
1217 }
1218 }  // namespace AccountTest
1219 }  // namespace OHOS