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