1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <gmock/gmock.h>
16 #include <gtest/gtest.h>
17 #include "accesstoken_kit.h"
18 #define private public
19 #include "account_iam_callback.h"
20 #undef private
21 #include "account_iam_callback_stub.h"
22 #include "account_iam_client.h"
23 #include "account_log_wrapper.h"
24 #include "domain_account_client.h"
25 #include "inner_account_iam_manager.h"
26 #include "ipc_skeleton.h"
27 #include "iremote_stub.h"
28 #include "mock_domain_plugin.h"
29 #include "os_account_info.h"
30 #include "os_account_manager.h"
31 #include "token_setproc.h"
32 
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::AccountSA;
36 using namespace OHOS::UserIam::UserAuth;
37 using namespace OHOS::Security::AccessToken;
38 namespace OHOS {
39 namespace AccountTest {
40 namespace {
41 const int32_t DEFAULT_USER_ID = 100;
42 const int32_t TEST_USER_ID = 200;
43 const int32_t TEST_MODULE = 5;
44 const int32_t TEST_ACQUIRE_INFO = 10;
45 #ifdef DOMAIN_ACCOUNT_TEST_CASE
46 const int32_t INFO_LIST_SIZE_ONE = 1;
47 const int32_t INFO_LIST_SIZE_ZERO = 0;
48 const int32_t WAIT_TIME = 20;
49 #endif // DOMAIN_ACCOUNT_TEST_CASE
50 const static AccessTokenID g_accountMgrTokenID = AccessTokenKit::GetNativeTokenId("accountmgr");
51 } // namespace
52 
53 #ifdef HAS_PIN_AUTH_PART
54 class MockIInputer final : public IInputer {
55 public:
~MockIInputer()56     virtual ~MockIInputer() {}
OnGetData(int32_t authSubType,std::vector<uint8_t> challenge,std::shared_ptr<IInputerData> inputerData)57     void OnGetData(int32_t authSubType, std::vector<uint8_t> challenge,
58         std::shared_ptr<IInputerData> inputerData) override
59     {
60         return;
61     }
62 };
63 #endif
64 
65 class MockIIDMCallback : public IDMCallbackStub {
66 public:
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)67     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
68     {
69         module_ = module;
70         acquireInfo_ = acquireInfo;
71         return;
72     }
OnResult(int32_t result,const Attributes & extraInfo)73     void OnResult(int32_t result, const Attributes &extraInfo) override
74     {
75         result_ = result;
76         return;
77     }
78 
79 public:
80     int32_t result_ = -1;
81     int32_t module_ = 0;
82     uint32_t acquireInfo_ = 0;
83 };
84 class MockGetCredInfoCallback {
85 public:
86     MOCK_METHOD1(OnResult, void(int32_t result));
87 };
88 
89 class TestGetCredInfoCallback final : public GetCredInfoCallback {
90 public:
TestGetCredInfoCallback(const std::shared_ptr<MockGetCredInfoCallback> & callback)91     explicit TestGetCredInfoCallback(const std::shared_ptr<MockGetCredInfoCallback> &callback) : callback_(callback)
92     {}
OnCredentialInfo(int32_t result,const std::vector<CredentialInfo> & infoList)93     void OnCredentialInfo(int32_t result, const std::vector<CredentialInfo> &infoList)
94     {
95         int infoListSize = infoList.size();
96         callback_->OnResult(infoListSize);
97         std::unique_lock<std::mutex> lock(mutex);
98         isReady = true;
99         cv.notify_one();
100         return;
101     }
102     std::condition_variable cv;
103     bool isReady = false;
104     std::mutex mutex;
105 private:
106     std::shared_ptr<MockGetCredInfoCallback> callback_;
107 };
108 
109 class AccountIamCallbackTest : public testing::Test {
110 public:
111     static void SetUpTestCase(void);
112     static void TearDownTestCase(void);
113     void SetUp(void) override;
114     void TearDown(void) override;
115 };
116 
SetUpTestCase(void)117 void AccountIamCallbackTest::SetUpTestCase(void)
118 {
119     SetSelfTokenID(g_accountMgrTokenID);
120 }
121 
TearDownTestCase(void)122 void AccountIamCallbackTest::TearDownTestCase(void)
123 {}
124 
SetUp(void)125 void AccountIamCallbackTest::SetUp(void) __attribute__((no_sanitize("cfi")))
126 {
127     testing::UnitTest *test = testing::UnitTest::GetInstance();
128     ASSERT_NE(test, nullptr);
129     const testing::TestInfo *testinfo = test->current_test_info();
130     ASSERT_NE(testinfo, nullptr);
131     string testCaseName = string(testinfo->name());
132     ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
133 }
134 
TearDown(void)135 void AccountIamCallbackTest::TearDown(void)
136 {}
137 
138 /**
139  * @tc.name: AuthCallback_OnResult_0100
140  * @tc.desc: OnResult with nullptr.
141  * @tc.type: FUNC
142  * @tc.require:
143  */
144 HWTEST_F(AccountIamCallbackTest, AuthCallback_OnResult_0100, TestSize.Level0)
145 {
146     auto userAuthCallback = std::make_shared<AuthCallback>(
147         TEST_USER_ID, AuthType::PIN, AccountSA::AuthIntent::DEFAULT, nullptr);
148     EXPECT_TRUE(userAuthCallback->innerCallback_ == nullptr);
149     Attributes extraInfo;
150     userAuthCallback->OnResult(0, extraInfo);
151 }
152 
153 /**
154  * @tc.name: AuthCallback_OnResult_0200
155  * @tc.desc: OnResult test with PIN.
156  * @tc.type: FUNC
157  * @tc.require:
158  */
159 HWTEST_F(AccountIamCallbackTest, AuthCallback_OnResult_0200, TestSize.Level0)
160 {
161     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(DEFAULT_USER_ID, "com.ohos.settings", 0);
162     SetSelfTokenID(tokenId);
163     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
164     auto userAuthCallback = std::make_shared<AuthCallback>(
165         TEST_USER_ID, AuthType::PIN, AccountSA::AuthIntent::DEFAULT, callback);
166     EXPECT_TRUE(userAuthCallback->innerCallback_ != nullptr);
167     Attributes extraInfo;
168     int32_t errCode = 0;
169     userAuthCallback->OnResult(errCode, extraInfo);
170     EXPECT_EQ(ResultCode::FAIL, callback->result_);
171     errCode = 10; // result != 0
172     userAuthCallback->OnResult(errCode, extraInfo);
173     EXPECT_EQ(errCode, callback->result_);
174     SetSelfTokenID(g_accountMgrTokenID);
175 }
176 
177 /**
178  * @tc.name: AuthCallback_OnResult_0300
179  * @tc.desc: OnResult test with not PIN.
180  * @tc.type: FUNC
181  * @tc.require:
182  */
183 HWTEST_F(AccountIamCallbackTest, AuthCallback_OnResult_0300, TestSize.Level0)
184 {
185     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
186     auto userAuthCallback = std::make_shared<AuthCallback>(
187         TEST_USER_ID, AuthType::FACE, AccountSA::AuthIntent::DEFAULT, callback);
188     EXPECT_TRUE(userAuthCallback->innerCallback_ != nullptr);
189     Attributes extraInfo;
190     int32_t errCode = 1;
191     userAuthCallback->OnResult(errCode, extraInfo);
192     EXPECT_EQ(errCode, callback->result_);
193     errCode = 10; // result != 0 && authType_ != AuthType::PIN
194     userAuthCallback->OnResult(errCode, extraInfo);
195     EXPECT_EQ(errCode, callback->result_);
196 }
197 
198 /**
199  * @tc.name: AuthCallback_OnAcquireInfo_0100
200  * @tc.desc: OnAcquireInfo with nullptr.
201  * @tc.type: FUNC
202  * @tc.require:
203  */
204 HWTEST_F(AccountIamCallbackTest, AuthCallback_OnAcquireInfo_0100, TestSize.Level0)
205 {
206     auto userAuthCallback = std::make_shared<AuthCallback>(
207         TEST_USER_ID, AuthType::PIN, AccountSA::AuthIntent::DEFAULT, nullptr);
208     EXPECT_TRUE(userAuthCallback->innerCallback_ == nullptr);
209     Attributes extraInfo;
210     userAuthCallback->OnAcquireInfo(0, 0, extraInfo);
211 }
212 
213 #ifdef HAS_PIN_AUTH_PART
214 /**
215  * @tc.name: AuthCallback_OnAcquireInfo_0200
216  * @tc.desc: OnAcquireInfo with not nullptr.
217  * @tc.type: FUNC
218  * @tc.require:
219  */
220 HWTEST_F(AccountIamCallbackTest, AuthCallback_OnAcquireInfo_0200, TestSize.Level0)
221 {
222     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
223     auto userAuthCallback = std::make_shared<AuthCallback>(
224         TEST_USER_ID, AuthType::PIN, AccountSA::AuthIntent::DEFAULT, callback);
225     EXPECT_TRUE(userAuthCallback->innerCallback_ != nullptr);
226     Attributes extraInfo;
227     userAuthCallback->OnAcquireInfo(TEST_MODULE, TEST_ACQUIRE_INFO, extraInfo);
228     EXPECT_EQ(TEST_MODULE, callback->module_);
229     EXPECT_EQ(TEST_ACQUIRE_INFO, callback->acquireInfo_);
230 }
231 #endif
232 
233 /**
234  * @tc.name: AddCredCallback_OnResult_0100
235  * @tc.desc: OnResult with nullptr.
236  * @tc.type: FUNC
237  * @tc.require:
238  */
239 HWTEST_F(AccountIamCallbackTest, AddCredCallback_OnResult_0100, TestSize.Level0)
240 {
241     CredentialParameters credInfo = {};
242     Attributes extraInfo;
243     auto addCredCallback = std::make_shared<AddCredCallback>(TEST_USER_ID, credInfo, nullptr);
244     EXPECT_TRUE(addCredCallback->innerCallback_ == nullptr);
245     addCredCallback->OnResult(0, extraInfo);
246 }
247 
248 /**
249  * @tc.name: AddCredCallback_OnResult_0200
250  * @tc.desc: OnResult with PIN.
251  * @tc.type: FUNC
252  * @tc.require:
253  */
254 HWTEST_F(AccountIamCallbackTest, AddCredCallback_OnResult_0200, TestSize.Level0)
255 {
256     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
257     CredentialParameters credInfo = {};
258     credInfo.authType = AuthType::PIN;
259     Attributes extraInfo;
260     auto addCredCallback = std::make_shared<AddCredCallback>(TEST_USER_ID, credInfo, callback);
261     EXPECT_TRUE(addCredCallback->innerCallback_ != nullptr);
262     int32_t errCode = 0;
263     addCredCallback->OnResult(errCode, extraInfo);
264     EXPECT_EQ(errCode, callback->result_);
265     errCode = 10;
266     addCredCallback->OnResult(errCode, extraInfo);
267     EXPECT_EQ(errCode, callback->result_);
268 }
269 
270 /**
271  * @tc.name: AddCredCallback_OnResult_0300
272  * @tc.desc: OnResult with not PIN.
273  * @tc.type: FUNC
274  * @tc.require:
275  */
276 HWTEST_F(AccountIamCallbackTest, AddCredCallback_OnResult_0300, TestSize.Level0)
277 {
278     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
279     CredentialParameters credInfo = {};
280     credInfo.authType = AuthType::FACE;
281     Attributes extraInfo;
282     auto addCredCallback = std::make_shared<AddCredCallback>(TEST_USER_ID, credInfo, callback);
283     EXPECT_TRUE(addCredCallback->innerCallback_ != nullptr);
284     int32_t errCode = 0;
285     addCredCallback->OnResult(errCode, extraInfo);
286     EXPECT_EQ(errCode, callback->result_);
287     errCode = 10;
288     addCredCallback->OnResult(errCode, extraInfo);
289     EXPECT_EQ(errCode, callback->result_);
290 }
291 
292 /**
293  * @tc.name: AddCredCallback_OnAcquireInfo_0100
294  * @tc.desc: OnAcquireInfo with nullptr.
295  * @tc.type: FUNC
296  * @tc.require:
297  */
298 HWTEST_F(AccountIamCallbackTest, AddCredCallback_OnAcquireInfo_0100, TestSize.Level0)
299 {
300     CredentialParameters credInfo = {};
301     Attributes extraInfo;
302     auto addCredCallback = std::make_shared<AddCredCallback>(TEST_USER_ID, credInfo, nullptr);
303     EXPECT_TRUE(addCredCallback->innerCallback_ == nullptr);
304     addCredCallback->OnAcquireInfo(0, 0, extraInfo);
305 }
306 
307 /**
308  * @tc.name: AddCredCallback_OnAcquireInfo_0200
309  * @tc.desc: OnAcquireInfo with not nullptr.
310  * @tc.type: FUNC
311  * @tc.require:
312  */
313 HWTEST_F(AccountIamCallbackTest, AddCredCallback_OnAcquireInfo_0200, TestSize.Level0)
314 {
315     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
316     CredentialParameters credInfo = {};
317     Attributes extraInfo;
318     auto addCredCallback = std::make_shared<AddCredCallback>(TEST_USER_ID, credInfo, callback);
319     EXPECT_TRUE(addCredCallback->innerCallback_ != nullptr);
320     addCredCallback->OnAcquireInfo(TEST_MODULE, TEST_ACQUIRE_INFO, extraInfo);
321     EXPECT_EQ(TEST_MODULE, callback->module_);
322     EXPECT_EQ(TEST_ACQUIRE_INFO, callback->acquireInfo_);
323 }
324 
325 /**
326  * @tc.name: DelCredCallback_OnResult_0100
327  * @tc.desc: OnResult with nullptr.
328  * @tc.type: FUNC
329  * @tc.require:
330  */
331 HWTEST_F(AccountIamCallbackTest, DelCredCallback_OnResult_0100, TestSize.Level0)
332 {
333     Attributes extraInfo;
334     std::vector<uint8_t> token;
335     auto delCredCallback = std::make_shared<DelCredCallback>(TEST_USER_ID, false, token, nullptr);
336     EXPECT_TRUE(delCredCallback->innerCallback_ == nullptr);
337     delCredCallback->OnResult(0, extraInfo);
338 }
339 
340 /**
341  * @tc.name: DelCredCallback_OnResult_0300
342  * @tc.desc: OnResult with not PIN.
343  * @tc.type: FUNC
344  * @tc.require:
345  */
346 HWTEST_F(AccountIamCallbackTest, DelCredCallback_OnResult_0300, TestSize.Level0)
347 {
348     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
349     Attributes extraInfo;
350     std::vector<uint8_t> token;
351     auto delCredCallback = std::make_shared<DelCredCallback>(TEST_USER_ID, false, token, callback);
352     EXPECT_TRUE(delCredCallback->innerCallback_ != nullptr);
353     IAMState state = InnerAccountIAMManager::GetInstance().GetState(TEST_USER_ID);
354     InnerAccountIAMManager::GetInstance().SetState(TEST_USER_ID, IDLE);
355     int32_t errCode = 0;
356     delCredCallback->OnResult(errCode, extraInfo);
357     EXPECT_EQ(errCode, callback->result_);
358     errCode = 10;
359     delCredCallback->OnResult(errCode, extraInfo);
360     EXPECT_EQ(errCode, callback->result_);
361     InnerAccountIAMManager::GetInstance().SetState(TEST_USER_ID, state);
362 }
363 
364 /**
365  * @tc.name: DelCredCallback_OnAcquireInfo_0100
366  * @tc.desc: OnAcquireInfo with nullptr.
367  * @tc.type: FUNC
368  * @tc.require:
369  */
370 HWTEST_F(AccountIamCallbackTest, DelCredCallback_OnAcquireInfo_0100, TestSize.Level0)
371 {
372     Attributes extraInfo;
373     std::vector<uint8_t> token;
374     auto delCredCallback = std::make_shared<DelCredCallback>(TEST_USER_ID, false, token, nullptr);
375     EXPECT_TRUE(delCredCallback->innerCallback_ == nullptr);
376     delCredCallback->OnAcquireInfo(0, 0, extraInfo);
377 }
378 
379 /**
380  * @tc.name: DelCredCallback_OnAcquireInfo_0200
381  * @tc.desc: OnAcquireInfo with not nullptr.
382  * @tc.type: FUNC
383  * @tc.require:
384  */
385 HWTEST_F(AccountIamCallbackTest, DelCredCallback_OnAcquireInfo_0200, TestSize.Level0)
386 {
387     sptr<MockIIDMCallback> callback = new (std::nothrow) MockIIDMCallback();
388     Attributes extraInfo;
389     std::vector<uint8_t> token;
390     auto delCredCallback = std::make_shared<DelCredCallback>(TEST_USER_ID, false, token, callback);
391     EXPECT_TRUE(delCredCallback->innerCallback_ != nullptr);
392     delCredCallback->OnAcquireInfo(TEST_MODULE, TEST_ACQUIRE_INFO, extraInfo);
393     EXPECT_EQ(TEST_MODULE, callback->module_);
394     EXPECT_EQ(TEST_ACQUIRE_INFO, callback->acquireInfo_);
395 }
396 
397 /**
398  * @tc.name: GetCredInfoCallbackWrapper_OnCredentialInfo_0100
399  * @tc.desc: OnCredentialInfo with nullptr.
400  * @tc.type: FUNC
401  * @tc.require:
402  */
403 HWTEST_F(AccountIamCallbackTest, GetCredInfoCallbackWrapper_OnCredentialInfo_0100, TestSize.Level0)
404 {
405     auto getCredInfoCallback = std::make_shared<GetCredInfoCallbackWrapper>(0, 0, nullptr);
406     EXPECT_TRUE(getCredInfoCallback->innerCallback_ == nullptr);
407     std::vector<CredentialInfo> infoList;
408     getCredInfoCallback->OnCredentialInfo(infoList);
409 }
410 
411 /**
412  * @tc.name: GetPropCallbackWrapper_OnResult_0100
413  * @tc.desc: OnResult with nullptr.
414  * @tc.type: FUNC
415  * @tc.require:
416  */
417 HWTEST_F(AccountIamCallbackTest, GetPropCallbackWrapper_OnResult_0100, TestSize.Level0)
418 {
419     Attributes extraInfo;
420     auto getPropCallback = std::make_shared<GetPropCallbackWrapper>(DEFAULT_USER_ID, nullptr);
421     EXPECT_TRUE(getPropCallback->innerCallback_ == nullptr);
422     getPropCallback->OnResult(0, extraInfo);
423 }
424 
425 /**
426  * @tc.name: GetCredInfoCallbackWrapper_OnCredentialInfo_0200
427  * @tc.desc: OnCredentialInfo with domain auth plugin not available.
428  * @tc.type: FUNC
429  * @tc.require: issuesI64KAM
430  */
431 #ifdef ENABLE_MULTIPLE_OS_ACCOUNTS
432 #ifdef DOMAIN_ACCOUNT_TEST_CASE
433 HWTEST_F(AccountIamCallbackTest, GetCredInfoCallbackWrapper_OnCredentialInfo_0200, TestSize.Level0)
434 {
435     DomainAccountInfo domainInfo;
436     domainInfo.accountName_ = "zhangsan";
437     domainInfo.domain_ = "china.example.com";
438     OsAccountInfo accountInfo;
439     std::vector<CredentialInfo> infoList = {};
440     ErrCode errCode = OsAccountManager::CreateOsAccountForDomain(OsAccountType::NORMAL, domainInfo, accountInfo);
441     EXPECT_EQ(errCode, ERR_OK);
442     int32_t userId = accountInfo.GetLocalId();
443     std::shared_ptr<MockGetCredInfoCallback> callback = std::make_shared<MockGetCredInfoCallback>();
444     ASSERT_NE(callback, nullptr);
445     std::shared_ptr<TestGetCredInfoCallback> testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
446     ASSERT_NE(testCallback, nullptr);
447     EXPECT_CALL(*callback, OnResult(INFO_LIST_SIZE_ZERO)).Times(1);
448     AccountIAMClient::GetInstance().GetCredentialInfo(userId, AuthType::ALL, testCallback);
449     std::unique_lock<std::mutex> lock(testCallback->mutex);
450     testCallback->cv.wait_for(
__anon3f898c880202() 451         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
452     EXPECT_EQ(OsAccountManager::RemoveOsAccount(accountInfo.GetLocalId()), ERR_OK);
453 }
454 
455 /**
456  * @tc.name: GetCredInfoCallbackWrapper_OnCredentialInfo_0300
457  * @tc.desc: OnCredentialInfo with domain auth plugin available.
458  * @tc.type: FUNC
459  * @tc.require: issuesI64KAM
460  */
461 HWTEST_F(AccountIamCallbackTest, GetCredInfoCallbackWrapper_OnCredentialInfo_0300, TestSize.Level0)
462 {
463     DomainAccountInfo domainInfo;
464     domainInfo.accountName_ = "lisi111";
465     domainInfo.domain_ = "china.example.com";
466     OsAccountInfo accountInfo;
467     ErrCode errCode = OsAccountManager::CreateOsAccountForDomain(OsAccountType::NORMAL, domainInfo, accountInfo);
468     EXPECT_EQ(errCode, ERR_OK);
469     int32_t userId = accountInfo.GetLocalId();
470     std::shared_ptr<MockDomainPlugin> g_plugin = std::make_shared<MockDomainPlugin>();
471     ASSERT_NE(g_plugin, nullptr);
472     ASSERT_EQ(DomainAccountClient::GetInstance().RegisterPlugin(g_plugin), ERR_OK);
473     std::shared_ptr<MockGetCredInfoCallback> callback = std::make_shared<MockGetCredInfoCallback>();
474     ASSERT_NE(callback, nullptr);
475     std::shared_ptr<TestGetCredInfoCallback> testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
476     ASSERT_NE(testCallback, nullptr);
477     EXPECT_CALL(*callback, OnResult(INFO_LIST_SIZE_ONE)).Times(Exactly(1));
478     AccountIAMClient::GetInstance().GetCredentialInfo(userId, AuthType::ALL, testCallback);
479     std::unique_lock<std::mutex> lock(testCallback->mutex);
480     testCallback->cv.wait_for(
__anon3f898c880302() 481         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
482     EXPECT_EQ(OsAccountManager::RemoveOsAccount(accountInfo.GetLocalId()), ERR_OK);
483     ASSERT_EQ(DomainAccountClient::GetInstance().UnregisterPlugin(), ERR_OK);
484 }
485 
486 /**
487  * @tc.name: GetCredInfoCallbackWrapper_OnCredentialInfo_0400
488  * @tc.desc: OnCredentialInfo with not domain authtype.
489  * @tc.type: FUNC
490  * @tc.require: issuesI64KAM
491  */
492 HWTEST_F(AccountIamCallbackTest, GetCredInfoCallbackWrapper_OnCredentialInfo_0400, TestSize.Level0)
493 {
494     DomainAccountInfo domainInfo;
495     domainInfo.accountName_ = "lisi11";
496     domainInfo.domain_ = "chin.example.com";
497     OsAccountInfo accountInfo;
498     ErrCode errCode = OsAccountManager::CreateOsAccountForDomain(OsAccountType::NORMAL, domainInfo, accountInfo);
499     EXPECT_EQ(errCode, ERR_OK);
500     int32_t userId = accountInfo.GetLocalId();
501     std::shared_ptr<MockDomainPlugin> g_plugin = std::make_shared<MockDomainPlugin>();
502     ASSERT_EQ(DomainAccountClient::GetInstance().RegisterPlugin(g_plugin), ERR_OK);
503     std::shared_ptr<MockGetCredInfoCallback> callback = std::make_shared<MockGetCredInfoCallback>();
504     ASSERT_NE(callback, nullptr);
505     std::shared_ptr<TestGetCredInfoCallback> testCallback = std::make_shared<TestGetCredInfoCallback>(callback);
506     ASSERT_NE(testCallback, nullptr);
507     EXPECT_CALL(*callback, OnResult(INFO_LIST_SIZE_ZERO)).Times(Exactly(1));
508     AccountIAMClient::GetInstance().GetCredentialInfo(userId, AuthType::PIN, testCallback);
509     std::unique_lock<std::mutex> lock(testCallback->mutex);
510     testCallback->cv.wait_for(
__anon3f898c880402() 511         lock, std::chrono::seconds(WAIT_TIME), [lockCallback = testCallback]() { return lockCallback->isReady; });
512     EXPECT_EQ(OsAccountManager::RemoveOsAccount(accountInfo.GetLocalId()), ERR_OK);
513     ASSERT_EQ(DomainAccountClient::GetInstance().UnregisterPlugin(), ERR_OK);
514 }
515 #endif // DOMAIN_ACCOUNT_TEST_CASE
516 #endif // ENABLE_MULTIPLE_OS_ACCOUNTS
517 /**
518  * @tc.name: SetPropCallbackWrapper_OnResult_0100
519  * @tc.desc: OnResult with nullptr.
520  * @tc.type: FUNC
521  * @tc.require:
522  */
523 HWTEST_F(AccountIamCallbackTest, SetPropCallbackWrapper_OnResult_0100, TestSize.Level0)
524 {
525     Attributes extraInfo;
526     auto setPropCallback = std::make_shared<SetPropCallbackWrapper>(DEFAULT_USER_ID, nullptr);
527     EXPECT_TRUE(setPropCallback->innerCallback_ == nullptr);
528     setPropCallback->OnResult(0, extraInfo);
529 }
530 } // namespace AccountTest
531 } // namespace OHOS