1 /*
2 * Copyright (c) 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_session_json.c"
22 #include "auth_session_json_deps_mock.h"
23 #include "softbus_error_code.h"
24
25 namespace OHOS {
26 using namespace testing;
27 using namespace testing::ext;
28 constexpr int64_t TEST_AUTH_ID = 1;
29 constexpr int32_t KEY_VALUE_LEN = 13;
30 constexpr int32_t TEST_AUTH_PORT = 1;
31 constexpr int32_t TEST_SESSION_PORT = 2;
32 constexpr int32_t TEST_PROXY_PORT = 3;
33 constexpr uint8_t KEY_VALUE[SESSION_KEY_LENGTH] = "123456keytest";
34
35 class AuthSessionJsonMockTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase()43 void AuthSessionJsonMockTest::SetUpTestCase() {}
44
TearDownTestCase()45 void AuthSessionJsonMockTest::TearDownTestCase() {}
46
SetUp()47 void AuthSessionJsonMockTest::SetUp() {}
48
TearDown()49 void AuthSessionJsonMockTest::TearDown() {}
50
51 /*
52 * @tc.name: GET_ENHANCED_P2P_AUTH_KEY_TEST_001
53 * @tc.desc: GetEnhancedP2pAuthKey test
54 * @tc.type: FUNC
55 * @tc.require:
56 */
57 HWTEST_F(AuthSessionJsonMockTest, GET_ENHANCED_P2P_AUTH_KEY_TEST_001, TestSize.Level1)
58 {
59 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
60 EXPECT_CALL(mocker, AuthFindLatestNormalizeKey).WillOnce(Return(SOFTBUS_OK))
61 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
62 EXPECT_CALL(mocker, AuthFindDeviceKey).WillOnce(Return(SOFTBUS_OK))
63 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
64
65 char udidHash[SHA_256_HEX_HASH_LEN] = {0};
66 AuthSessionInfo info = {0};
67 AuthDeviceKeyInfo deviceKey = {0};
68 int32_t ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
69 EXPECT_EQ(ret, SOFTBUS_OK);
70 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
71 EXPECT_EQ(ret, SOFTBUS_OK);
72
73 AuthHandle authHandle = { .authId = TEST_AUTH_ID };
74 EXPECT_CALL(mocker, AuthGetLatestIdByUuid).WillRepeatedly(DoAll(SetArgPointee<3>(authHandle), Return()));
75 AuthManager auth = {0};
76 EXPECT_CALL(mocker, GetAuthManagerByAuthId).WillOnce(Return(nullptr)).WillRepeatedly(Return(&auth));
77 EXPECT_CALL(mocker, DelDupAuthManager).WillRepeatedly(Return());
78 SessionKey sessionKey = { .len = SESSION_KEY_LENGTH };
79 EXPECT_EQ(memcpy_s(sessionKey.value, SESSION_KEY_LENGTH, KEY_VALUE, KEY_VALUE_LEN), EOK);
80 EXPECT_CALL(mocker, GetLatestSessionKey).WillOnce(Return(SOFTBUS_INVALID_PARAM))
81 .WillRepeatedly(DoAll(SetArgPointee<3>(sessionKey), Return(SOFTBUS_OK)));
82
83 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
84 EXPECT_NE(ret, SOFTBUS_OK);
85 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
86 EXPECT_NE(ret, SOFTBUS_OK);
87 ret = GetEnhancedP2pAuthKey(udidHash, &info, &deviceKey);
88 EXPECT_NE(ret, SOFTBUS_OK);
89 }
90
91 /*
92 * @tc.name: PACK_NORMALIZED_KEY_VALUE_TEST_001
93 * @tc.desc: PackNormalizedKeyValue test
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(AuthSessionJsonMockTest, PACK_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
98 {
99 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
100 uint32_t dataLen = 1;
101 uint8_t *data = reinterpret_cast<uint8_t *>(SoftBusMalloc(dataLen));
102 if (data == nullptr) {
103 return;
104 }
105 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM))
106 .WillRepeatedly(Return(SOFTBUS_OK));
107 EXPECT_CALL(mocker, LnnDecryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
108 .WillOnce(DoAll(SetArgPointee<1>(nullptr), Return(SOFTBUS_OK)))
109 .WillOnce(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(0), Return(SOFTBUS_OK)));
110 AuthSessionInfo info = {0};
111 AuthDeviceKeyInfo deviceKey = {0};
112 const char *fastAuth = "encryptedFastAuth";
113 ParseFastAuthValue(&info, fastAuth, &deviceKey);
114 ParseFastAuthValue(&info, fastAuth, &deviceKey);
115 ParseFastAuthValue(&info, fastAuth, &deviceKey);
116 ParseFastAuthValue(&info, fastAuth, &deviceKey);
117 EXPECT_CALL(mocker, LnnEncryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
118 .WillOnce(DoAll(SetArgPointee<2>(nullptr), Return(SOFTBUS_OK)))
119 .WillOnce(DoAll(SetArgPointee<2>(data), SetArgPointee<3>(0), Return(SOFTBUS_OK)))
120 .WillRepeatedly(DoAll(SetArgPointee<2>(data), SetArgPointee<3>(dataLen), Return(SOFTBUS_OK)));
121 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString)
122 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
123 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
124 JsonObj obj;
125 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
126 SessionKey sessionKey;
127 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
128 int32_t ret = PackNormalizedKeyValue(&obj, &sessionKey);
129 EXPECT_NE(ret, SOFTBUS_OK);
130 ret = PackNormalizedKeyValue(&obj, &sessionKey);
131 EXPECT_NE(ret, SOFTBUS_OK);
132 ret = PackNormalizedKeyValue(&obj, &sessionKey);
133 EXPECT_NE(ret, SOFTBUS_OK);
134 ret = PackNormalizedKeyValue(&obj, &sessionKey);
135 EXPECT_NE(ret, SOFTBUS_OK);
136 }
137
138 /*
139 * @tc.name: PARSE_NORMALIZED_KEY_VALUE_TEST_001
140 * @tc.desc: ParseNormalizedKeyValue test
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(AuthSessionJsonMockTest, PARSE_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
145 {
146 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
147 uint32_t dataLen = strlen("true");
148 uint8_t *data = reinterpret_cast<uint8_t *>(SoftBusMalloc(dataLen));
149 if (data == nullptr) {
150 return;
151 }
152 (void)memcpy_s(data, dataLen, "true", strlen("true"));
153 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM))
154 .WillRepeatedly(Return(SOFTBUS_OK));
155 EXPECT_CALL(mocker, LnnDecryptAesGcm).WillOnce(Return(SOFTBUS_INVALID_PARAM))
156 .WillOnce(DoAll(SetArgPointee<1>(nullptr), Return(SOFTBUS_OK)))
157 .WillOnce(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(0), Return(SOFTBUS_OK)))
158 .WillRepeatedly(DoAll(SetArgPointee<1>(data), SetArgPointee<2>(dataLen), Return(SOFTBUS_OK)));
159 AuthSessionInfo info = {0};
160 SessionKey sessionKey;
161 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
162 const char *fastAuth = "encryptedFastAuth";
163 int32_t ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
164 EXPECT_NE(ret, SOFTBUS_OK);
165 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
166 EXPECT_NE(ret, SOFTBUS_OK);
167 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
168 EXPECT_NE(ret, SOFTBUS_OK);
169 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
170 EXPECT_NE(ret, SOFTBUS_OK);
171 ret = ParseNormalizedKeyValue(&info, fastAuth, &sessionKey);
172 EXPECT_EQ(ret, SOFTBUS_OK);
173 }
174
175 /*
176 * @tc.name: PARSE_NORMALIZE_DATA_TEST_001
177 * @tc.desc: ParseNormalizeData test
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(AuthSessionJsonMockTest, PARSE_NORMALIZE_DATA_TEST_001, TestSize.Level1)
182 {
183 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
184 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
185 .WillRepeatedly(Return(SOFTBUS_OK));
186 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
187 .WillRepeatedly(Return(SOFTBUS_OK));
188 AuthDeviceKeyInfo testKey = { .keyLen = KEY_VALUE_LEN };
189 EXPECT_EQ(memcpy_s(testKey.deviceKey, SESSION_KEY_LENGTH, KEY_VALUE, KEY_VALUE_LEN), EOK);
190 EXPECT_CALL(mocker, AuthFindLatestNormalizeKey).WillOnce(Return(SOFTBUS_INVALID_PARAM))
191 .WillRepeatedly(DoAll(SetArgPointee<1>(testKey), Return(SOFTBUS_OK)));
192 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
193 EXPECT_CALL(mocker, AuthFindNormalizeKeyByServerSide).WillOnce(Return(SOFTBUS_INVALID_PARAM))
194 .WillRepeatedly(Return(SOFTBUS_OK));
195 EXPECT_CALL(mocker, AuthUpdateCreateTime).WillRepeatedly(Return());
196 AuthSessionInfo info = {0};
197 AuthDeviceKeyInfo deviceKey = {0};
198 const char *key = "encnormalizedkeytest";
199 int32_t ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
200 EXPECT_NE(ret, SOFTBUS_OK);
201 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
202 EXPECT_NE(ret, SOFTBUS_OK);
203 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
204 EXPECT_NE(ret, SOFTBUS_OK);
205 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
206 EXPECT_NE(ret, SOFTBUS_OK);
207 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
208 EXPECT_NE(ret, SOFTBUS_OK);
209 ret = ParseNormalizeData(&info, const_cast<char *>(key), &deviceKey);
210 EXPECT_NE(ret, SOFTBUS_OK);
211 }
212
213 /*
214 * @tc.name: VERIFY_SESSION_INFO_ID_TYPE_TEST_001
215 * @tc.desc: VerifySessionInfoIdType test
216 * @tc.type: FUNC
217 * @tc.require:
218 */
219 HWTEST_F(AuthSessionJsonMockTest, VERIFY_SESSION_INFO_ID_TYPE_TEST_001, TestSize.Level1)
220 {
221 AuthSessionInfo info = { .idType = EXCHANGE_NETWORKID, .connInfo.type = AUTH_LINK_TYPE_WIFI };
222 char *networkId = nullptr;
223 char *udid = nullptr;
224 JsonObj obj;
225 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
226 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
227 EXPECT_CALL(mocker, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
228 .WillRepeatedly(Return(SOFTBUS_OK));
229 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
230 .WillRepeatedly(Return(SOFTBUS_OK));
231 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString)
232 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
233 .WillRepeatedly(Return(SOFTBUS_OK));
234 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(false));
235 PackWifiSinglePassInfo(&obj, &info);
236 PackWifiSinglePassInfo(&obj, &info);
237 PackWifiSinglePassInfo(&obj, &info);
238 PackWifiSinglePassInfo(&obj, &info);
239 PackWifiSinglePassInfo(&obj, &info);
240 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false)).WillOnce(Return(false))
241 .WillRepeatedly(Return(true));
242 bool ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
243 EXPECT_NE(ret, true);
244 info.idType = EXCHANGE_UDID;
245 ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
246 EXPECT_NE(ret, true);
247 ret = VerifySessionInfoIdType(&info, &obj, networkId, udid);
248 EXPECT_EQ(ret, true);
249 }
250
251 /*
252 * @tc.name: PACK_DEVICE_JSON_INFO_TEST_001
253 * @tc.desc: PackDeviceJsonInfo test
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_JSON_INFO_TEST_001, TestSize.Level1)
258 {
259 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
260 EXPECT_CALL(mocker, IsSupportUDIDAbatement).WillRepeatedly(Return(true));
261 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillRepeatedly(Return(false));
262 EXPECT_CALL(mocker, IsNeedUDIDAbatement).WillRepeatedly(Return(false));
263 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
264 .WillOnce(Return(false))
265 .WillRepeatedly(Return(true));
266 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false))
267 .WillRepeatedly(Return(true));
268 AuthSessionInfo info = {.connInfo.type = AUTH_LINK_TYPE_WIFI, .isConnectServer = false };
269 JsonObj obj;
270 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
271 PackUDIDAbatementFlag(&obj, &info);
272 int32_t ret = PackDeviceJsonInfo(&info, &obj);
273 EXPECT_NE(ret, SOFTBUS_OK);
274 info.isConnectServer = true;
275 ret = PackDeviceJsonInfo(&info, &obj);
276 EXPECT_NE(ret, SOFTBUS_OK);
277 ret = PackDeviceJsonInfo(&info, &obj);
278 EXPECT_NE(ret, SOFTBUS_OK);
279 ret = PackDeviceJsonInfo(&info, &obj);
280 EXPECT_EQ(ret, SOFTBUS_OK);
281 }
282
283 /*
284 * @tc.name: PACK_NORMALIZED_DATA_TEST_001
285 * @tc.desc: PackNormalizedData test
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(AuthSessionJsonMockTest, PACK_NORMALIZED_DATA_TEST_001, TestSize.Level1)
290 {
291 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
292 EXPECT_CALL(mocker, IsSupportFeatureByCapaBit).WillRepeatedly(Return(false));
293 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillOnce(Return(false))
294 .WillRepeatedly(Return(true));
295 AuthSessionInfo info = { .isServer = true, .connInfo.type = AUTH_LINK_TYPE_WIFI };
296 NodeInfo nodeInfo;
297 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
298 JsonObj obj;
299 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
300 int32_t ret = PackNormalizedData(&info, &obj, &nodeInfo);
301 EXPECT_NE(ret, SOFTBUS_OK);
302 EXPECT_CALL(mocker, JSON_GetStringFromOject).WillOnce(Return(false))
303 .WillRepeatedly(Return(false));
304 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
305 .WillRepeatedly(Return(SOFTBUS_OK));
306 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR);
307 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR);
308 EXPECT_EQ(info.normalizedKey, nullptr);
309 if (info.normalizedKey != nullptr) {
310 SoftBusFree(info.normalizedKey);
311 }
312 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR);
313 EXPECT_EQ(info.normalizedKey, nullptr);
314 if (info.normalizedKey != nullptr) {
315 SoftBusFree(info.normalizedKey);
316 }
317 UnpackNormalizedKey(&obj, &info, NORMALIZED_KEY_ERROR);
318 EXPECT_EQ(info.normalizedKey, nullptr);
319 if (info.normalizedKey != nullptr) {
320 SoftBusFree(info.normalizedKey);
321 }
322 ret = PackNormalizedData(&info, &obj, &nodeInfo);
323 EXPECT_EQ(ret, SOFTBUS_OK);
324 }
325
326 /*
327 * @tc.name: PACK_DEVICE_ID_JSON_TEST_001
328 * @tc.desc: PackDeviceIdJson test
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_ID_JSON_TEST_001, TestSize.Level1)
333 {
334 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
335 JsonObj obj;
336 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
337 EXPECT_CALL(mocker, JSON_CreateObject).WillOnce(Return(nullptr))
338 .WillRepeatedly(Return(&obj));
339 EXPECT_CALL(mocker, JSON_Delete).WillRepeatedly(Return());
340 EXPECT_CALL(mocker, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
341 EXPECT_CALL(mocker, FindAuthPreLinkNodeById).WillRepeatedly(Return(SOFTBUS_OK));
342 AuthSessionInfo info = {0};
343 char *ret = PackDeviceIdJson(&info);
344 EXPECT_EQ(ret, nullptr);
345 ret = PackDeviceIdJson(&info);
346 EXPECT_EQ(ret, nullptr);
347 }
348
349 /*
350 * @tc.name: UNPACK_WIFI_SINGLE_PASS_INFO_TEST_001
351 * @tc.desc: UnpackWifiSinglePassInfo test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(AuthSessionJsonMockTest, UNPACK_WIFI_SINGLE_PASS_INFO_TEST_001, TestSize.Level1)
356 {
357 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
358 const char *inetTest = "SoftBusInetNtoPTest";
359 EXPECT_CALL(mocker, JSON_GetStringFromOject).WillRepeatedly(Return(true));
360 EXPECT_CALL(mocker, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_INVALID_PARAM))
361 .WillRepeatedly(Return(SOFTBUS_OK));
362 EXPECT_CALL(mocker, SoftBusInetNtoP).WillOnce(Return(nullptr))
363 .WillRepeatedly(Return(inetTest));
364 EXPECT_CALL(mocker, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM))
365 .WillRepeatedly(Return(SOFTBUS_OK));
366 EXPECT_CALL(mocker, ConvertBytesToUpperCaseHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
367 .WillRepeatedly(Return(SOFTBUS_OK));
368 JsonObj obj;
369 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
370 AuthSessionInfo info = { .connInfo.type = AUTH_LINK_TYPE_WIFI };
371 bool ret = UnpackWifiSinglePassInfo(&obj, &info);
372 EXPECT_EQ(ret, true);
373 ret = UnpackWifiSinglePassInfo(&obj, &info);
374 EXPECT_EQ(ret, true);
375 ret = UnpackWifiSinglePassInfo(&obj, &info);
376 EXPECT_EQ(ret, true);
377 ret = UnpackWifiSinglePassInfo(&obj, &info);
378 EXPECT_EQ(ret, true);
379 ret = UnpackWifiSinglePassInfo(&obj, &info);
380 EXPECT_EQ(ret, true);
381 }
382
383 /*
384 * @tc.name: VERIFY_EXCHANGE_ID_TYPE_AND_INFO_TEST_001
385 * @tc.desc: VerifyExchangeIdTypeAndInfo test
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(AuthSessionJsonMockTest, VERIFY_EXCHANGE_ID_TYPE_AND_INFO_TEST_001, TestSize.Level1)
390 {
391 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
392 EXPECT_CALL(mocker, GetPeerUdidByNetworkId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
393 .WillRepeatedly(Return(SOFTBUS_OK));
394 EXPECT_CALL(mocker, GetIsExchangeUdidByNetworkId).WillOnce(Return(SOFTBUS_OK))
395 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
396 AuthSessionInfo info;
397 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
398 const char *anonyUdid = "0123456789ABC";
399 char testUdid[UDID_BUF_LEN] = "0123456789ABC";
400 EXPECT_EQ(strcpy_s(info.udid, UDID_BUF_LEN, testUdid), EOK);
401 int32_t ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_UDID, const_cast<char *>(anonyUdid));
402 EXPECT_EQ(ret, SOFTBUS_OK);
403 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
404 EXPECT_EQ(ret, SOFTBUS_OK);
405 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
406 EXPECT_EQ(ret, SOFTBUS_OK);
407 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
408 EXPECT_EQ(ret, SOFTBUS_OK);
409 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
410 EXPECT_EQ(ret, SOFTBUS_OK);
411 ret = VerifyExchangeIdTypeAndInfo(&info, EXCHANGE_NETWORKID, const_cast<char *>(anonyUdid));
412 EXPECT_EQ(ret, SOFTBUS_OK);
413 }
414
415 /*
416 * @tc.name: SET_EXCHANGE_ID_TYPE_AND_VALUE_TEST_001
417 * @tc.desc: SetExchangeIdTypeAndValue test
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(AuthSessionJsonMockTest, SET_EXCHANGE_ID_TYPE_AND_VALUE_TEST_001, TestSize.Level1)
422 {
423 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
424 EXPECT_CALL(mocker, JSON_GetInt32FromOject).WillRepeatedly(Return(false));
425 JsonObj obj;
426 (void)memset_s(&obj, sizeof(JsonObj), 0, sizeof(JsonObj));
427 AuthSessionInfo info;
428 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
429 int32_t ret = SetExchangeIdTypeAndValue(&obj, &info);
430 EXPECT_EQ(ret, SOFTBUS_OK);
431 EXPECT_CALL(mocker, AuthMetaGetConnIdByInfo).WillRepeatedly(Return(SOFTBUS_OK));
432 EXPECT_CALL(mocker, LnnGetMetaPtk).WillOnce(Return(SOFTBUS_INVALID_PARAM))
433 .WillRepeatedly(Return(SOFTBUS_OK));
434 EXPECT_CALL(mocker, LnnDumpRemotePtk).WillRepeatedly(Return());
435 EXPECT_CALL(mocker, SoftBusBase64Encode).WillOnce(Return(SOFTBUS_INVALID_PARAM))
436 .WillRepeatedly(Return(SOFTBUS_OK));
437 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
438 .WillOnce(Return(true))
439 .WillOnce(Return(false))
440 .WillRepeatedly(Return(true));
441 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false))
442 .WillRepeatedly(Return(true));
443 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
444 .WillRepeatedly(Return(SOFTBUS_OK));
445 AuthConnInfo connInfo;
446 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
447 NodeInfo nodeInfo;
448 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
449 const char *remoteUuid = "remoteUuidTest";
450 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, true);
451 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, nullptr, false);
452 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
453 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
454 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
455 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
456 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
457 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
458 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
459 PackWifiDirectInfo(&connInfo, &obj, &nodeInfo, remoteUuid, false);
460 ret = SetExchangeIdTypeAndValue(&obj, nullptr);
461 EXPECT_NE(ret, SOFTBUS_OK);
462 ret = SetExchangeIdTypeAndValue(nullptr, &info);
463 EXPECT_NE(ret, SOFTBUS_OK);
464 }
465
466 /*
467 * @tc.name: PACK_CIPHER_RPA_INFO_TEST_001
468 * @tc.desc: PackCipherRpaInfo test
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(AuthSessionJsonMockTest, PACK_CIPHER_RPA_INFO_TEST_001, TestSize.Level1)
473 {
474 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
475 JsonObj json;
476 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
477 NodeInfo info;
478 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
479 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM));
480 int32_t ret = PackCipherRpaInfo(&json, &info);
481 EXPECT_NE(ret, SOFTBUS_OK);
482 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
483 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
484 ret = PackCipherRpaInfo(&json, &info);
485 EXPECT_NE(ret, SOFTBUS_OK);
486 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
487 .WillOnce(Return(SOFTBUS_OK))
488 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
489 ret = PackCipherRpaInfo(&json, &info);
490 EXPECT_NE(ret, SOFTBUS_OK);
491 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_OK))
492 .WillOnce(Return(SOFTBUS_OK))
493 .WillOnce(Return(SOFTBUS_OK))
494 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
495 ret = PackCipherRpaInfo(&json, &info);
496 EXPECT_NE(ret, SOFTBUS_OK);
497 EXPECT_CALL(mocker, ConvertBytesToHexString).WillRepeatedly(Return(SOFTBUS_OK));
498 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
499 EXPECT_CALL(mocker, LnnUpdateLocalBroadcastCipherKey).WillOnce(Return(SOFTBUS_INVALID_PARAM))
500 .WillRepeatedly(Return(SOFTBUS_OK));
501 ret = PackCipherRpaInfo(&json, &info);
502 EXPECT_NE(ret, SOFTBUS_OK);
503 ret = PackCipherRpaInfo(&json, &info);
504 EXPECT_EQ(ret, SOFTBUS_OK);
505 }
506
507 /*
508 * @tc.name: PACK_COMMON_EX_TEST_001
509 * @tc.desc: PackCommonEx test
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 HWTEST_F(AuthSessionJsonMockTest, PACK_COMMON_EX_TEST_001, TestSize.Level1)
514 {
515 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
516 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
517 .WillRepeatedly(Return(true));
518 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
519 EXPECT_CALL(mocker, JSON_AddInt16ToObject).WillRepeatedly(Return(true));
520 EXPECT_CALL(mocker, JSON_AddBoolToObject).WillRepeatedly(Return(true));
521 EXPECT_CALL(mocker, JSON_AddInt64ToObject).WillRepeatedly(Return(true));
522 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
523 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
524 EXPECT_CALL(mocker, LnnGetSupportedProtocols).WillRepeatedly(Return(0));
525 JsonObj json;
526 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
527 NodeInfo info;
528 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
529 int32_t ret = PackCommonEx(&json, &info);
530 EXPECT_NE(ret, SOFTBUS_OK);
531 EXPECT_CALL(mocker, JSON_GetStringFromOject).WillRepeatedly(Return(true));
532 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM));
533 UnpackCipherRpaInfo(&json, &info);
534 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_OK))
535 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
536 UnpackCipherRpaInfo(&json, &info);
537 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillOnce(Return(SOFTBUS_OK))
538 .WillOnce(Return(SOFTBUS_OK))
539 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
540 UnpackCipherRpaInfo(&json, &info);
541 EXPECT_CALL(mocker, ConvertHexStringToBytes).WillRepeatedly(Return(SOFTBUS_OK));
542 UnpackCipherRpaInfo(&json, &info);
543 const char *btMac = "00:11:22:33:44:55";
544 EXPECT_CALL(mocker, LnnGetBtMac).WillRepeatedly(Return(btMac));
545 EXPECT_CALL(mocker, StringToUpperCase).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
546 ret = PackCommonEx(&json, &info);
547 EXPECT_EQ(ret, SOFTBUS_OK);
548 }
549
550 /*
551 * @tc.name: PACK_COMMON_TEST_001
552 * @tc.desc: PackCommon test
553 * @tc.type: FUNC
554 * @tc.require:
555 */
556 HWTEST_F(AuthSessionJsonMockTest, PACK_COMMON_TEST_001, TestSize.Level1)
557 {
558 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
559 JsonObj json;
560 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
561 NodeInfo info;
562 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
563 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false));
564 int32_t ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
565 EXPECT_NE(ret, SOFTBUS_OK);
566 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(true));
567 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false));
568 ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
569 EXPECT_NE(ret, SOFTBUS_OK);
570 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(true))
571 .WillOnce(Return(false));
572 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(true));
573 ret = PackCommon(&json, &info, SOFTBUS_NEW_V1, true);
574 EXPECT_NE(ret, SOFTBUS_OK);
575 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false));
576 ret = PackCommon(&json, &info, SOFTBUS_OLD_V2, true);
577 EXPECT_NE(ret, SOFTBUS_OK);
578 }
579
580 /*
581 * @tc.name: PACK_BT_TEST_001
582 * @tc.desc: PackBt test
583 * @tc.type: FUNC
584 * @tc.require:
585 */
586 HWTEST_F(AuthSessionJsonMockTest, PACK_BT_TEST_001, TestSize.Level1)
587 {
588 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
589 JsonObj json;
590 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
591 NodeInfo info;
592 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
593 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillOnce(Return(false));
594 EXPECT_CALL(mocker, LnnGetNetworkIdByUuid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
595 .WillRepeatedly(Return(SOFTBUS_OK));
596 const char *remoteUuid = "remoteUuidTest";
597 AddDiscoveryType(&json, nullptr);
598 AddDiscoveryType(&json, remoteUuid);
599 EXPECT_CALL(mocker, LnnGetRemoteNumInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
600 AddDiscoveryType(&json, remoteUuid);
601 int32_t ret = PackBt(&json, &info, SOFTBUS_NEW_V1, true, remoteUuid);
602 EXPECT_NE(ret, SOFTBUS_OK);
603 }
604
605 /*
606 * @tc.name: PACK_WIFI_TEST_001
607 * @tc.desc: PackWiFi test
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(AuthSessionJsonMockTest, PACK_WIFI_TEST_001, TestSize.Level1)
612 {
613 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
614 JsonObj json;
615 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
616 NodeInfo info;
617 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
618 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(false));
619 EXPECT_CALL(mocker, LnnGetAuthPort).WillRepeatedly(Return(TEST_AUTH_PORT));
620 EXPECT_CALL(mocker, LnnGetSessionPort).WillRepeatedly(Return(TEST_SESSION_PORT));
621 EXPECT_CALL(mocker, LnnGetProxyPort).WillRepeatedly(Return(TEST_PROXY_PORT));
622 int32_t ret = PackWiFi(&json, &info, SOFTBUS_NEW_V1, false);
623 EXPECT_NE(ret, SOFTBUS_OK);
624 EXPECT_CALL(mocker, JSON_AddInt32ToObject).WillRepeatedly(Return(true));
625 EXPECT_CALL(mocker, JSON_AddStringToObject).WillRepeatedly(Return(true));
626 EXPECT_CALL(mocker, SoftBusBase64Encode).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
627 ret = PackWiFi(&json, &info, SOFTBUS_NEW_V1, false);
628 EXPECT_NE(ret, SOFTBUS_OK);
629 }
630
631 /*
632 * @tc.name: PACK_CERTIFICATEINFO_TEST_001
633 * @tc.desc: PackCertificateInfo test
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(AuthSessionJsonMockTest, PACK_CERTIFICATEINFO_TEST_001, TestSize.Level1)
638 {
639 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
640 JsonObj json;
641 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
642 AuthSessionInfo info;
643 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
644 info.isNeedPackCert = false;
645 EXPECT_CALL(mocker, IsSupportUDIDAbatement).WillOnce(Return(false))
646 .WillRepeatedly(Return(true));
647 int32_t ret = PackCertificateInfo(&json, nullptr);
648 EXPECT_EQ(ret, SOFTBUS_OK);
649 ret = PackCertificateInfo(&json, &info);
650 EXPECT_EQ(ret, SOFTBUS_OK);
651 ret = PackCertificateInfo(&json, &info);
652 EXPECT_EQ(ret, SOFTBUS_OK);
653 info.isNeedPackCert = true;
654 EXPECT_CALL(mocker, GenerateCertificate).WillOnce(Return(SOFTBUS_OK))
655 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
656 ret = PackCertificateInfo(&json, &info);
657 EXPECT_NE(ret, SOFTBUS_OK);
658 EXPECT_CALL(mocker, JSON_AddBytesToObject).WillRepeatedly(Return(false));
659 EXPECT_CALL(mocker, FreeSoftbusChain).WillRepeatedly(Return());
660 ret = PackCertificateInfo(&json, &info);
661 EXPECT_EQ(ret, SOFTBUS_OK);
662 EXPECT_CALL(mocker, JSON_AddBytesToObject).WillRepeatedly(Return(true));
663 EXPECT_EQ(ret, SOFTBUS_OK);
664 }
665
666 /*
667 * @tc.name: UNPACK_CERTIFICATEINFO_TEST_001
668 * @tc.desc: UnpackCertificateInfo test
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(AuthSessionJsonMockTest, UNPACK_CERTIFICATEINFO_TEST_001, TestSize.Level1)
673 {
674 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
675 JsonObj json;
676 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
677 AuthSessionInfo info;
678 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
679 NodeInfo nodeInfo;
680 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
681 EXPECT_CALL(mocker, IsSupportUDIDAbatement).WillOnce(Return(false))
682 .WillRepeatedly(Return(true));
683 EXPECT_CALL(mocker, IsNeedUDIDAbatement).WillOnce(Return(false))
684 .WillRepeatedly(Return(true));
685
686 int32_t ret = UnpackCertificateInfo(nullptr, &nodeInfo, &info);
687 EXPECT_EQ(ret, SOFTBUS_OK);
688 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
689 EXPECT_EQ(ret, SOFTBUS_OK);
690 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
691 EXPECT_EQ(ret, SOFTBUS_OK);
692 EXPECT_CALL(mocker, InitSoftbusChain).WillOnce(Return(SOFTBUS_INVALID_PARAM))
693 .WillRepeatedly(Return(SOFTBUS_OK));
694 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 EXPECT_CALL(mocker, JSON_GetBytesFromObject).WillRepeatedly(Return(false));
697 EXPECT_CALL(mocker, FreeSoftbusChain).WillRepeatedly(Return());
698 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
699 EXPECT_EQ(ret, SOFTBUS_OK);
700 EXPECT_CALL(mocker, JSON_GetBytesFromObject).WillRepeatedly(Return(true));
701 EXPECT_CALL(mocker, VerifyCertificate).WillOnce(Return(SOFTBUS_INVALID_PARAM))
702 .WillRepeatedly(Return(SOFTBUS_OK));
703 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
704 EXPECT_NE(ret, SOFTBUS_OK);
705 ret = UnpackCertificateInfo(&json, &nodeInfo, &info);
706 EXPECT_EQ(ret, SOFTBUS_OK);
707 }
708
709 /*
710 * @tc.name: PACK_USER_ID_CHECK_SUM_TEST_001
711 * @tc.desc: PackUserIdCheckSum test
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(AuthSessionJsonMockTest, PACK_USER_ID_CHECK_SUM_TEST_001, TestSize.Level1)
716 {
717 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
718 JsonObj json;
719 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
720 NodeInfo nodeInfo;
721 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
722 EXPECT_CALL(mocker, ConvertBytesToHexString).WillOnce(Return(SOFTBUS_INVALID_PARAM))
723 .WillRepeatedly(Return(SOFTBUS_OK));
724 EXPECT_CALL(mocker, JSON_AddStringToObject).WillOnce(Return(false))
725 .WillRepeatedly(Return(true));
726 int32_t ret = PackUserIdCheckSum(&json, &nodeInfo);
727 EXPECT_NE(ret, SOFTBUS_OK);
728 ret = PackUserIdCheckSum(&json, &nodeInfo);
729 EXPECT_NE(ret, SOFTBUS_OK);
730 ret = PackUserIdCheckSum(&json, &nodeInfo);
731 EXPECT_EQ(ret, SOFTBUS_OK);
732 }
733
734 /*
735 * @tc.name: PACK_DEVICE_INFO_MESSAGE_TEST_001
736 * @tc.desc: PackDeviceInfoMessage test
737 * @tc.type: FUNC
738 * @tc.require:
739 */
740 HWTEST_F(AuthSessionJsonMockTest, PACK_DEVICE_INFO_MESSAGE_TEST_001, TestSize.Level1)
741 {
742 NiceMock<AuthSessionJsonDepsInterfaceMock> mocker;
743 AuthConnInfo connInfo;
744 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
745 AuthSessionInfo info;
746 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
747 NodeInfo nodeInfo;
748 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
749 EXPECT_CALL(mocker, LnnGetLocalNodeInfoSafe).WillOnce(Return(SOFTBUS_INVALID_PARAM))
750 .WillRepeatedly(Return(SOFTBUS_OK));
751 const char *brMacTempNull = "";
752 const char *brMacTempInvalid = "00:00:00:00:00:00";
753 const char *brMacTemp = "00:11:22:33:44:55";
754 EXPECT_CALL(mocker, LnnGetBtMac).WillOnce(Return(brMacTempNull)).WillOnce(Return(brMacTempInvalid))
755 .WillRepeatedly(Return(brMacTemp));
756 EXPECT_CALL(mocker, SoftBusGetBtState).WillOnce(Return(BLE_DISABLE))
757 .WillRepeatedly(Return(BLE_ENABLE));
758 EXPECT_CALL(mocker, SoftBusGetBtMacAddr).WillOnce(Return(SOFTBUS_INVALID_PARAM))
759 .WillRepeatedly(Return(SOFTBUS_OK));
760 EXPECT_CALL(mocker, LnnGetLocalNodeInfo).WillRepeatedly(Return(nullptr));
761 const char *remoteUuid = "remoteUuidTest";
762 char *ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
763 EXPECT_EQ(ret, nullptr);
764 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
765 EXPECT_EQ(ret, nullptr);
766 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
767 EXPECT_EQ(ret, nullptr);
768 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
769 EXPECT_EQ(ret, nullptr);
770 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
771 EXPECT_EQ(ret, nullptr);
772 ret = PackDeviceInfoMessage(&connInfo, SOFTBUS_NEW_V1, false, remoteUuid, &info);
773 EXPECT_EQ(ret, nullptr);
774 }
775 } // namespace OHOS