1 /*
2 * Copyright (c) 2024-2025 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_hichain.c"
22 #include "auth_hichain_deps_mock.h"
23 #include "softbus_error_code.h"
24 #include "auth_session_json.c"
25 #include "auth_hichain_adapter.c"
26
27 namespace OHOS {
28 using namespace testing;
29 using namespace testing::ext;
30
31 constexpr int64_t TEST_AUTH_SEQ = 1;
32 constexpr int OPERATION_CODE = 100;
33 constexpr uint32_t TMP_DATA_LEN = 10;
34 constexpr uint8_t TMP_DATA[TMP_DATA_LEN] = "tmpInData";
35 static constexpr int32_t DEFALUT_USERID = 100;
36
37 class AuthHichainMockTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void AuthHichainMockTest::SetUpTestCase() {}
46
TearDownTestCase()47 void AuthHichainMockTest::TearDownTestCase() {}
48
SetUp()49 void AuthHichainMockTest::SetUp() {}
50
TearDown()51 void AuthHichainMockTest::TearDown() {}
52
53 /*
54 * @tc.name: GEN_DEVICE_LEVEL_PARAM_TEST_001
55 * @tc.desc: GenDeviceLevelParam test
56 * @tc.type: FUNC
57 * @tc.require:
58 */
59 HWTEST_F(AuthHichainMockTest, GEN_DEVICE_LEVEL_PARAM_TEST_001, TestSize.Level1)
60 {
61 AuthHichainInterfaceMock hichainMock;
62 HiChainAuthParam hiChainParam = {};
63 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
64 if (msg == nullptr) {
65 return;
66 }
67 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg));
68 const char *udid = "123456";
69 const char *uid = "123";
70 if (strcpy_s(hiChainParam.udid, UDID_BUF_LEN, (char *)udid) != EOK ||
71 strcpy_s(hiChainParam.uid, MAX_ACCOUNT_HASH_LEN, (char *)uid) != EOK) {
72 return;
73 }
74 hiChainParam.userId = DEFALUT_USERID;
75 static char *ptr = GenDeviceLevelParam(&hiChainParam);
76 EXPECT_EQ(ptr, nullptr);
77 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
78 ptr = GenDeviceLevelParam(&hiChainParam);
79 EXPECT_EQ(ptr, nullptr);
80 cJSON *msg1 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
81 if (msg1 == nullptr) {
82 return;
83 }
84 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(msg1));
85 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillRepeatedly(Return(true));
86 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
87 EXPECT_CALL(hichainMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr));
88 ptr = GenDeviceLevelParam(&hiChainParam);
89 EXPECT_EQ(ptr, nullptr);
90 }
91
92 /*
93 * @tc.name: ON_TRANSMIT_TEST_001
94 * @tc.desc: OnTransmit test
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(AuthHichainMockTest, ON_TRANSMIT_TEST_001, TestSize.Level1)
99 {
100 AuthHichainInterfaceMock hichainMock;
101 EXPECT_CALL(hichainMock, AuthSessionPostAuthData).WillOnce(Return(SOFTBUS_INVALID_PARAM))
102 .WillRepeatedly(Return(SOFTBUS_OK));
103 int64_t authSeq = TEST_AUTH_SEQ;
104 const uint8_t *data = reinterpret_cast<const unsigned char *>(TMP_DATA);
105 uint32_t len = TMP_DATA_LEN;
106 bool ret = OnTransmit(authSeq, data, len);
107 EXPECT_EQ(ret, false);
108 ret = OnTransmit(authSeq, data, len);
109 EXPECT_EQ(ret, true);
110 }
111
112 /*
113 * @tc.name: GET_DEVICE_SIDE_FLAG_TEST_001
114 * @tc.desc: GetDeviceSideFlag test
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(AuthHichainMockTest, GET_DEVICE_SIDE_FLAG_TEST_001, TestSize.Level1)
119 {
120 AuthHichainInterfaceMock hichainMock;
121 void *para = reinterpret_cast<void *>(SoftBusCalloc(sizeof(ProofInfo)));
122 if (para == nullptr) {
123 return;
124 }
125 EXPECT_CALL(hichainMock, AuthFailNotifyProofInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
126 .WillRepeatedly(Return(SOFTBUS_OK));
127 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(nullptr));
128 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(para));
129 void *para1 = reinterpret_cast<void *>(SoftBusCalloc(sizeof(ProofInfo)));
130 if (para1 == nullptr) {
131 return;
132 }
133 EXPECT_NO_FATAL_FAILURE(ProcessAuthFailCallBack(para1));
134 AuthFsm authFsm;
135 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
136 EXPECT_CALL(hichainMock, GetAuthFsmByAuthSeq).WillOnce(Return(nullptr))
137 .WillRepeatedly(Return(&authFsm));
138 const char *side = "server";
139 EXPECT_CALL(hichainMock, GetAuthSideStr).WillRepeatedly(Return(side));
140 EXPECT_CALL(hichainMock, RequireAuthLock).WillOnce(Return(false))
141 .WillRepeatedly(Return(true));
142 EXPECT_CALL(hichainMock, ReleaseAuthLock).WillRepeatedly(Return());
143 int64_t authSeq = TEST_AUTH_SEQ;
144 bool flag;
145 int32_t ret = GetDeviceSideFlag(authSeq, &flag);
146 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
147 ret = GetDeviceSideFlag(authSeq, &flag);
148 EXPECT_EQ(ret, SOFTBUS_AUTH_NOT_FOUND);
149 ret = GetDeviceSideFlag(authSeq, &flag);
150 EXPECT_EQ(ret, SOFTBUS_OK);
151 }
152
153 /*
154 * @tc.name: CHECK_ERR_RETURN_VALIDITY_TEST_001
155 * @tc.desc: CheckErrReturnValidity test
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(AuthHichainMockTest, CHECK_ERR_RETURN_VALIDITY_TEST_001, TestSize.Level1)
160 {
161 AuthHichainInterfaceMock hichainMock;
162 EXPECT_CALL(hichainMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
163 EXPECT_CALL(hichainMock, RequireAuthLock).WillRepeatedly(Return(true));
164 EXPECT_CALL(hichainMock, ReleaseAuthLock).WillRepeatedly(Return());
165 const char *errorReturn = "errorReturnTest";
166 int32_t ret = CheckErrReturnValidity(errorReturn);
167 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
168 ret = CheckErrReturnValidity(errorReturn);
169 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
170 int errCode = PC_AUTH_ERRCODE;
171 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, nullptr));
172 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
173 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
174 errCode = PC_PROOF_NON_CONSISTENT_ERRCODE;
175 EXPECT_NO_FATAL_FAILURE(NotifyPcAuthFail(TEST_AUTH_SEQ, errCode, errorReturn));
176 }
177
178 /*
179 * @tc.name: ON_REQUEST_TEST_001
180 * @tc.desc: OnRequest test
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184 HWTEST_F(AuthHichainMockTest, ON_REQUEST_TEST_001, TestSize.Level1)
185 {
186 int64_t authSeq = TEST_AUTH_SEQ - 1;
187 const char *reqParams = "reqParams";
188 AuthHichainInterfaceMock hichainMock;
189 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
190 if (msg == nullptr) {
191 return;
192 }
193 cJSON *msg1 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
194 if (msg1 == nullptr) {
195 SoftBusFree(msg);
196 return;
197 }
198 cJSON *msg2 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
199 if (msg2 == nullptr) {
200 SoftBusFree(msg);
201 SoftBusFree(msg1);
202 return;
203 }
204 EXPECT_CALL(hichainMock, AuthSessionGetUdid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
205 .WillRepeatedly(Return(SOFTBUS_OK));
206 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
207 char *ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
208 EXPECT_EQ(ptr, nullptr);
209 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr)).WillOnce(Return(msg))
210 .WillOnce(Return(msg1)).WillOnce(Return(msg2));
211
212 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
213 EXPECT_EQ(ptr, nullptr);
214 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
215 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
216 EXPECT_EQ(ptr, nullptr);
217 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
218 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
219 EXPECT_EQ(ptr, nullptr);
220 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
221 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
222 EXPECT_EQ(ptr, nullptr);
223 }
224
225 /*
226 * @tc.name: ON_REQUEST_TEST_002
227 * @tc.desc: OnRequest test
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(AuthHichainMockTest, ON_REQUEST_TEST_002, TestSize.Level1)
232 {
233 int64_t authSeq = TEST_AUTH_SEQ;
234 const char *reqParams = "reqParams";
235 AuthHichainInterfaceMock hichainMock;
236 cJSON *msg3 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
237 if (msg3 == nullptr) {
238 return;
239 }
240 cJSON *msg4 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
241 if (msg4 == nullptr) {
242 SoftBusFree(msg3);
243 return;
244 }
245 cJSON *msg5 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
246 if (msg5 == nullptr) {
247 SoftBusFree(msg3);
248 SoftBusFree(msg4);
249 return;
250 }
251
252 cJSON *msg6 = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
253 if (msg6 == nullptr) {
254 SoftBusFree(msg3);
255 SoftBusFree(msg4);
256 SoftBusFree(msg5);
257 return;
258 }
259
260 EXPECT_CALL(hichainMock, AuthSessionGetUdid).WillRepeatedly(Return(SOFTBUS_OK));
261 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
262 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(msg3)).WillOnce(Return(msg4))
263 .WillOnce(Return(msg5)).WillOnce(Return(msg6));
264 EXPECT_CALL(hichainMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
265 EXPECT_CALL(hichainMock, AddStringToJsonObject).WillOnce(Return(true)).WillOnce(Return(true))
266 .WillOnce(Return(true)).WillOnce(Return(false)).WillRepeatedly(Return(true));
267 EXPECT_CALL(hichainMock, AddBoolToJsonObject).WillRepeatedly(Return(true));
268
269 char msgStr[10] = {0};
270 const char *val = "returnStr";
271 EXPECT_EQ(strcpy_s(msgStr, sizeof(msgStr), val), EOK);
272 EXPECT_CALL(hichainMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr)).WillRepeatedly(Return(msgStr));
273 char *ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
274 EXPECT_EQ(ptr, nullptr);
275
276 authSeq = 0;
277 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
278 EXPECT_EQ(ptr, nullptr);
279
280 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
281 EXPECT_EQ(ptr, nullptr);
282
283 ptr = OnRequest(authSeq, OPERATION_CODE, reqParams);
284 EXPECT_NE(ptr, nullptr);
285 }
286
287 /*
288 * @tc.name: GET_UDID_HASH_TEST_001
289 * @tc.desc: GetUdidHash test
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(AuthHichainMockTest, GET_UDID_HASH_TEST_001, TestSize.Level1)
294 {
295 AuthHichainInterfaceMock hichainMock;
296 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
297 .WillRepeatedly(Return(SOFTBUS_OK));
298 EXPECT_CALL(hichainMock, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
299 .WillRepeatedly(Return(SOFTBUS_OK));
300 const char *udid = "udidTest";
301 char udidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
302
303 int32_t ret = GetUdidHash(nullptr, udidHash);
304 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
305 ret = GetUdidHash(udid, nullptr);
306 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
307 ret = GetUdidHash(udid, udidHash);
308 EXPECT_NE(ret, SOFTBUS_OK);
309 ret = GetUdidHash(udid, udidHash);
310 EXPECT_NE(ret, SOFTBUS_OK);
311 ret = GetUdidHash(udid, udidHash);
312 EXPECT_EQ(ret, SOFTBUS_OK);
313 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(nullptr));
314 EXPECT_CALL(hichainMock, GetNodeFromPcRestrictMap).WillOnce(Return(SOFTBUS_INVALID_PARAM))
315 .WillRepeatedly(Return(SOFTBUS_OK));
316 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(udid));
317 EXPECT_CALL(hichainMock, DeleteNodeFromPcRestrictMap).WillRepeatedly(Return());
318 EXPECT_NO_FATAL_FAILURE(DeletePcRestrictNode(udid));
319 }
320
321 /*
322 * @tc.name: HICHAIN_START_AUTH_TEST_001
323 * @tc.desc: HichainStartAuth test
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(AuthHichainMockTest, HICHAIN_START_AUTH_TEST_001, TestSize.Level1)
328 {
329 AuthHichainInterfaceMock hichainMock;
330 HiChainAuthParam hiChainParam = {};
331 EXPECT_CALL(hichainMock, cJSON_CreateObject).WillOnce(Return(nullptr));
332 int64_t authSeq = TEST_AUTH_SEQ;
333 const char *udid = "udidTest";
334 const char *uid = "uidTest";
335 const char *groupInfo = "groupInfoTest";
336
337 if (strcpy_s(hiChainParam.udid, UDID_BUF_LEN, (char *)udid) != EOK ||
338 strcpy_s(hiChainParam.uid, MAX_ACCOUNT_HASH_LEN, (char *)uid) != EOK) {
339 return;
340 }
341 hiChainParam.userId = DEFALUT_USERID;
342 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(hiChainParam.udid, nullptr));
343 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(nullptr, groupInfo));
344 int32_t ret = HichainStartAuth(authSeq, &hiChainParam, HICHAIN_AUTH_DEVICE);
345 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
346 cJSON *msg = reinterpret_cast<cJSON *>(SoftBusCalloc(sizeof(cJSON)));
347 if (msg == nullptr) {
348 return;
349 }
350 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
351 EXPECT_CALL(hichainMock, GetJsonObjectStringItem).WillRepeatedly(Return(true));
352 EXPECT_CALL(hichainMock, GetJsonObjectNumberItem)
353 .WillRepeatedly(DoAll(SetArgPointee<2>(AUTH_IDENTICAL_ACCOUNT_GROUP), Return(true)));
354 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
355 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
356 }
357
358 /*
359 * @tc.name: PACK_EXTERNAL_AUTH_INFO_001
360 * @tc.desc: PackExternalAuthInfo test
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(AuthHichainMockTest, PACK_EXTERNAL_AUTH_INFO_001, TestSize.Level1)
365 {
366 AuthHichainInterfaceMock hichainMock;
367 int32_t ret = SOFTBUS_OK;
368
369 JsonObj *obj = JSON_CreateObject();
370 EXPECT_NE(obj, NULL);
371
372 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
373 .WillRepeatedly(Return(SOFTBUS_OK));
374 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
375 .WillRepeatedly(Return(SOFTBUS_OK));
376 EXPECT_CALL(hichainMock, LnnGetLocalByteInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
377 .WillRepeatedly(Return(SOFTBUS_OK));
378 EXPECT_CALL(hichainMock, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK))
379 .WillOnce(Return(SOFTBUS_OK))
380 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND)).WillRepeatedly(Return(SOFTBUS_OK));
381 EXPECT_CALL(hichainMock, JSON_AddStringToObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
382
383 ret = PackExternalAuthInfo(obj);
384 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
385
386 ret = PackExternalAuthInfo(obj);
387 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
388
389 ret = PackExternalAuthInfo(obj);
390 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
391
392 ret = PackExternalAuthInfo(obj);
393 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
394
395 ret = PackExternalAuthInfo(obj);
396 EXPECT_EQ(ret, SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR);
397
398 ret = PackExternalAuthInfo(obj);
399 EXPECT_EQ(ret, SOFTBUS_OK);
400
401 JSON_Delete(obj);
402 }
403
404 /*
405 * @tc.name: UNPACK_EXTERNAL_AUTH_INFO_001
406 * @tc.desc: UnpackExternalAuthInfo test
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(AuthHichainMockTest, UNPACK_EXTERNAL_AUTH_INFO_001, TestSize.Level1)
411 {
412 AuthHichainInterfaceMock hichainMock;
413 AuthSessionInfo info = { 0 };
414 const char *credID = "1234";
415
416 JsonObj *obj = JSON_CreateObject();
417 EXPECT_NE(obj, NULL);
418
419 EXPECT_CALL(hichainMock, JSON_GetStringFromObject).WillOnce(Return(false)).WillRepeatedly(Return(true));
420 EXPECT_CALL(hichainMock, LnnGetLocalNodeInfoSafe).WillOnce(Return(SOFTBUS_INVALID_PARAM))
421 .WillRepeatedly(Return(SOFTBUS_OK));
422 EXPECT_CALL(hichainMock, LnnGetLocalByteInfo).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
423 .WillRepeatedly(Return(SOFTBUS_OK));
424 EXPECT_CALL(hichainMock, ConvertBytesToHexString).WillRepeatedly(Return(SOFTBUS_OK));
425 EXPECT_CALL(hichainMock, LnnIsDefaultOhosAccount).WillRepeatedly(Return(false));
426 EXPECT_CALL(hichainMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
427 .WillRepeatedly(Return(SOFTBUS_OK));
428 EXPECT_CALL(hichainMock, AuthIdServiceQueryCredential).WillOnce(Return(SOFTBUS_INVALID_PARAM))
429 .WillRepeatedly(Return(SOFTBUS_OK));
430 EXPECT_CALL(hichainMock, IdServiceGetCredIdFromCredList).WillOnce(Return(NULL))
431 .WillRepeatedly(Return((char *)credID));
432 EXPECT_CALL(hichainMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
433 EXPECT_CALL(hichainMock, IdServiceDestroyCredentialList).Times(2);
434
435 UnpackExternalAuthInfo(obj, &info);
436 EXPECT_EQ(info.credId, NULL);
437
438 info.authVersion = (AuthVersion)2; // AUTH_VERSION_V2
439 UnpackExternalAuthInfo(obj, &info);
440 EXPECT_EQ(info.credId, NULL);
441
442 UnpackExternalAuthInfo(obj, &info);
443 EXPECT_EQ(info.credId, NULL);
444
445 UnpackExternalAuthInfo(obj, &info);
446 EXPECT_EQ(info.credId, NULL);
447
448 UnpackExternalAuthInfo(obj, &info);
449 EXPECT_EQ(info.credId, NULL);
450
451 UnpackExternalAuthInfo(obj, &info);
452 EXPECT_EQ(info.credId, NULL);
453
454 UnpackExternalAuthInfo(obj, &info);
455 EXPECT_NE(info.credId, NULL);
456
457 JSON_Delete(obj);
458 }
459 } // namespace OHOS
460