1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "auth_interface.h"
20 #include "distribute_net_ledger_mock.h"
21 #include "lnn_net_builder.c"
22 #include "lnn_net_builder_mock.h"
23 #include "lnn_net_ledger_mock.h"
24 #include "lnn_service_mock.h"
25 #include "lnn_sync_info_manager.c"
26 #include "lnn_sync_info_manager.h"
27 #include "lnn_sync_info_manager_mock.h"
28 #include "lnn_trans_mock.h"
29 #include "message_handler.h"
30 #include "softbus_error_code.h"
31
32 namespace OHOS {
33 using namespace testing;
34 using namespace testing::ext;
35
36 constexpr char NETWORKID[65] = "abcdefg";
37 constexpr char NODE_NETWORK_ID[65] = "gfedcba";
38 constexpr uint8_t MSG[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
39 constexpr char MSG_DATA[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
40 constexpr char MSG_DATA1[] = { -1 };
41 constexpr char MSG_DATA2[] = { 1 };
42 constexpr uint32_t LEN = 10;
43 constexpr uint32_t LENGTH = 8192;
44 constexpr char MSG_TEST[] = "msg";
45 class LNNSyncInfoManagerTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase()53 void LNNSyncInfoManagerTest::SetUpTestCase() { }
54
TearDownTestCase()55 void LNNSyncInfoManagerTest::TearDownTestCase() { }
56
SetUp()57 void LNNSyncInfoManagerTest::SetUp() { }
58
TearDown()59 void LNNSyncInfoManagerTest::TearDown() { }
60
Handler(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)61 void Handler(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len) { }
62
Complete(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)63 void Complete(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len) { }
64
65 /*
66 * @tc.name: LNN_INIT_SYNC_INFO_MANAGER_TEST_001
67 * @tc.desc: LnnInitSyncInfoManager
68 * @tc.type: FUNC
69 * @tc.require: I5OMIK
70 */
71 HWTEST_F(LNNSyncInfoManagerTest, LNN_INIT_SYNC_INFO_MANAGER_TEST_001, TestSize.Level1)
72 {
73 LooperInit();
74 NiceMock<LnnTransInterfaceMock> transMock;
75 NiceMock<LnnServicetInterfaceMock> serviceMock;
76 EXPECT_CALL(transMock, TransRegisterNetworkingChannelListener)
77 .WillRepeatedly(DoAll(LnnTransInterfaceMock::ActionOfTransRegister, Return(SOFTBUS_OK)));
78 int32_t ret = LnnInitSyncInfoManager();
79 EXPECT_TRUE(ret == SOFTBUS_OK);
80 }
81
82 /*
83 * @tc.name: LNN_REG_SYNC_INFO_HANDLER_TEST_001
84 * @tc.desc: invalid parameter
85 * @tc.type: FUNC
86 * @tc.require: I5OMIK
87 */
88 HWTEST_F(LNNSyncInfoManagerTest, LNN_REG_SYNC_INFO_HANDLER_TEST_001, TestSize.Level1)
89 {
90 int32_t ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_COUNT, Handler);
91 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
92 ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_TOPO_UPDATE, Handler);
93 EXPECT_TRUE(ret == SOFTBUS_OK);
94 ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_TOPO_UPDATE, Handler);
95 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
96 }
97
98 /*
99 * @tc.name: LNN_UNREG_SYNC_INFO_HANDLER_TEST_001
100 * @tc.desc: invalid parameter
101 * @tc.type: FUNC
102 * @tc.require: I5OMIK
103 */
104 HWTEST_F(LNNSyncInfoManagerTest, LNN_UNREG_SYNC_INFO_HANDLER_TEST_001, TestSize.Level1)
105 {
106 int32_t ret = LnnUnregSyncInfoHandler(LNN_INFO_TYPE_COUNT, Handler);
107 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
108 ret = LnnUnregSyncInfoHandler(LNN_INFO_TYPE_OFFLINE, Handler);
109 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
110 LnnRegSyncInfoHandler(LNN_INFO_TYPE_TOPO_UPDATE, Handler);
111 ret = LnnUnregSyncInfoHandler(LNN_INFO_TYPE_TOPO_UPDATE, Handler);
112 EXPECT_TRUE(ret == SOFTBUS_OK);
113 }
114
115 /*
116 * @tc.name: LNN_SEND_SYNC_INFO_MSG_TEST_001
117 * @tc.desc: invalid parameter
118 * @tc.type: FUNC
119 * @tc.require: I5OMIK
120 */
121 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_SYNC_INFO_MSG_TEST_001, TestSize.Level1)
122 {
123 int32_t ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_COUNT, NETWORKID, MSG, LEN, Complete);
124 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
125
126 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_ROUTE_LSU, NETWORKID, MSG, LENGTH, Complete);
127 EXPECT_TRUE(ret == SOFTBUS_MEM_ERR);
128 }
129
130 /*
131 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_001
132 * @tc.desc: LnnSendP2pSyncInfoMsg test
133 * @tc.type: FUNC
134 * @tc.require: I5OMIK
135 */
136 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_001, TestSize.Level1)
137 {
138 int64_t newLocalAuthSeq[2] = { 1, 2 };
139 JsonObj json;
140 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
141 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
142 if (msg == nullptr) {
143 return;
144 }
145 (void)strcpy_s(msg, LEN, MSG_TEST);
146 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
147 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
148 NiceMock<LnnServicetInterfaceMock> serviceMock;
149
150 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
151 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
152 .Times(1)
153 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
154 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
155 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
156
157 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
158 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
159 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
160 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
161 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillRepeatedly(Return(msg));
162
163 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_OK));
164 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
165 EXPECT_EQ(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
166 }
167
168 /*
169 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_002
170 * @tc.desc: networkId == nullptr
171 * @tc.type: FUNC
172 * @tc.require: I5OMIK
173 */
174 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_002, TestSize.Level1)
175 {
176 NiceMock<LnnServicetInterfaceMock> serviceMock;
177 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_OK));
178 uint32_t netCapability = 0;
179 int32_t ret = LnnSendP2pSyncInfoMsg(nullptr, netCapability);
180 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
181 }
182
183 /*
184 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_003
185 * @tc.desc: GetAuthHandleByNetworkId(networkId, &authHandle) != SOFTBUS_OK
186 * @tc.type: FUNC
187 * @tc.require: I5OMIK
188 */
189 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_003, TestSize.Level1)
190 {
191 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
192
193 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
194 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
195 .Times(2)
196 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = AUTH_INVALID_ID, .type = 1 }), Return(SOFTBUS_ERR)))
197 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = AUTH_INVALID_ID, .type = 1 }), Return(SOFTBUS_ERR)));
198
199 EXPECT_NE(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
200 }
201
202 /*
203 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_004
204 * @tc.desc: AuthGetLatestAuthSeqListByType != SOFTBUS_OK
205 * @tc.type: FUNC
206 * @tc.require: I5OMIK
207 */
208 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_004, TestSize.Level1)
209 {
210 int64_t newLocalAuthSeq[2] = { 1, 2 };
211 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
212
213 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
214 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
215 .Times(1)
216 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
217 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
218 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_ERR)));
219
220 EXPECT_NE(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
221 }
222
223 /*
224 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_005
225 * @tc.desc: msg == nullptr
226 * @tc.type: FUNC
227 * @tc.require: I5OMIK
228 */
229 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_005, TestSize.Level1)
230 {
231 int64_t newLocalAuthSeq[2] = { 1, 2 };
232 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
233 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
234
235 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
236 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
237 .Times(1)
238 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
239 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
240 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
241 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(nullptr));
242
243 EXPECT_NE(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
244 }
245
246 /*
247 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_006
248 * @tc.desc: SoftBusGenerateRandomArray((uint8_t *)&dataInfo.seq, sizeof(int64_t)) != SOFTBUS_OK
249 * @tc.type: FUNC
250 * @tc.require: I5OMIK
251 */
252 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_006, TestSize.Level1)
253 {
254 int64_t newLocalAuthSeq[2] = { 1, 2 };
255 JsonObj json;
256 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
257 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
258 if (msg == nullptr) {
259 return;
260 }
261 (void)strcpy_s(msg, LEN, MSG_TEST);
262 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
263 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
264 NiceMock<LnnServicetInterfaceMock> serviceMock;
265
266 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
267 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
268 .Times(1)
269 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
270 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
271 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
272
273 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
274 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
275 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
276 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
277 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillRepeatedly(Return(msg));
278
279 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_ERR));
280
281 EXPECT_NE(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
282 }
283
284 /*
285 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_007
286 * @tc.desc: AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_OK
287 * @tc.type: FUNC
288 * @tc.require: I5OMIK
289 */
290 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_007, TestSize.Level1)
291 {
292 int64_t newLocalAuthSeq[2] = { 1, 2 };
293 JsonObj json;
294 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
295 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
296 if (msg == nullptr) {
297 return;
298 }
299 (void)strcpy_s(msg, LEN, MSG_TEST);
300 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
301 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
302 NiceMock<LnnServicetInterfaceMock> serviceMock;
303
304 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
305 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
306 .Times(1)
307 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
308 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
309 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
310
311 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
312 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
313 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
314 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
315 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillRepeatedly(Return(msg));
316
317 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_OK));
318 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
319
320 EXPECT_EQ(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
321 }
322
323 /*
324 * @tc.name: LNN_SEND_P2P_SYNC_INFO_MSG_TEST_008
325 * @tc.desc: AuthPostTransData(authHandle, &dataInfo) != SOFTBUS_OK
326 * @tc.type: FUNC
327 * @tc.require: I5OMIK
328 */
329 HWTEST_F(LNNSyncInfoManagerTest, LNN_SEND_P2P_SYNC_INFO_MSG_TEST_008, TestSize.Level1)
330 {
331 int64_t newLocalAuthSeq[2] = { 1, 2 };
332 JsonObj json;
333 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
334 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
335 if (msg == nullptr) {
336 return;
337 }
338 (void)strcpy_s(msg, LEN, MSG_TEST);
339 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
340 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
341 NiceMock<LnnServicetInterfaceMock> serviceMock;
342
343 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(2).WillRepeatedly(Return(SOFTBUS_OK));
344 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
345 .Times(1)
346 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(SOFTBUS_OK)));
347 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
348 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
349
350 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
351 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
352 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
353 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
354 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillRepeatedly(Return(msg));
355
356 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray).WillRepeatedly(Return(SOFTBUS_OK));
357 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
358
359 EXPECT_EQ(LnnSendP2pSyncInfoMsg(NETWORKID, 0), SOFTBUS_OK);
360 }
361
362 /*
363 * @tc.name: FindSyncChannelInfoByChannelId_001
364 * @tc.desc: return nullptr
365 * @tc.type: FUNC
366 * @tc.require: 1
367 */
368 HWTEST_F(LNNSyncInfoManagerTest, FindSyncChannelInfoByChannelId_001, TestSize.Level1)
369 {
370 ClearSyncChannelInfo();
371 EXPECT_EQ(FindSyncChannelInfoByChannelId(10), nullptr);
372 }
373
374 /*
375 * @tc.name: SendSyncInfoMsg_001
376 * @tc.desc: SendSyncInfoMsgOnly
377 * @tc.type: FUNC
378 * @tc.require: 1
379 */
380 HWTEST_F(LNNSyncInfoManagerTest, SendSyncInfoMsg_001, TestSize.Level1)
381 {
382 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
383 if (info == nullptr) {
384 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
385 return;
386 }
387
388 info->clientChannelId = 10;
389 SoftBusSysTime sysTime;
390 info->accessTime = sysTime;
391 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
392 if (msg == nullptr) {
393 LNN_LOGE(LNN_BUILDER, "create sync info sync error!");
394 return;
395 }
396
397 NiceMock<LnnTransInterfaceMock> transMock;
398 EXPECT_CALL(transMock, TransSendNetworkingMessage(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
399
400 SendSyncInfoMsg(info, msg);
401 }
402
403 /*
404 * @tc.name: DumpMsgExcludeListNode_001
405 * @tc.desc: return newMsg;
406 * @tc.type: FUNC
407 * @tc.require: 1
408 */
409 HWTEST_F(LNNSyncInfoManagerTest, DumpMsgExcludeListNode_001, TestSize.Level1)
410 {
411 EXPECT_EQ(DumpMsgExcludeListNode(nullptr), nullptr);
412
413 SyncInfoMsg *newItem = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
414 if (newItem == nullptr) {
415 LNN_LOGE(LNN_BUILDER, "create sync info sync error!");
416 return;
417 }
418 EXPECT_NE(DumpMsgExcludeListNode(newItem), nullptr);
419
420 SoftBusFree(newItem);
421 }
422
423 /*
424 * @tc.name: DumpSyncInfoMsgList_001
425 * @tc.desc: return SOFTBUS_OK;
426 * @tc.type: FUNC
427 * @tc.require: 1
428 */
429 HWTEST_F(LNNSyncInfoManagerTest, DumpSyncInfoMsgList_001, TestSize.Level1)
430 {
431 EXPECT_EQ(DumpSyncInfoMsgList(nullptr, nullptr), SOFTBUS_INVALID_PARAM);
432
433 SyncChannelInfo *newInfo = CreateSyncChannelInfo(NETWORKID);
434 if (newInfo == nullptr) {
435 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
436 return;
437 }
438 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
439 if (info == nullptr) {
440 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
441 return;
442 }
443
444 EXPECT_EQ(DumpSyncInfoMsgList(&info->syncMsgList, &newInfo->syncMsgList), SOFTBUS_OK);
445
446 SoftBusFree(info);
447 SoftBusFree(newInfo);
448 }
449
450 /*
451 * @tc.name: DumpSyncChannelInfo_001
452 * @tc.desc: return newInfo;
453 * @tc.type: FUNC
454 * @tc.require: 1
455 */
456 HWTEST_F(LNNSyncInfoManagerTest, DumpSyncChannelInfo_001, TestSize.Level1)
457 {
458 SoftBusSysTime now;
459 SoftBusGetTime(&now);
460 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
461 if (info == nullptr) {
462 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
463 return;
464 }
465 info->clientChannelId = 10;
466 info->serverChannelId = 10;
467 info->accessTime = now;
468 info->isClientOpened = 0;
469 DestroySyncInfoMsgList(&info->syncMsgList);
470
471 EXPECT_NE(DumpSyncChannelInfo(info), nullptr);
472 SoftBusFree(info);
473 }
474
475 /*
476 * @tc.name: SendSyncInfoMsgFromList_001
477 * @tc.desc: SendSyncInfoMsgFromList
478 * @tc.type: FUNC
479 * @tc.require: 1
480 */
481 HWTEST_F(LNNSyncInfoManagerTest, SendSyncInfoMsgFromList_001, TestSize.Level1)
482 {
483 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
484 if (info == nullptr) {
485 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
486 return;
487 }
488 info->clientChannelId = 10;
489 SyncInfoMsg *newItem = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
490 if (newItem == nullptr) {
491 LNN_LOGE(LNN_BUILDER, "create sync info sync error!");
492 return;
493 }
494
495 ListTailInsert(&info->syncMsgList, &newItem->node);
496
497 NiceMock<LnnTransInterfaceMock> transMock;
498 EXPECT_CALL(transMock, TransSendNetworkingMessage(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
499
500 SendSyncInfoMsgFromList(info);
501 SoftBusFree(info);
502 }
503
504 /*
505 * @tc.name: ResetOpenChannelInfo_001
506 * @tc.desc: info->serverChannelId != channelId && info->serverChannelId != INVALID_CHANNEL_ID
507 * @tc.type: FUNC
508 * @tc.require: 1
509 */
510 HWTEST_F(LNNSyncInfoManagerTest, ResetOpenChannelInfo_001, TestSize.Level1)
511 {
512 int32_t *oldChannelId = new int32_t(0);
513 int32_t channelId = 10;
514 unsigned char isServer = true;
515 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
516 if (info == nullptr) {
517 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
518 return;
519 }
520 info->serverChannelId = 1;
521 ResetOpenChannelInfo(channelId, isServer, info, oldChannelId);
522
523 EXPECT_EQ(info->serverChannelId, channelId);
524 delete (oldChannelId);
525 oldChannelId = nullptr;
526 SoftBusFree(info);
527 }
528
529 /*
530 * @tc.name: ResetOpenChannelInfo_002
531 * @tc.desc: info->serverChannelId != channelId && info->serverChannelId != INVALID_CHANNEL_ID
532 * @tc.type: FUNC
533 * @tc.require: 1
534 */
535 HWTEST_F(LNNSyncInfoManagerTest, ResetOpenChannelInfo_002, TestSize.Level1)
536 {
537 int32_t *oldChannelId = new int32_t(0);
538 int32_t channelId = 10;
539 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
540 if (info == nullptr) {
541 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
542 return;
543 }
544 info->clientChannelId = 1;
545 ResetOpenChannelInfo(channelId, false, info, oldChannelId);
546
547 EXPECT_EQ(info->clientChannelId, channelId);
548 delete (oldChannelId);
549 oldChannelId = nullptr;
550 SoftBusFree(info);
551 }
552
553 /*
554 * @tc.name: AddChannelInfoNode_001
555 * @tc.desc: isServer = false
556 * @tc.type: FUNC
557 * @tc.require: 1
558 */
559 HWTEST_F(LNNSyncInfoManagerTest, AddChannelInfoNode_001, TestSize.Level1)
560 {
561 int32_t channelId = 10;
562 unsigned char isServer = false;
563 EXPECT_EQ(AddChannelInfoNode(NETWORKID, channelId, isServer), SOFTBUS_INVALID_PARAM);
564 }
565
566 /*
567 * @tc.name: OnChannelOpened_001
568 * @tc.desc: LnnConvertDlId(peerUuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK
569 * @tc.type: FUNC
570 * @tc.require: 1
571 */
572 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpened_001, TestSize.Level1)
573 {
574 int32_t channelId = 10;
575 unsigned char isServer = false;
576
577 NiceMock<LnnNetLedgertInterfaceMock> mock;
578 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
579
580 EXPECT_EQ(OnChannelOpened(channelId, nullptr, isServer), SOFTBUS_ERR);
581 }
582
583 /*
584 * @tc.name: OnChannelOpened_002
585 * @tc.desc: !isServer == true
586 * @tc.type: FUNC
587 * @tc.require: 1
588 */
589 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpened_002, TestSize.Level1)
590 {
591 int32_t channelId = 10;
592 unsigned char isServer = true;
593 const char *peerUuid = nullptr;
594 ClearSyncChannelInfo();
595 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
596 if (msg == nullptr) {
597 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
598 return;
599 }
600 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
601 if (info == nullptr) {
602 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
603 return;
604 }
605 info->serverChannelId = channelId;
606 info->clientChannelId = channelId;
607 ListTailInsert(&info->syncMsgList, &msg->node);
608 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
609 NiceMock<LnnTransInterfaceMock> lnnTransMock;
610 EXPECT_CALL(lnnTransMock, TransSendNetworkingMessage(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
611 NiceMock<LnnNetLedgertInterfaceMock> lnnNetLedgertMock;
612 EXPECT_CALL(lnnNetLedgertMock, LnnConvertDlId(_, _, _, _, _))
613 .WillRepeatedly(DoAll(SetArrayArgument<3>(NETWORKID, NETWORKID + LEN), Return(SOFTBUS_OK)));
614 EXPECT_EQ(OnChannelOpened(channelId, peerUuid, isServer), SOFTBUS_OK);
615 }
616
617 /*
618 * @tc.name: OnChannelOpened_003
619 * @tc.desc: oldChannelId != INVALID_CHANNEL_ID
620 * @tc.type: FUNC
621 * @tc.require: 1
622 */
623 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpened_003, TestSize.Level1)
624 {
625 int32_t channelId = 10;
626 unsigned char isServer = true;
627 const char *peerUuid = nullptr;
628 ClearSyncChannelInfo();
629
630 SyncChannelInfo *info = CreateSyncChannelInfo(NODE_NETWORK_ID);
631 if (info == nullptr) {
632 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
633 return;
634 }
635 info->serverChannelId = 100;
636 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
637
638 NiceMock<LnnNetLedgertInterfaceMock> lnnNetLedgerMock;
639 NiceMock<LnnTransInterfaceMock> lnnTransMock;
640 EXPECT_CALL(lnnNetLedgerMock, LnnConvertDlId(_, _, _, _, _))
641 .WillRepeatedly(DoAll(SetArrayArgument<3>(NETWORKID, NETWORKID + LEN), Return(SOFTBUS_OK)));
642 EXPECT_EQ(OnChannelOpened(channelId, peerUuid, isServer), SOFTBUS_OK);
643 }
644
645 /*
646 * @tc.name: OnChannelCloseCommon_001
647 * @tc.desc: info->serverChannelId == channelId
648 * @tc.type: FUNC
649 * @tc.require: 1
650 */
651 HWTEST_F(LNNSyncInfoManagerTest, OnChannelCloseCommon_001, TestSize.Level1)
652 {
653 int32_t channelId = 10;
654 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
655 if (info == nullptr) {
656 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
657 return;
658 }
659 info->serverChannelId = channelId;
660
661 OnChannelCloseCommon(info, channelId);
662 EXPECT_EQ(info->serverChannelId, INVALID_CHANNEL_ID);
663 SoftBusFree(info);
664 }
665
666 /*
667 * @tc.name: OnChannelCloseCommon_002
668 * @tc.desc: oldChannelId != INVALID_CHANNEL_ID
669 * @tc.type: FUNC
670 * @tc.require: 1
671 */
672 HWTEST_F(LNNSyncInfoManagerTest, OnChannelCloseCommon_002, TestSize.Level1)
673 {
674 int32_t channelId = 10;
675 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
676 if (info == nullptr) {
677 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
678 return;
679 }
680 info->serverChannelId = 1;
681
682 OnChannelCloseCommon(info, channelId);
683 EXPECT_EQ(info->clientChannelId, INVALID_CHANNEL_ID);
684 SoftBusFree(info);
685 }
686
687 /*
688 * @tc.name: OnChannelCloseCommon_003
689 * @tc.desc: info->serverChannelId == INVALID_CHANNEL_ID
690 * @tc.type: FUNC
691 * @tc.require: 1
692 */
693 HWTEST_F(LNNSyncInfoManagerTest, OnChannelCloseCommon_003, TestSize.Level1)
694 {
695 int32_t channelId = 10;
696 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
697 if (info == nullptr) {
698 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
699 return;
700 }
701 info->serverChannelId = INVALID_CHANNEL_ID;
702
703 OnChannelCloseCommon(info, channelId);
704 }
705
706 /*
707 * @tc.name: OnChannelOpenFailed_001
708 * @tc.desc: LnnConvertDlId(peerUuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK
709 * @tc.type: FUNC
710 * @tc.require: 1
711 */
712 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpenFailed_001, TestSize.Level1)
713 {
714 int32_t channelId = 10;
715 const char *peerUuid = nullptr;
716 NiceMock<LnnNetLedgertInterfaceMock> mock;
717 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
718
719 OnChannelOpenFailed(channelId, peerUuid);
720 }
721
722 /*
723 * @tc.name: OnChannelOpenFailed_002
724 * @tc.desc: info == nullptr
725 * @tc.type: FUNC
726 * @tc.require: 1
727 */
728 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpenFailed_002, TestSize.Level1)
729 {
730 int32_t channelId = 10;
731 const char *peerUuid = nullptr;
732
733 auto mockHandler = [](const char *srcId, IdCategory srcIdType, IdCategory dstIdType, char *dstIdBuf,
__anon95b434e50102(const char *srcId, IdCategory srcIdType, IdCategory dstIdType, char *dstIdBuf, uint32_t dstIdBufLen) 734 uint32_t dstIdBufLen) {
735 memcpy_s(dstIdBuf, NETWORK_ID_BUF_LEN, "abc", sizeof("abc"));
736 return SOFTBUS_OK;
737 };
738
739 NiceMock<LnnNetLedgertInterfaceMock> mock;
740 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).Times(1).WillOnce(Invoke(mockHandler));
741
742 ClearSyncChannelInfo();
743
744 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
745 if (msg == nullptr) {
746 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
747 return;
748 }
749 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
750 if (info == nullptr) {
751 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
752 return;
753 }
754 info->clientChannelId = 1;
755 ListTailInsert(&info->syncMsgList, &msg->node);
756 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
757
758 OnChannelOpenFailed(channelId, peerUuid);
759 ClearSyncChannelInfo();
760 }
761
762 /*
763 * @tc.name: OnChannelOpenFailed_003
764 * @tc.desc: SUCCESS
765 * @tc.type: FUNC
766 * @tc.require: 1
767 */
768 HWTEST_F(LNNSyncInfoManagerTest, OnChannelOpenFailed_003, TestSize.Level1)
769 {
770 int32_t channelId = 10;
771 const char *peerUuid = nullptr;
772
773 auto mockHandler = [](const char *srcId, IdCategory srcIdType, IdCategory dstIdType, char *dstIdBuf,
__anon95b434e50202(const char *srcId, IdCategory srcIdType, IdCategory dstIdType, char *dstIdBuf, uint32_t dstIdBufLen) 774 uint32_t dstIdBufLen) {
775 memcpy_s(dstIdBuf, NETWORK_ID_BUF_LEN, "0123456789", sizeof("0123456789"));
776 return SOFTBUS_OK;
777 };
778
779 NiceMock<LnnNetLedgertInterfaceMock> mock;
780 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).Times(1).WillOnce(Invoke(mockHandler));
781
782 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
783 if (msg == nullptr) {
784 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
785 return;
786 }
787 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
788 if (info == nullptr) {
789 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
790 return;
791 }
792 info->clientChannelId = 1;
793 info->serverChannelId = channelId;
794
795 ListTailInsert(&info->syncMsgList, &msg->node);
796 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
797
798 OnChannelOpenFailed(channelId, peerUuid);
799 ClearSyncChannelInfo();
800 }
801
802 /*
803 * @tc.name: OnChannelClosed_001
804 * @tc.desc: info == nullptr
805 * @tc.type: FUNC
806 * @tc.require: 1
807 */
808 HWTEST_F(LNNSyncInfoManagerTest, OnChannelClosed_001, TestSize.Level1)
809 {
810 int32_t channelId = 10;
811 ClearSyncChannelInfo();
812
813 OnChannelClosed(channelId);
814 }
815
816 /*
817 * @tc.name: OnChannelClosed_002
818 * @tc.desc: info == nullptr
819 * @tc.type: FUNC
820 * @tc.require: 1
821 */
822 HWTEST_F(LNNSyncInfoManagerTest, OnChannelClosed_002, TestSize.Level1)
823 {
824 int32_t channelId = 10;
825
826 ClearSyncChannelInfo();
827 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
828 if (info == nullptr) {
829 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
830 return;
831 }
832 info->clientChannelId = 10;
833 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
834
835 OnChannelClosed(channelId);
836 }
837
838 /*
839 * @tc.name: OnMessageReceived_001
840 * @tc.desc: len <= MSG_HEAD_LEN & len <= MSG_HEAD_LEN & info == nullptr
841 * @tc.type: FUNC
842 * @tc.require: 1
843 */
844 HWTEST_F(LNNSyncInfoManagerTest, OnMessageReceived_001, TestSize.Level1)
845 {
846 int32_t channelId = 10;
847 uint32_t len = 10;
848 OnMessageReceived(channelId, nullptr, len);
849
850 len = 1;
851 OnMessageReceived(channelId, MSG_DATA, len);
852
853 len = 10;
854 ListDelete(&g_syncInfoManager.channelInfoList);
855 OnMessageReceived(channelId, MSG_DATA, len);
856 }
857
858 /*
859 * @tc.name: OnMessageReceived_002
860 * @tc.desc: type < 0 || type >= LNN_INFO_TYPE_COUNT
861 * @tc.type: FUNC
862 * @tc.require: 1
863 */
864 HWTEST_F(LNNSyncInfoManagerTest, OnMessageReceived_002, TestSize.Level1)
865 {
866 int32_t channelId = 10;
867 uint32_t len = 10;
868
869 ListDelete(&g_syncInfoManager.channelInfoList);
870 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
871 if (info == nullptr) {
872 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
873 return;
874 }
875 info->clientChannelId = 10;
876 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
877
878 OnMessageReceived(channelId, MSG_DATA1, len);
879 SoftBusFree(info);
880 }
881
882 /*
883 * @tc.name: OnMessageReceived_003
884 * @tc.desc: handler == nullptr
885 * @tc.type: FUNC
886 * @tc.require: 1
887 */
888 HWTEST_F(LNNSyncInfoManagerTest, OnMessageReceived_003, TestSize.Level1)
889 {
890 int32_t channelId = 10;
891 uint32_t len = 10;
892
893 ListDelete(&g_syncInfoManager.channelInfoList);
894 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
895 if (info == nullptr) {
896 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
897 return;
898 }
899 info->clientChannelId = 10;
900 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
901 g_syncInfoManager.handlers[1] = nullptr;
902
903 OnMessageReceived(channelId, MSG_DATA2, len);
904 SoftBusFree(info);
905 }
906
907 /*
908 * @tc.name: PackBleOfflineMsg_001
909 * @tc.desc: json == nullptr
910 * @tc.type: FUNC
911 * @tc.require: 1
912 */
913 HWTEST_F(LNNSyncInfoManagerTest, PackBleOfflineMsg_001, TestSize.Level1)
914 {
915 int64_t connCap = 0;
916 int32_t networkType = 0;
917 int64_t authSeq = 0;
918
919 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
920 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(nullptr));
921
922 EXPECT_EQ(PackBleOfflineMsg(connCap, networkType, authSeq), nullptr);
923 }
924
925 /*
926 * @tc.name: PackBleOfflineMsg_002
927 * @tc.desc: !JSON_AddInt64ToObject(json, NETWORK_SYNC_CONN_CAP, connCap)
928 * @tc.type: FUNC
929 * @tc.require: 1
930 */
931 HWTEST_F(LNNSyncInfoManagerTest, PackBleOfflineMsg_002, TestSize.Level1)
932 {
933 int64_t connCap = 0;
934 int32_t networkType = 0;
935 int64_t authSeq = 0;
936
937 JsonObj json;
938 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
939 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
940 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(&json));
941 EXPECT_CALL(mock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(false));
942 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(false));
943 EXPECT_CALL(mock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(false));
944
945 EXPECT_EQ(PackBleOfflineMsg(connCap, networkType, authSeq), nullptr);
946 }
947
948 /*
949 * @tc.name: PackBleOfflineMsg_003
950 * @tc.desc: SUCCESS
951 * @tc.type: FUNC
952 * @tc.require: 1
953 */
954 HWTEST_F(LNNSyncInfoManagerTest, PackBleOfflineMsg_003, TestSize.Level1)
955 {
956 int64_t connCap = 0;
957 int32_t networkType = 0;
958 int64_t authSeq = 0;
959
960 JsonObj json;
961 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
962 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
963 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(&json));
964 EXPECT_CALL(mock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
965 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
966 EXPECT_CALL(mock, JSON_AddInt64ToObject(_, _, _)).WillRepeatedly(Return(true));
967 EXPECT_CALL(mock, JSON_PrintUnformatted(_)).Times(1).WillRepeatedly(Return(nullptr));
968
969 EXPECT_EQ(PackBleOfflineMsg(connCap, networkType, authSeq), nullptr);
970 }
971
972 /*
973 * @tc.name: PackWifiOfflineMsg_001
974 * @tc.desc: json == nullptr
975 * @tc.type: FUNC
976 * @tc.require: 1
977 */
978 HWTEST_F(LNNSyncInfoManagerTest, PackWifiOfflineMsg_001, TestSize.Level1)
979 {
980 int64_t authPort = 0;
981 char offlineCode[] = { 0 };
982
983 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
984 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(nullptr));
985
986 EXPECT_EQ(PackWifiOfflineMsg(authPort, offlineCode), nullptr);
987 }
988
989 /*
990 * @tc.name: PackWifiOfflineMsg_002
991 * @tc.desc: !JSON_AddInt64ToObject(json, NETWORK_SYNC_CONN_CAP, connCap)
992 * @tc.type: FUNC
993 * @tc.require: 1
994 */
995 HWTEST_F(LNNSyncInfoManagerTest, PackWifiOfflineMsg_002, TestSize.Level1)
996 {
997 int64_t authPort = 0;
998 char offlineCode[] = { 0 };
999
1000 JsonObj json;
1001 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1002 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1003 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(&json));
1004 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(false));
1005 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(false));
1006 EXPECT_CALL(mock, JSON_AddStringToObject(_, _, _)).WillRepeatedly(Return(false));
1007
1008 EXPECT_EQ(PackWifiOfflineMsg(authPort, offlineCode), nullptr);
1009 }
1010
1011 /*
1012 * @tc.name: PackWifiOfflineMsg_003
1013 * @tc.desc: SUCCESS
1014 * @tc.type: FUNC
1015 * @tc.require: 1
1016 */
1017 HWTEST_F(LNNSyncInfoManagerTest, PackWifiOfflineMsg_003, TestSize.Level1)
1018 {
1019 int64_t authPort = 0;
1020 char offlineCode[] = { 0 };
1021
1022 JsonObj json;
1023 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1024 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1025 EXPECT_CALL(mock, JSON_CreateObject()).WillRepeatedly(Return(&json));
1026 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
1027 EXPECT_CALL(mock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
1028 EXPECT_CALL(mock, JSON_AddStringToObject(_, _, _)).WillRepeatedly(Return(true));
1029 EXPECT_CALL(mock, JSON_PrintUnformatted(_)).Times(1).WillOnce(Return(nullptr));
1030
1031 EXPECT_EQ(PackWifiOfflineMsg(authPort, offlineCode), nullptr);
1032 }
1033
1034 /*
1035 * @tc.name: CheckPeerAuthSeq_001
1036 * @tc.desc: LnnConvertDlId(uuid, CATEGORY_UUID, CATEGORY_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK
1037 * @tc.type: FUNC
1038 * @tc.require: 1
1039 */
1040 HWTEST_F(LNNSyncInfoManagerTest, CheckPeerAuthSeq_001, TestSize.Level1)
1041 {
1042 const char *uuid = nullptr;
1043 int64_t peerAuthSeq = 0;
1044
1045 NiceMock<LnnNetLedgertInterfaceMock> mock;
1046 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1047
1048 EXPECT_EQ(CheckPeerAuthSeq(uuid, peerAuthSeq), SOFTBUS_ERR);
1049 }
1050
1051 /*
1052 * @tc.name: CheckPeerAuthSeq_002
1053 * @tc.desc: AuthGetLatestAuthSeqListByType(udid, localAuthSeq, authVerifyTime, DISCOVERY_TYPE_BLE) != SOFTBUS_OK
1054 * @tc.type: FUNC
1055 * @tc.require: 1
1056 */
1057 HWTEST_F(LNNSyncInfoManagerTest, CheckPeerAuthSeq_002, TestSize.Level1)
1058 {
1059 const char *uuid = nullptr;
1060 int64_t peerAuthSeq = 0;
1061
1062 NiceMock<LnnNetLedgertInterfaceMock> mock;
1063 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1064 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1065 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType).WillRepeatedly(Return(SOFTBUS_ERR));
1066
1067 EXPECT_EQ(CheckPeerAuthSeq(uuid, peerAuthSeq), SOFTBUS_ERR);
1068 }
1069
1070 /*
1071 * @tc.name: CheckPeerAuthSeq_003
1072 * @tc.desc: peerAuthSeq == 0
1073 * @tc.type: FUNC
1074 * @tc.require: 1
1075 */
1076 HWTEST_F(LNNSyncInfoManagerTest, CheckPeerAuthSeq_003, TestSize.Level1)
1077 {
1078 const char *uuid = nullptr;
1079 int64_t peerAuthSeq = 0;
1080
1081 NiceMock<LnnNetLedgertInterfaceMock> mock;
1082 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1083 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1084 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType).WillRepeatedly(Return(SOFTBUS_OK));
1085
1086 EXPECT_NE(CheckPeerAuthSeq(uuid, peerAuthSeq), SOFTBUS_OK);
1087 }
1088
1089 /*
1090 * @tc.name: CheckPeerAuthSeq_004
1091 * @tc.desc: return SOFTBUS_OK;
1092 * @tc.type: FUNC
1093 * @tc.require: 1
1094 */
1095 HWTEST_F(LNNSyncInfoManagerTest, CheckPeerAuthSeq_004, TestSize.Level1)
1096 {
1097 const char *uuid = nullptr;
1098 int64_t peerAuthSeq = 10;
1099 int64_t newLocalAuthSeq[2] = { 10, 2 };
1100
1101 NiceMock<LnnNetLedgertInterfaceMock> mock;
1102 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1103 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1104 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
1105 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
1106
1107 EXPECT_EQ(CheckPeerAuthSeq(uuid, peerAuthSeq), SOFTBUS_OK);
1108 }
1109
1110 /*
1111 * @tc.name: BleOffLineProcess_001
1112 * @tc.desc: return SOFTBUS_OK;
1113 * @tc.type: FUNC
1114 * @tc.require: 1
1115 */
1116 HWTEST_F(LNNSyncInfoManagerTest, BleOffLineProcess_001, TestSize.Level1)
1117 {
1118 AuthTransData data;
1119 data.data = new uint8_t(0);
1120 AuthHandle authHandle;
1121
1122 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1123 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(nullptr));
1124
1125 BleOffLineProcess(&data, authHandle);
1126 delete (data.data);
1127 data.data = nullptr;
1128 }
1129
1130 /*
1131 * @tc.name: BleOffLineProcess_002
1132 * @tc.desc: !JSON_GetInt64FromOject(json, NETWORK_SYNC_CONN_CAP, &peerConnCap) == true
1133 * @tc.type: FUNC
1134 * @tc.require: 1
1135 */
1136 HWTEST_F(LNNSyncInfoManagerTest, BleOffLineProcess_002, TestSize.Level1)
1137 {
1138 AuthTransData data;
1139 data.data = new uint8_t(0);
1140 AuthHandle authHandle;
1141
1142 JsonObj json;
1143 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1144 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1145 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1146 EXPECT_CALL(mock, JSON_GetInt64FromOject(_, _, _)).WillRepeatedly(Return(false));
1147
1148 BleOffLineProcess(&data, authHandle);
1149 delete (data.data);
1150 data.data = nullptr;
1151 }
1152
1153 /*
1154 * @tc.name: BleOffLineProcess_003
1155 * @tc.desc: LnnHasCapability((uint32_t)peerConnCap, BIT_BLE) == true
1156 * @tc.type: FUNC
1157 * @tc.require: 1
1158 */
1159 HWTEST_F(LNNSyncInfoManagerTest, BleOffLineProcess_003, TestSize.Level1)
1160 {
1161 AuthTransData data;
1162 data.data = new uint8_t(0);
1163 AuthHandle authHandle;
1164
1165 JsonObj json;
1166 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1167 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1168 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1169 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1170 EXPECT_CALL(mock, JSON_GetInt64FromOject(_, _, _)).WillRepeatedly(Return(true));
1171 EXPECT_CALL(ledgerMock, LnnHasCapability(_, _)).WillRepeatedly(Return(true));
1172
1173 BleOffLineProcess(&data, authHandle);
1174 delete (data.data);
1175 data.data = nullptr;
1176 }
1177
1178 /*
1179 * @tc.name: BleOffLineProcess_004
1180 * @tc.desc: AuthGetDeviceUuid(authHandle.authId, uuid, UUID_BUF_LEN) != SOFTBUS_OK
1181 * @tc.type: FUNC
1182 * @tc.require: 1
1183 */
1184 HWTEST_F(LNNSyncInfoManagerTest, BleOffLineProcess_004, TestSize.Level1)
1185 {
1186 AuthTransData data;
1187 data.data = new uint8_t(0);
1188 AuthHandle authHandle;
1189
1190 JsonObj json;
1191 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1192 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1193 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1194 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1195
1196 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1197 EXPECT_CALL(mock, JSON_GetInt64FromOject(_, _, _)).WillRepeatedly(Return(true));
1198 EXPECT_CALL(ledgerMock, LnnHasCapability(_, _)).WillRepeatedly(Return(false));
1199 EXPECT_CALL(lnnServerMock, AuthGetDeviceUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1200
1201 BleOffLineProcess(&data, authHandle);
1202 delete (data.data);
1203 data.data = nullptr;
1204 }
1205
1206 /*
1207 * @tc.name: BleOffLineProcess_005
1208 * @tc.desc: LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_BLE) != SOFTBUS_OK
1209 * @tc.type: FUNC
1210 * @tc.require: 1
1211 */
1212 HWTEST_F(LNNSyncInfoManagerTest, BleOffLineProcess_005, TestSize.Level1)
1213 {
1214 AuthTransData data;
1215 data.data = new uint8_t(0);
1216 AuthHandle authHandle;
1217 int64_t newLocalAuthSeq[2] = { 1, 2 };
1218
1219 JsonObj json;
1220 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1221 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1222 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1223 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1224
1225 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1226 EXPECT_CALL(mock, JSON_GetInt64FromOject(_, _, _))
1227 .WillOnce(Return(true))
1228 .WillOnce(DoAll(SetArgPointee<2>(10), Return(true)));
1229 EXPECT_CALL(ledgerMock, LnnHasCapability(_, _)).WillRepeatedly(Return(false));
1230 EXPECT_CALL(lnnServerMock, AuthGetDeviceUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1231 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1232 EXPECT_CALL(ledgerMock, AuthGetLatestAuthSeqListByType)
1233 .WillOnce(DoAll(SetArrayArgument<1>(newLocalAuthSeq, newLocalAuthSeq + 2), Return(SOFTBUS_OK)));
1234
1235 BleOffLineProcess(&data, authHandle);
1236 delete (data.data);
1237 data.data = nullptr;
1238 }
1239
1240 /*
1241 * @tc.name: CheckWifiOfflineMsgResult_001
1242 * @tc.desc: LnnGetRemoteNumInfo(networkId, NUM_KEY_AUTH_PORT, &port) != 0
1243 * @tc.type: FUNC
1244 * @tc.require: 1
1245 */
1246 HWTEST_F(LNNSyncInfoManagerTest, CheckWifiOfflineMsgResult_001, TestSize.Level1)
1247 {
1248 int32_t authPort = 0;
1249 const char *offlineCode = nullptr;
1250
1251 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1252 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1253
1254 EXPECT_EQ(CheckWifiOfflineMsgResult(NETWORKID, authPort, offlineCode), false);
1255 }
1256
1257 /*
1258 * @tc.name: CheckWifiOfflineMsgResult_002
1259 * @tc.desc: LnnGetNodeKeyInfo(networkId, NODE_KEY_BLE_OFFLINE_CODE, remoteOfflineCode, WIFI_OFFLINE_CODE_LEN) != 0
1260 * @tc.type: FUNC
1261 * @tc.require: 1
1262 */
1263 HWTEST_F(LNNSyncInfoManagerTest, CheckWifiOfflineMsgResult_002, TestSize.Level1)
1264 {
1265 int32_t authPort = 0;
1266 const char *offlineCode = nullptr;
1267
1268 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1269 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1270 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _)).WillOnce(Return(SOFTBUS_OK));
1271 EXPECT_CALL(ledgerMock, LnnGetNodeKeyInfo(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1272
1273 EXPECT_EQ(CheckWifiOfflineMsgResult(NETWORKID, authPort, offlineCode), false);
1274 }
1275
1276 /*
1277 * @tc.name: CheckWifiOfflineMsgResult_003
1278 * @tc.desc: ConvertBytesToHexString != SOFTBUS_OK
1279 * @tc.type: FUNC
1280 * @tc.require: 1
1281 */
1282 HWTEST_F(LNNSyncInfoManagerTest, CheckWifiOfflineMsgResult_003, TestSize.Level1)
1283 {
1284 int32_t authPort = 0;
1285 const char *offlineCode = nullptr;
1286
1287 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1288 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1289 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1290
1291 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _)).WillOnce(Return(SOFTBUS_OK));
1292 EXPECT_CALL(ledgerMock, LnnGetNodeKeyInfo(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1293 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1294
1295 EXPECT_EQ(CheckWifiOfflineMsgResult(NETWORKID, authPort, offlineCode), false);
1296 }
1297
1298 /*
1299 * @tc.name: CheckWifiOfflineMsgResult_004
1300 * @tc.desc: strcmp(convertOfflineCode, offlineCode) != 0 || port != authPort
1301 * @tc.type: FUNC
1302 * @tc.require: 1
1303 */
1304 HWTEST_F(LNNSyncInfoManagerTest, CheckWifiOfflineMsgResult_004, TestSize.Level1)
1305 {
1306 int32_t authPort = 0;
1307 int32_t newAuthPort = 10;
1308 char offlineCode[] = "123";
1309
1310 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1311 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1312 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1313
1314 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _))
1315 .Times(1)
1316 .WillOnce(DoAll(SetArgPointee<2>(newAuthPort), Return(SOFTBUS_OK)));
1317 EXPECT_CALL(ledgerMock, LnnGetNodeKeyInfo(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1318 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1319
1320 EXPECT_EQ(CheckWifiOfflineMsgResult(NETWORKID, authPort, offlineCode), false);
1321 }
1322
1323 /*
1324 * @tc.name: CheckWifiOfflineMsgResult_005
1325 * @tc.desc: return true
1326 * @tc.type: FUNC
1327 * @tc.require: 1
1328 */
1329 HWTEST_F(LNNSyncInfoManagerTest, CheckWifiOfflineMsgResult_005, TestSize.Level1)
1330 {
1331 int32_t authPort = 0;
1332 int32_t newAuthPort = 0;
1333 char offlineCode[] = "123";
1334
1335 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1336 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1337 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1338
1339 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _))
1340 .Times(1)
1341 .WillOnce(DoAll(SetArgPointee<2>(newAuthPort), Return(SOFTBUS_OK)));
1342 EXPECT_CALL(ledgerMock, LnnGetNodeKeyInfo(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1343 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _))
1344 .WillOnce(DoAll(SetArrayArgument<0>(offlineCode, offlineCode + 3), Return(SOFTBUS_OK)));
1345
1346 EXPECT_EQ(CheckWifiOfflineMsgResult(NETWORKID, authPort, offlineCode), true);
1347 }
1348
1349 /*
1350 * @tc.name: WlanOffLineProcess_001
1351 * @tc.desc: json == nullptr
1352 * @tc.type: FUNC
1353 * @tc.require: 1
1354 */
1355 HWTEST_F(LNNSyncInfoManagerTest, WlanOffLineProcess_001, TestSize.Level1)
1356 {
1357 AuthTransData data;
1358 data.data = new uint8_t(0);
1359 AuthHandle authHandle;
1360
1361 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1362 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(nullptr));
1363
1364 WlanOffLineProcess(&data, authHandle);
1365 delete (data.data);
1366 data.data = nullptr;
1367 }
1368
1369 /*
1370 * @tc.name: WlanOffLineProcess_002
1371 * @tc.desc: !JSON_GetInt32FromOject(json, NETWORK_OFFLINE_PORT, &authPort) == false
1372 * @tc.type: FUNC
1373 * @tc.require: 1
1374 */
1375 HWTEST_F(LNNSyncInfoManagerTest, WlanOffLineProcess_002, TestSize.Level1)
1376 {
1377 AuthTransData data;
1378 data.data = new uint8_t(0);
1379 AuthHandle authHandle;
1380
1381 JsonObj json;
1382 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1383 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1384 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1385 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillRepeatedly(Return(false));
1386
1387 WlanOffLineProcess(&data, authHandle);
1388 delete (data.data);
1389 data.data = nullptr;
1390 }
1391
1392 /*
1393 * @tc.name: WlanOffLineProcess_003
1394 * @tc.desc: AuthGetDeviceUuid(authHandle.authId, uuid, UUID_BUF_LEN) != SOFTBUS_OK
1395 * @tc.type: FUNC
1396 * @tc.require: 1
1397 */
1398 HWTEST_F(LNNSyncInfoManagerTest, WlanOffLineProcess_003, TestSize.Level1)
1399 {
1400 AuthTransData data;
1401 data.data = new uint8_t(0);
1402 AuthHandle authHandle;
1403
1404 JsonObj json;
1405 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1406 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1407 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1408 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1409 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillRepeatedly(Return(true));
1410 EXPECT_CALL(mock, JSON_GetStringFromObject(_, _, _, _)).WillRepeatedly(Return(true));
1411 EXPECT_CALL(lnnServerMock, AuthGetDeviceUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1412
1413 WlanOffLineProcess(&data, authHandle);
1414 delete (data.data);
1415 data.data = nullptr;
1416 }
1417
1418 /*
1419 * @tc.name: WlanOffLineProcess_004
1420 * @tc.desc: LnnConvertDlId(uuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK
1421 * @tc.type: FUNC
1422 * @tc.require: 1
1423 */
1424 HWTEST_F(LNNSyncInfoManagerTest, WlanOffLineProcess_004, TestSize.Level1)
1425 {
1426 AuthTransData data;
1427 data.data = new uint8_t(0);
1428 AuthHandle authHandle;
1429
1430 JsonObj json;
1431 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1432 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1433 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1434 NiceMock<LnnNetLedgertInterfaceMock> lnnNetLedgertmock;
1435 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1436 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillRepeatedly(Return(true));
1437 EXPECT_CALL(mock, JSON_GetStringFromObject(_, _, _, _)).WillRepeatedly(Return(true));
1438 EXPECT_CALL(lnnServerMock, AuthGetDeviceUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1439 EXPECT_CALL(lnnNetLedgertmock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1440
1441 WlanOffLineProcess(&data, authHandle);
1442 delete (data.data);
1443 data.data = nullptr;
1444 }
1445
1446 /*
1447 * @tc.name: WlanOffLineProcess_005
1448 * @tc.desc: CheckWifiOfflineMsgResult(networkId, authPort, convertOfflineCode) == true &&
1449 * LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_WLAN) != SOFTBUS_OK
1450 * @tc.type: FUNC
1451 * @tc.require: 1
1452 */
1453 HWTEST_F(LNNSyncInfoManagerTest, WlanOffLineProcess_005, TestSize.Level1)
1454 {
1455 AuthTransData data;
1456 data.data = new uint8_t(0);
1457 AuthHandle authHandle;
1458 int32_t newAuthPort = 12345;
1459 char offlineCode[] = "123";
1460
1461 JsonObj json;
1462 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1463 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1464 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1465 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
1466 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
1467 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1468 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(newAuthPort), Return(true)));
1469 EXPECT_CALL(mock, JSON_GetStringFromObject(_, _, _, _))
1470 .WillOnce(DoAll(SetArrayArgument<2>(offlineCode, offlineCode + 3), Return(true)));
1471 EXPECT_CALL(lnnServerMock, AuthGetDeviceUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1472 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1473
1474 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumInfoByIfnameIdx(_, _, _, _))
1475 .Times(1)
1476 .WillOnce(DoAll(SetArgPointee<2>(newAuthPort), Return(SOFTBUS_OK)));
1477 EXPECT_CALL(ledgerMock, LnnGetNodeKeyInfo(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1478 EXPECT_CALL(mock, ConvertBytesToHexString(_, _, _, _))
1479 .WillOnce(DoAll(SetArrayArgument<0>(offlineCode, offlineCode + 3), Return(SOFTBUS_OK)));
1480
1481 WlanOffLineProcess(&data, authHandle);
1482 delete (data.data);
1483 data.data = nullptr;
1484 }
1485
1486 /*
1487 * @tc.name: OnP2pNetworkingDataRecv_001
1488 * @tc.desc: data == nullptr
1489 * @tc.type: FUNC
1490 * @tc.require: 1
1491 */
1492 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_001, TestSize.Level1)
1493 {
1494 AuthTransData data;
1495 data.data = new uint8_t(0);
1496 data.len = 0;
1497 AuthHandle authHandle;
1498
1499 OnP2pNetworkingDataRecv(authHandle, &data);
1500 }
1501
1502 /*
1503 * @tc.name: OnP2pNetworkingDataRecv_002
1504 * @tc.desc: data->module != MODULE_P2P_NETWORKING_SYNC
1505 * @tc.type: FUNC
1506 * @tc.require: 1
1507 */
1508 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_002, TestSize.Level1)
1509 {
1510 AuthTransData data;
1511 data.data = new uint8_t(0);
1512 data.len = LEN;
1513 data.module = ConnModule::MODULE_TRUST_ENGINE;
1514 AuthHandle authHandle;
1515
1516 OnP2pNetworkingDataRecv(authHandle, &data);
1517 delete (data.data);
1518 data.data = nullptr;
1519 }
1520
1521 /*
1522 * @tc.name: OnP2pNetworkingDataRecv_003
1523 * @tc.desc: json == nullptr
1524 * @tc.type: FUNC
1525 * @tc.require: 1
1526 */
1527 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_003, TestSize.Level1)
1528 {
1529 AuthTransData data;
1530 data.data = new uint8_t(0);
1531 data.len = LEN;
1532 data.module = ConnModule::MODULE_P2P_NETWORKING_SYNC;
1533 AuthHandle authHandle;
1534
1535 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1536 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(nullptr));
1537
1538 OnP2pNetworkingDataRecv(authHandle, &data);
1539 delete (data.data);
1540 data.data = nullptr;
1541 }
1542
1543 /*
1544 * @tc.name: OnP2pNetworkingDataRecv_004
1545 * @tc.desc: JSON_GetInt32FromOject(json, NETWORK_SYNC_TYPE, &peerNetworkType) == false
1546 * @tc.type: FUNC
1547 * @tc.require: 1
1548 */
1549 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_004, TestSize.Level1)
1550 {
1551 AuthTransData data;
1552 data.data = new uint8_t(0);
1553 data.len = LEN;
1554 data.module = ConnModule::MODULE_P2P_NETWORKING_SYNC;
1555 AuthHandle authHandle;
1556
1557 JsonObj json;
1558 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1559 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1560 EXPECT_CALL(mock, JSON_Parse(_, _)).WillRepeatedly(Return(&json));
1561 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillRepeatedly(Return(false));
1562
1563 OnP2pNetworkingDataRecv(authHandle, &data);
1564 delete (data.data);
1565 data.data = nullptr;
1566 }
1567
1568 /*
1569 * @tc.name: OnP2pNetworkingDataRecv_005
1570 * @tc.desc: peerNetworkType == DISCOVERY_TYPE_BLE
1571 * @tc.type: FUNC
1572 * @tc.require: 1
1573 */
1574 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_005, TestSize.Level1)
1575 {
1576 AuthTransData data;
1577 data.data = new uint8_t(0);
1578 data.len = LEN;
1579 data.module = ConnModule::MODULE_P2P_NETWORKING_SYNC;
1580 AuthHandle authHandle;
1581 int32_t peerNetworkType = DISCOVERY_TYPE_BLE;
1582
1583 JsonObj json;
1584 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1585 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1586 EXPECT_CALL(mock, JSON_Parse(_, _)).WillOnce(Return(&json)).WillOnce(nullptr);
1587 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(peerNetworkType), Return(true)));
1588
1589 OnP2pNetworkingDataRecv(authHandle, &data);
1590 delete (data.data);
1591 data.data = nullptr;
1592 }
1593
1594 /*
1595 * @tc.name: OnP2pNetworkingDataRecv_006
1596 * @tc.desc: peerNetworkType == DISCOVERY_TYPE_WIFI
1597 * @tc.type: FUNC
1598 * @tc.require: 1
1599 */
1600 HWTEST_F(LNNSyncInfoManagerTest, OnP2pNetworkingDataRecv_006, TestSize.Level1)
1601 {
1602 AuthTransData data;
1603 data.data = new uint8_t(0);
1604 data.len = LEN;
1605 data.module = ConnModule::MODULE_P2P_NETWORKING_SYNC;
1606 AuthHandle authHandle;
1607 int32_t peerNetworkType = DISCOVERY_TYPE_WIFI;
1608
1609 JsonObj json;
1610 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
1611 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
1612 EXPECT_CALL(mock, JSON_Parse(_, _)).WillOnce(Return(&json)).WillOnce(nullptr);
1613 EXPECT_CALL(mock, JSON_GetInt32FromOject(_, _, _)).WillOnce(DoAll(SetArgPointee<2>(peerNetworkType), Return(true)));
1614
1615 OnP2pNetworkingDataRecv(authHandle, &data);
1616 delete (data.data);
1617 data.data = nullptr;
1618 }
1619
1620 /*
1621 * @tc.name: LnnSyncManagerHandleOffline_001
1622 * @tc.desc: item == nullptr
1623 * @tc.type: FUNC
1624 * @tc.require: 1
1625 */
1626 HWTEST_F(LNNSyncInfoManagerTest, LnnSyncManagerHandleOffline_001, TestSize.Level1)
1627 {
1628 ListDelete(&g_syncInfoManager.channelInfoList);
1629
1630 LnnSyncManagerHandleOffline(NETWORKID);
1631 }
1632
1633 /*
1634 * @tc.name: LnnSyncManagerHandleOffline_002
1635 * @tc.desc: item->clientChannelId != INVALID_CHANNEL_ID && item->serverChannelId != INVALID_CHANNEL_ID
1636 * @tc.type: FUNC
1637 * @tc.require: 1
1638 */
1639 HWTEST_F(LNNSyncInfoManagerTest, LnnSyncManagerHandleOffline_002, TestSize.Level1)
1640 {
1641 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
1642 if (info == nullptr) {
1643 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
1644 return;
1645 }
1646 info->clientChannelId = 10;
1647 info->serverChannelId = 10;
1648 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
1649
1650 NiceMock<LnnTransInterfaceMock> mock;
1651 EXPECT_CALL(mock, TransCloseNetWorkingChannel(_)).Times(2);
1652
1653 LnnSyncManagerHandleOffline(NETWORKID);
1654 }
1655
1656 /*
1657 * @tc.name: OnLnnOnlineStateChange_001
1658 * @tc.desc: info->event != LNN_EVENT_NODE_ONLINE_STATE_CHANGED
1659 * @tc.type: FUNC
1660 * @tc.require: 1
1661 */
1662 HWTEST_F(LNNSyncInfoManagerTest, OnLnnOnlineStateChange_001, TestSize.Level1)
1663 {
1664 LnnEventBasicInfo info;
1665 info.event = LNN_EVENT_IP_ADDR_CHANGED;
1666
1667 OnLnnOnlineStateChange(&info);
1668
1669 info.event = LNN_EVENT_NODE_ONLINE_STATE_CHANGED;
1670 OnLnnOnlineStateChange(&info);
1671 }
1672
1673 /*
1674 * @tc.name: OnWifiDirectSyncMsgRecv_001
1675 * @tc.desc: data == nullptr
1676 * @tc.type: FUNC
1677 * @tc.require: 1
1678 */
1679 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_001, TestSize.Level1)
1680 {
1681 AuthTransData *data = nullptr;
1682 AuthHandle authHandle;
1683 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, data));
1684 }
1685
1686 /*
1687 * @tc.name: OnWifiDirectSyncMsgRecv_002
1688 * @tc.desc: data->len <= MSG_HEAD_LEN
1689 * @tc.type: FUNC
1690 * @tc.require: 1
1691 */
1692 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_002, TestSize.Level1)
1693 {
1694 AuthTransData data;
1695 data.len = 0;
1696 data.data = new uint8_t(0);
1697 AuthHandle authHandle;
1698
1699 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1700 delete (data.data);
1701 data.data = nullptr;
1702 }
1703
1704 /*
1705 * @tc.name: OnWifiDirectSyncMsgRecv_003
1706 * @tc.desc: auth == nullptr
1707 * @tc.type: FUNC
1708 * @tc.require: 1
1709 */
1710 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_003, TestSize.Level1)
1711 {
1712 AuthTransData data;
1713 data.len = 10;
1714 data.data = new uint8_t(0);
1715 AuthHandle authHandle;
1716
1717 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1718 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(nullptr));
1719
1720 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1721 delete (data.data);
1722 data.data = nullptr;
1723 }
1724
1725 /*
1726 * @tc.name: OnWifiDirectSyncMsgRecv_004
1727 * @tc.desc: LnnGetNetworkIdByUdid(auth->udid, networkId, sizeof(networkId)) != SOFTBUS_OK
1728 * @tc.type: FUNC
1729 * @tc.require: 1
1730 */
1731 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_004, TestSize.Level1)
1732 {
1733 AuthTransData data;
1734 data.len = 10;
1735 data.data = new uint8_t(0);
1736 AuthHandle authHandle;
1737 AuthManager authManager;
1738
1739 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1740 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(&authManager));
1741 EXPECT_CALL(lnnSyncInfoMgrMock, LnnGetNetworkIdByUdid(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
1742 EXPECT_CALL(lnnSyncInfoMgrMock, DelDupAuthManager(_)).Times(1);
1743
1744 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1745 delete (data.data);
1746 data.data = nullptr;
1747 }
1748
1749 /*
1750 * @tc.name: OnWifiDirectSyncMsgRecv_005
1751 * @tc.desc: type < 0 || type >= LNN_INFO_TYPE_COUNT
1752 * @tc.type: FUNC
1753 * @tc.require: 1
1754 */
1755 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_005, TestSize.Level1)
1756 {
1757 AuthTransData data;
1758 data.len = 10;
1759 data.data = new uint8_t(0);
1760 AuthHandle authHandle;
1761 AuthManager authManager;
1762
1763 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1764 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(&authManager));
1765 EXPECT_CALL(lnnSyncInfoMgrMock, LnnGetNetworkIdByUdid(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
1766 EXPECT_CALL(lnnSyncInfoMgrMock, DelDupAuthManager(_)).Times(1);
1767
1768 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1769 delete (data.data);
1770 data.data = nullptr;
1771 }
1772
1773 /*
1774 * @tc.name: OnWifiDirectSyncMsgRecv_006
1775 * @tc.desc: handler == nullptr
1776 * @tc.type: FUNC
1777 * @tc.require: 1
1778 */
1779 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_006, TestSize.Level1)
1780 {
1781 AuthTransData data;
1782 data.len = 10;
1783 data.data = new uint8_t(10);
1784 AuthHandle authHandle;
1785 AuthManager authManager;
1786
1787 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1788 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(&authManager));
1789 EXPECT_CALL(lnnSyncInfoMgrMock, LnnGetNetworkIdByUdid(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
1790 EXPECT_CALL(lnnSyncInfoMgrMock, DelDupAuthManager(_)).Times(1);
1791
1792 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1793
1794 delete (data.data);
1795 data.data = nullptr;
1796 }
1797
1798 /*
1799 * @tc.name: OnWifiDirectSyncMsgRecv_007
1800 * @tc.desc: handler == nullptr
1801 * @tc.type: FUNC
1802 * @tc.require: 1
1803 */
1804 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_007, TestSize.Level1)
1805 {
1806 AuthTransData data;
1807 data.len = 10;
1808 data.data = new uint8_t(LNN_INFO_TYPE_NICK_NAME);
1809 AuthHandle authHandle;
1810 AuthManager authManager;
1811 g_syncInfoManager.handlers[LNN_INFO_TYPE_NICK_NAME] = nullptr;
1812
1813 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1814 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(&authManager));
1815 EXPECT_CALL(lnnSyncInfoMgrMock, LnnGetNetworkIdByUdid(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
1816 EXPECT_CALL(lnnSyncInfoMgrMock, DelDupAuthManager(_)).Times(1);
1817
1818 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1819
1820 delete (data.data);
1821 data.data = nullptr;
1822 }
1823
1824 /*
1825 * @tc.name: OnWifiDirectSyncMsgRecv_008
1826 * @tc.desc: SUCCESS
1827 * @tc.type: FUNC
1828 * @tc.require: 1
1829 */
1830 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncMsgRecv_008, TestSize.Level1)
1831 {
1832 AuthTransData data;
1833 data.len = 10;
1834 data.data = new uint8_t(LNN_INFO_TYPE_NICK_NAME);
1835 AuthHandle authHandle;
1836 AuthManager authManager;
1837 g_syncInfoManager.handlers[LNN_INFO_TYPE_NICK_NAME] = Complete;
1838
1839 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
1840 EXPECT_CALL(lnnSyncInfoMgrMock, GetAuthManagerByAuthId(_)).Times(1).WillOnce(Return(&authManager));
1841 EXPECT_CALL(lnnSyncInfoMgrMock, LnnGetNetworkIdByUdid(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
1842 EXPECT_CALL(lnnSyncInfoMgrMock, DelDupAuthManager(_)).Times(1);
1843
1844 EXPECT_NO_FATAL_FAILURE(OnWifiDirectSyncMsgRecv(authHandle, &data));
1845
1846 delete (data.data);
1847 data.data = nullptr;
1848 }
1849
1850 /*
1851 * @tc.name: OnWifiDirectSyncAuthClose_001
1852 * @tc.desc: SUCCESS
1853 * @tc.type: FUNC
1854 * @tc.require: 1
1855 */
1856 HWTEST_F(LNNSyncInfoManagerTest, OnWifiDirectSyncAuthClose_001, TestSize.Level1)
1857 {
1858 AuthHandle authHandle;
1859 OnWifiDirectSyncAuthClose(authHandle);
1860 }
1861
1862 /*
1863 * @tc.name: ResetSendSyncInfo_001
1864 * @tc.desc: oldInfo->clientChannelId == INVALID_CHANNEL_ID
1865 * @tc.type: FUNC
1866 * @tc.require: 1
1867 */
1868 HWTEST_F(LNNSyncInfoManagerTest, ResetSendSyncInfo_001, TestSize.Level1)
1869 {
1870 SoftBusSysTime time = {
1871 .sec = 0,
1872 .usec = 0,
1873 };
1874
1875 SyncChannelInfo oldInfo = {
1876 .clientChannelId = INVALID_CHANNEL_ID,
1877 };
1878
1879 SyncChannelInfo newInfo = {
1880 .clientChannelId = 10,
1881 .accessTime = time,
1882 };
1883
1884 SyncInfoMsg msg;
1885
1886 ResetSendSyncInfo(&oldInfo, &newInfo, &msg);
1887 EXPECT_EQ(oldInfo.clientChannelId, newInfo.clientChannelId);
1888 EXPECT_EQ(oldInfo.accessTime.sec, newInfo.accessTime.sec);
1889 EXPECT_EQ(oldInfo.accessTime.usec, newInfo.accessTime.usec);
1890 }
1891
1892 /*
1893 * @tc.name: ResetSendSyncInfo_002
1894 * @tc.desc: oldInfo->isClientOpened = false
1895 * @tc.type: FUNC
1896 * @tc.require: 1
1897 */
1898 HWTEST_F(LNNSyncInfoManagerTest, ResetSendSyncInfo_002, TestSize.Level1)
1899 {
1900 SoftBusSysTime time = {
1901 .sec = 0,
1902 .usec = 0,
1903 };
1904
1905 SyncChannelInfo oldInfo = {
1906 .clientChannelId = 100,
1907 .isClientOpened = true,
1908 };
1909
1910 SyncChannelInfo newInfo = {
1911 .clientChannelId = 10,
1912 .accessTime = time,
1913 };
1914
1915 SyncInfoMsg msg;
1916
1917 NiceMock<LnnTransInterfaceMock> mock;
1918 EXPECT_CALL(mock, TransCloseNetWorkingChannel(_)).Times(1);
1919
1920 ResetSendSyncInfo(&oldInfo, &newInfo, &msg);
1921
1922 EXPECT_EQ(oldInfo.isClientOpened, false);
1923 EXPECT_EQ(oldInfo.clientChannelId, newInfo.clientChannelId);
1924 }
1925
1926 /*
1927 * @tc.name: ResetSendSyncInfo_003
1928 * @tc.desc: oldInfo->isClientOpened = true
1929 * @tc.type: FUNC
1930 * @tc.require: 1
1931 */
1932 HWTEST_F(LNNSyncInfoManagerTest, ResetSendSyncInfo_003, TestSize.Level1)
1933 {
1934 SoftBusSysTime time = {
1935 .sec = 0,
1936 .usec = 0,
1937 };
1938
1939 SyncChannelInfo oldInfo = {
1940 .clientChannelId = 100,
1941 .isClientOpened = false,
1942 .accessTime = time,
1943 };
1944
1945 SyncChannelInfo newInfo = {
1946 .clientChannelId = 100,
1947 .accessTime = time,
1948 };
1949
1950 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
1951 if (msg == nullptr) {
1952 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
1953 return;
1954 }
1955 NiceMock<LnnTransInterfaceMock> mock;
1956 EXPECT_CALL(mock, TransSendNetworkingMessage(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
1957
1958 ResetSendSyncInfo(&oldInfo, &newInfo, msg);
1959 }
1960
1961 /*
1962 * @tc.name: SendSyncInfoByNewChannel_001
1963 * @tc.desc: info->clientChannelId == INVALID_CHANNEL_ID
1964 * @tc.type: FUNC
1965 * @tc.require: 1
1966 */
1967 HWTEST_F(LNNSyncInfoManagerTest, SendSyncInfoByNewChannel_001, TestSize.Level1)
1968 {
1969 SyncInfoMsg msg;
1970 NiceMock<LnnTransInterfaceMock> transMock;
1971 EXPECT_CALL(transMock, TransOpenNetWorkingChannel(_, _)).Times(1).WillOnce(Return(INVALID_CHANNEL_ID));
1972
1973 SendSyncInfoByNewChannel(NETWORKID, &msg);
1974 }
1975
1976 /*
1977 * @tc.name: SendSyncInfoByNewChannel_002
1978 * @tc.desc: IsListEmpty(&g_syncInfoManager.channelInfoList)
1979 * @tc.type: FUNC
1980 * @tc.require: 1
1981 */
1982 HWTEST_F(LNNSyncInfoManagerTest, SendSyncInfoByNewChannel_002, TestSize.Level1)
1983 {
1984 SyncInfoMsg msg;
1985 int32_t id = 10;
1986 ListDelete(&g_syncInfoManager.channelInfoList);
1987 NiceMock<LnnTransInterfaceMock> transMock;
1988 NiceMock<LnnServicetInterfaceMock> lnnServerMock;
1989
1990 EXPECT_CALL(transMock, TransOpenNetWorkingChannel(_, _)).Times(1).WillOnce(Return(id));
1991 EXPECT_CALL(lnnServerMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).Times(1);
1992
1993 SendSyncInfoByNewChannel(NETWORKID, &msg);
1994 }
1995
1996 /*
1997 * @tc.name: TrySendSyncInfoMsg_001
1998 * @tc.desc: info->isClientOpened == true
1999 * @tc.type: FUNC
2000 * @tc.require: 1
2001 */
2002 HWTEST_F(LNNSyncInfoManagerTest, TrySendSyncInfoMsg_001, TestSize.Level1)
2003 {
2004 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
2005 if (msg == nullptr) {
2006 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
2007 return;
2008 }
2009 int32_t id = 10;
2010 ListDelete(&g_syncInfoManager.channelInfoList);
2011
2012 SyncChannelInfo *info = CreateSyncChannelInfo(NETWORKID);
2013 if (info == nullptr) {
2014 LNN_LOGE(LNN_BUILDER, "create sync channel info error!");
2015 return;
2016 }
2017 info->serverChannelId = id;
2018 info->clientChannelId = id;
2019 info->isClientOpened = true;
2020 ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
2021
2022 NiceMock<LnnTransInterfaceMock> transMock;
2023 EXPECT_CALL(transMock, TransSendNetworkingMessage(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
2024
2025 EXPECT_EQ(TrySendSyncInfoMsg(NODE_NETWORK_ID, msg), SOFTBUS_OK);
2026 }
2027
2028 /*
2029 * @tc.name: GetWifiDirectAuthByNetworkId_001
2030 * @tc.desc: authHandle->authId != AUTH_INVALID_ID
2031 * @tc.type: FUNC
2032 * @tc.require: 1
2033 */
2034 HWTEST_F(LNNSyncInfoManagerTest, GetWifiDirectAuthByNetworkId_001, TestSize.Level1)
2035 {
2036 AuthHandle authHandle = {
2037 .authId = 10,
2038 };
2039
2040 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2041 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1);
2042 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid)
2043 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAuthHandle);
2044
2045 EXPECT_EQ(GetWifiDirectAuthByNetworkId(NETWORKID, &authHandle), SOFTBUS_OK);
2046 }
2047
2048 /*
2049 * @tc.name: GetWifiDirectAuthByNetworkId_002
2050 * @tc.desc: return SOFTBUS_ERR;
2051 * @tc.type: FUNC
2052 * @tc.require: 1
2053 */
2054 HWTEST_F(LNNSyncInfoManagerTest, GetWifiDirectAuthByNetworkId_002, TestSize.Level1)
2055 {
2056 AuthHandle authHandle = {
2057 .authId = AUTH_INVALID_ID,
2058 };
2059
2060 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2061 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1);
2062 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid)
2063 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAuthHandle);
2064
2065 EXPECT_EQ(GetWifiDirectAuthByNetworkId(NETWORKID, &authHandle), SOFTBUS_OK);
2066 }
2067
2068 /*
2069 * @tc.name: TrySendSyncInfoMsgByAuth_001
2070 * @tc.desc: GetWifiDirectAuthByNetworkId(networkId, &authHandle) != SOFTBUS_OK
2071 * @tc.type: FUNC
2072 * @tc.require: 1
2073 */
2074 HWTEST_F(LNNSyncInfoManagerTest, TrySendSyncInfoMsgByAuth_001, TestSize.Level1)
2075 {
2076 SyncInfoMsg msg;
2077
2078 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2079 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1);
2080 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _)).Times(1);
2081
2082 EXPECT_NE(TrySendSyncInfoMsgByAuth(NETWORKID, &msg), SOFTBUS_OK);
2083 }
2084
2085 /*
2086 * @tc.name: TrySendSyncInfoMsgByAuth_002
2087 * @tc.desc: AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_ERR
2088 * @tc.type: FUNC
2089 * @tc.require: 1
2090 */
2091 HWTEST_F(LNNSyncInfoManagerTest, TrySendSyncInfoMsgByAuth_002, TestSize.Level1)
2092 {
2093 SyncInfoMsg msg;
2094 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2095 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1);
2096 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
2097 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(0)));
2098
2099 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
2100 EXPECT_CALL(mock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2101
2102 EXPECT_EQ(TrySendSyncInfoMsgByAuth(NETWORKID, &msg), SOFTBUS_ERR);
2103 }
2104
2105 /*
2106 * @tc.name: TrySendSyncInfoMsgByAuth_003
2107 * @tc.desc: msg->complete != nullptr
2108 * @tc.type: FUNC
2109 * @tc.require: 1
2110 */
2111 HWTEST_F(LNNSyncInfoManagerTest, TrySendSyncInfoMsgByAuth_003, TestSize.Level1)
2112 {
2113 SyncInfoMsg *msg = CreateSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, MSG, LEN, Complete);
2114 if (msg == nullptr) {
2115 LNN_LOGE(LNN_BUILDER, "create sync info msg error!");
2116 return;
2117 }
2118 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2119 EXPECT_CALL(ledgerMock, LnnConvertDlId(_, _, _, _, _)).Times(1);
2120 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
2121 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(0)));
2122
2123 NiceMock<LnnSyncInfoManagerInterfaceMock> mock;
2124 EXPECT_CALL(mock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2125
2126 EXPECT_EQ(TrySendSyncInfoMsgByAuth(NODE_NETWORK_ID, msg), SOFTBUS_ERR);
2127 SoftBusFree(msg);
2128 }
2129
2130 /*
2131 * @tc.name: GetFeatureCap_001
2132 * @tc.desc: ret != SOFTBUS_OK
2133 * @tc.type: FUNC
2134 * @tc.require: 1
2135 */
2136 HWTEST_F(LNNSyncInfoManagerTest, GetFeatureCap_001, TestSize.Level1)
2137 {
2138 uint64_t local = 0;
2139 uint64_t remote = 0;
2140
2141 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2142 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2143 EXPECT_NE(GetFeatureCap(NETWORKID, &local, &remote), SOFTBUS_OK);
2144 }
2145
2146 /*
2147 * @tc.name: GetFeatureCap_002
2148 * @tc.desc: *remote == 0
2149 * @tc.type: FUNC
2150 * @tc.require: 1
2151 */
2152 HWTEST_F(LNNSyncInfoManagerTest, GetFeatureCap_002, TestSize.Level1)
2153 {
2154 uint64_t local = 10;
2155 uint64_t remote = 0;
2156
2157 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2158 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2159
2160 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2161 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2162 EXPECT_NE(GetFeatureCap(NETWORKID, &local, &remote), SOFTBUS_OK);
2163 }
2164
2165 /*
2166 * @tc.name: GetFeatureCap_003
2167 * @tc.desc: return SOFTBUS_OK;
2168 * @tc.type: FUNC
2169 * @tc.require: 1
2170 */
2171 HWTEST_F(LNNSyncInfoManagerTest, GetFeatureCap_003, TestSize.Level1)
2172 {
2173 uint64_t local = 10;
2174 uint64_t remote = 10;
2175
2176 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2177 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2178
2179 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2180 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2181 EXPECT_EQ(GetFeatureCap(NETWORKID, &local, &remote), SOFTBUS_OK);
2182 }
2183
2184 /*
2185 * @tc.name: IsNeedSyncByAuth_001
2186 * @tc.desc: LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &localCap) != SOFTBUS_OK
2187 * @tc.type: FUNC
2188 * @tc.require: 1
2189 */
2190 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_001, TestSize.Level1)
2191 {
2192 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2193 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2194
2195 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2196 }
2197
2198 /*
2199 * @tc.name: IsNeedSyncByAuth_002
2200 * @tc.desc: (localCap & (1 << BIT_WIFI_P2P)) == 0
2201 * @tc.type: FUNC
2202 * @tc.require: 1
2203 */
2204 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_002, TestSize.Level1)
2205 {
2206 uint32_t local = 0;
2207 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2208 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2209 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2210 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2211 .Times(1)
2212 .WillOnce(DoAll(SetArgPointee<1>(local), Return(SOFTBUS_OK)));
2213 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2214
2215 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2216 }
2217
2218 /*
2219 * @tc.name: IsNeedSyncByAuth_003
2220 * @tc.desc: GetFeatureCap(networkId, &local, &remote) != SOFTBUS_OK
2221 * @tc.type: FUNC
2222 * @tc.require: 1
2223 */
2224 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_003, TestSize.Level1)
2225 {
2226 uint32_t local1 = 8;
2227 uint32_t remote1 = 8;
2228 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2229 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2230 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2231 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2232 .Times(1)
2233 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2234 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2235 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2236 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2237
2238 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2239 }
2240
2241 /*
2242 * @tc.name: IsNeedSyncByAuth_004
2243 * @tc.desc: (local & (1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY)) == 0
2244 * @tc.type: FUNC
2245 * @tc.require: 1
2246 */
2247 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_004, TestSize.Level1)
2248 {
2249 uint32_t local1 = 8;
2250 uint32_t remote1 = 8;
2251 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2252 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2253 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2254 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2255 .Times(1)
2256 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2257 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2258 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2259
2260 uint32_t local2 = 1;
2261 uint32_t remote2 = 1;
2262 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2263 .Times(1)
2264 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2265 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2266 .Times(1)
2267 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2268
2269 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2270 }
2271
2272 /*
2273 * @tc.name: IsNeedSyncByAuth_005
2274 * @tc.desc: LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &node) != SOFTBUS_OK
2275 * @tc.type: FUNC
2276 * @tc.require: 1
2277 */
2278 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_005, TestSize.Level1)
2279 {
2280 uint32_t local1 = 8;
2281 uint32_t remote1 = 8;
2282 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2283 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2284 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2285 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2286 .Times(1)
2287 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2288 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2289 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2290
2291 uint32_t local2 = 32768;
2292 uint32_t remote2 = 32768;
2293 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2294 .Times(1)
2295 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2296 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2297 .Times(1)
2298 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2299
2300 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2301
2302 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2303 }
2304
2305 /*
2306 * @tc.name: IsNeedSyncByAuth_006
2307 * @tc.desc: LnnHasDiscoveryType(&node, DISCOVERY_TYPE_WIFI) || LnnHasDiscoveryType(&node, DISCOVERY_TYPE_LSA)
2308 * @tc.type: FUNC
2309 * @tc.require: 1
2310 */
2311 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_006, TestSize.Level1)
2312 {
2313 uint32_t local1 = 8;
2314 uint32_t remote1 = 8;
2315 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2316 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2317 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2318 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2319 .Times(1)
2320 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2321 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2322 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2323
2324 uint32_t local2 = 32768;
2325 uint32_t remote2 = 32768;
2326 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2327 .Times(1)
2328 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2329 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2330 .Times(1)
2331 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2332
2333 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2334 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType(_, _)).Times(1).WillOnce(Return(true));
2335
2336 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2337 }
2338
2339 /*
2340 * @tc.name: IsNeedSyncByAuth_007
2341 * @tc.desc: (localCap & (1 << BIT_BR)) && (remoteCap & (1 << BIT_BR))
2342 * @tc.type: FUNC
2343 * @tc.require: 1
2344 */
2345 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_007, TestSize.Level1)
2346 {
2347 uint32_t local1 = 10;
2348 uint32_t remote1 = 10;
2349 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2350 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2351 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2352 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2353 .Times(1)
2354 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2355 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2356 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2357
2358 uint32_t local2 = 32768;
2359 uint32_t remote2 = 32768;
2360 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2361 .Times(1)
2362 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2363 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2364 .Times(1)
2365 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2366
2367 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2368 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType(_, _)).Times(2).WillOnce(Return(false)).WillOnce(Return(false));
2369
2370 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), false);
2371 }
2372
2373 /*
2374 * @tc.name: IsNeedSyncByAuth_008
2375 * @tc.desc: return true;
2376 * @tc.type: FUNC
2377 * @tc.require: 1
2378 */
2379 HWTEST_F(LNNSyncInfoManagerTest, IsNeedSyncByAuth_008, TestSize.Level1)
2380 {
2381 uint32_t local1 = 8;
2382 uint32_t remote1 = 8;
2383 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2384 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2385 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2386 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2387 .Times(1)
2388 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2389 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2390 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2391
2392 uint32_t local2 = 32768;
2393 uint32_t remote2 = 32768;
2394 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2395 .Times(1)
2396 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2397 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2398 .Times(1)
2399 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2400
2401 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2402 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType(_, _)).Times(2).WillOnce(Return(false)).WillOnce(Return(false));
2403
2404 EXPECT_EQ(IsNeedSyncByAuth(NETWORKID), true);
2405 }
2406
2407 /*
2408 * @tc.name: LnnSendSyncInfoMsg_001
2409 * @tc.desc: return true;
2410 * @tc.type: FUNC
2411 * @tc.require: 1
2412 */
2413 HWTEST_F(LNNSyncInfoManagerTest, LnnSendSyncInfoMsg_001, TestSize.Level1)
2414 {
2415 LnnSyncInfoType type = LNN_INFO_TYPE_CAPABILITY;
2416
2417 uint32_t local1 = 8;
2418 uint32_t remote1 = 8;
2419 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2420 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2421 NiceMock<DistributeLedgerInterfaceMock> distributeLedgerMock;
2422 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info(_, _))
2423 .Times(1)
2424 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
2425 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU32Info(_, _, _))
2426 .WillOnce(DoAll(SetArgPointee<2>(remote1), Return(SOFTBUS_OK)));
2427
2428 uint32_t local2 = 32768;
2429 uint32_t remote2 = 32768;
2430 EXPECT_CALL(ledgerMock, LnnGetLocalNumU64Info(_, _))
2431 .Times(1)
2432 .WillOnce(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
2433 EXPECT_CALL(distributeLedgerMock, LnnGetRemoteNumU64Info(_, _, _))
2434 .Times(1)
2435 .WillOnce(DoAll(SetArgPointee<2>(remote2), Return(SOFTBUS_OK)));
2436
2437 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2438 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType(_, _)).Times(2).WillOnce(Return(false)).WillOnce(Return(false));
2439
2440 EXPECT_CALL(ledgerMock, AuthDeviceGetLatestIdByUuid(_, _, _))
2441 .WillOnce(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(0)));
2442 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2443
2444 EXPECT_EQ(LnnSendSyncInfoMsg(type, NETWORKID, MSG, LEN, nullptr), SOFTBUS_OK);
2445 }
2446
2447 /*
2448 * @tc.name: GetAuthHandleByNetworkId_001
2449 * @tc.desc: authHandle->authId != AUTH_INVALID_ID
2450 * @tc.type: FUNC
2451 * @tc.require: 1
2452 */
2453 HWTEST_F(LNNSyncInfoManagerTest, GetAuthHandleByNetworkId_001, TestSize.Level1)
2454 {
2455 AuthHandle authHandle;
2456 NiceMock<LnnNetLedgertInterfaceMock> mock;
2457
2458 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2459 EXPECT_CALL(mock, AuthDeviceGetLatestIdByUuid(_, _, _))
2460 .WillRepeatedly(DoAll(SetArgPointee<2>(AuthHandle { .authId = 100, .type = 1 }), Return(0)));
2461
2462 EXPECT_EQ(GetAuthHandleByNetworkId(NETWORKID, &authHandle), SOFTBUS_OK);
2463 }
2464
2465 /*
2466 * @tc.name: GetAuthHandleByNetworkId_002
2467 * @tc.desc: return SOFTBUS_ERR;
2468 * @tc.type: FUNC
2469 * @tc.require: 1
2470 */
2471 HWTEST_F(LNNSyncInfoManagerTest, GetAuthHandleByNetworkId_002, TestSize.Level1)
2472 {
2473 AuthHandle authHandle;
2474 NiceMock<LnnNetLedgertInterfaceMock> mock;
2475
2476 EXPECT_CALL(mock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2477 EXPECT_CALL(mock, AuthDeviceGetLatestIdByUuid(_, _, _))
2478 .WillRepeatedly(DoAll(SetArgPointee<2>(AuthHandle { .authId = AUTH_INVALID_ID, .type = 1 }), Return(0)));
2479
2480 EXPECT_NE(GetAuthHandleByNetworkId(NETWORKID, &authHandle), SOFTBUS_OK);
2481 }
2482
2483 /*
2484 * @tc.name: LnnSendWifiOfflineInfoMsg_001
2485 * @tc.desc: LnnGetLocalNumInfoByIfnameIdx(NUM_KEY_AUTH_PORT, &authPort, WLAN_IF) != SOFTBUS_OK
2486 * @tc.type: FUNC
2487 * @tc.require: 1
2488 */
2489 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_001, TestSize.Level1)
2490 {
2491 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2492 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _))
2493 .Times(2)
2494 .WillOnce(Return(SOFTBUS_ERR))
2495 .WillOnce(Return(SOFTBUS_OK));
2496 EXPECT_NE(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2497
2498 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2499 EXPECT_NE(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2500 }
2501
2502 /*
2503 * @tc.name: LnnSendWifiOfflineInfoMsg_002
2504 * @tc.desc: ConvertBytesToHexString == SOFTBUS_ERR
2505 * @tc.type: FUNC
2506 * @tc.require: 1
2507 */
2508 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_002, TestSize.Level1)
2509 {
2510 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2511 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2512 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2513 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2514 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
2515
2516 EXPECT_NE(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2517 }
2518
2519 /*
2520 * @tc.name: LnnSendWifiOfflineInfoMsg_003
2521 * @tc.desc: msg == nullptr
2522 * @tc.type: FUNC
2523 * @tc.require: 1
2524 */
2525 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_003, TestSize.Level1)
2526 {
2527 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2528 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2529 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2530 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2531 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2532 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(nullptr));
2533
2534 EXPECT_NE(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2535 }
2536
2537 /*
2538 * @tc.name: LnnSendWifiOfflineInfoMsg_004
2539 * @tc.desc: GetHmlOrP2pAuthHandle(&authHandle, &num) != SOFTBUS_OK
2540 * @tc.type: FUNC
2541 * @tc.require: 1
2542 */
2543 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_004, TestSize.Level1)
2544 {
2545 JsonObj json;
2546 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
2547 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
2548 if (msg == nullptr) {
2549 return;
2550 }
2551 (void)strcpy_s(msg, LEN, MSG_TEST);
2552
2553 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2554 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2555 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2556 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2557 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2558
2559 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
2560
2561 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2562 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2563 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddStringToObject(_, _, _)).WillRepeatedly(Return(true));
2564
2565 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillOnce(Return(msg));
2566
2567 EXPECT_CALL(lnnSyncInfoMgrMock, GetHmlOrP2pAuthHandle(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2568
2569 EXPECT_NE(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2570 }
2571
2572 /*
2573 * @tc.name: LnnSendWifiOfflineInfoMsg_005
2574 * @tc.desc: AuthPostTransData(authHandle[i], &dataInfo) == SOFTBUS_OK
2575 * @tc.type: FUNC
2576 * @tc.require: 1
2577 */
2578 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_005, TestSize.Level1)
2579 {
2580 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
2581 if (msg == nullptr) {
2582 return;
2583 }
2584 (void)strcpy_s(msg, LEN, MSG_TEST);
2585 JsonObj json;
2586 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
2587 int32_t num = 1;
2588 AuthHandle *authHandle = new AuthHandle;
2589 authHandle->authId = 100;
2590 authHandle->type = 1;
2591
2592 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2593 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2594 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2595 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2596 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2597
2598 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
2599
2600 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2601 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2602 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddStringToObject(_, _, _)).WillRepeatedly(Return(true));
2603
2604 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillOnce(Return(msg));
2605
2606 EXPECT_CALL(lnnSyncInfoMgrMock, GetHmlOrP2pAuthHandle(_, _))
2607 .Times(1)
2608 .WillOnce(DoAll(SetArgPointee<0>(authHandle), SetArgPointee<1>(num), Return(SOFTBUS_OK)));
2609 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2610
2611 EXPECT_EQ(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2612 }
2613
2614 /*
2615 * @tc.name: LnnSendWifiOfflineInfoMsg_006
2616 * @tc.desc: AuthPostTransData(authHandle[i], &dataInfo) == SOFTBUS_OK
2617 * @tc.type: FUNC
2618 * @tc.require: 1
2619 */
2620 HWTEST_F(LNNSyncInfoManagerTest, LnnSendWifiOfflineInfoMsg_006, TestSize.Level1)
2621 {
2622 char *msg = reinterpret_cast<char *>(SoftBusMalloc(LEN));
2623 if (msg == nullptr) {
2624 return;
2625 }
2626 (void)strcpy_s(msg, LEN, MSG_TEST);
2627 JsonObj json;
2628 (void)memset_s(&json, sizeof(JsonObj), 0, sizeof(JsonObj));
2629 int32_t num = 1;
2630 AuthHandle *authHandle = new AuthHandle;
2631 authHandle->authId = 100;
2632 authHandle->type = 1;
2633
2634 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
2635 NiceMock<LnnSyncInfoManagerInterfaceMock> lnnSyncInfoMgrMock;
2636 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfoByIfnameIdx(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2637 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo(_, _, _)).Times(1).WillOnce(Return(SOFTBUS_OK));
2638 EXPECT_CALL(lnnSyncInfoMgrMock, ConvertBytesToHexString(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
2639
2640 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_CreateObject()).WillRepeatedly(Return(&json));
2641
2642 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2643 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddInt32ToObject(_, _, _)).WillRepeatedly(Return(true));
2644 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_AddStringToObject(_, _, _)).WillRepeatedly(Return(true));
2645
2646 EXPECT_CALL(lnnSyncInfoMgrMock, JSON_PrintUnformatted(_)).Times(1).WillOnce(Return(msg));
2647
2648 EXPECT_CALL(lnnSyncInfoMgrMock, GetHmlOrP2pAuthHandle(_, _))
2649 .Times(1)
2650 .WillOnce(DoAll(SetArgPointee<0>(authHandle), SetArgPointee<1>(num), Return(SOFTBUS_OK)));
2651 EXPECT_CALL(lnnSyncInfoMgrMock, AuthPostTransData(_, _)).Times(1).WillOnce(Return(SOFTBUS_ERR));
2652
2653 EXPECT_EQ(LnnSendWifiOfflineInfoMsg(), SOFTBUS_OK);
2654 }
2655 } // namespace OHOS
2656