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 "lnn_net_ledger_mock.h"
20 #include "lnn_service_mock.h"
21 #include "lnn_sync_info_mock.h"
22 #include "lnn_topo_manager.c"
23 #include "lnn_topo_manager.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_json_utils.h"
26
27 #define LNN_RELATION_JOIN_THREAD 1
28 #define LNN_RELATION_ERROR 0
29 namespace OHOS {
30 using namespace testing::ext;
31 using namespace testing;
32
33 constexpr char UDID[] = "83b37d243c8aac5a660d0cb231a7dbf9643b330245d560f4193956b0749a8651";
34 constexpr char UDID_1[] = "d243c8aac5a660d0cb231a7dbf9643b330245d560f4193956b0749a865183b37";
35 constexpr char INVALID_UUID[] = "91a0183f4b68272902e7411f8e122fafd59969cd088e22d296be16400dcc9736123";
36 constexpr char PEER_UDID[] = "dac6f8016d28d6cefa0671a1cdaba4928a53fa4e3b3a6b749c3887deda620564";
37 constexpr char PEER_UDID_1[] = "8d6cefa0671a1cdaba4928a53fa4e3b3a6b749c3887deda620564dac6f8016d2";
38 constexpr char NETWORK_ID[] = "abc";
39 constexpr char NETWORK_ID_1[] = "abcd";
40 constexpr uint8_t OLD_RELATION[] = "1";
41 constexpr uint8_t NEW_RELATION_1[] = "0";
42 constexpr uint8_t NEW_RELATION_2[] = "1";
43 constexpr uint8_t MSG[] = "tempMsg";
44 constexpr uint32_t MSG_LEN = 7;
45 constexpr uint32_t RELATION_LEN = 1;
46 constexpr uint32_t INVALID_RELATION_LEN = 6;
47 constexpr char MSG_1[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": \"infoTest\"}";
48 constexpr char MSG_2[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": [{\"udid\": \
49 \"83b37d243c8aac5a660d0cb231a7dbf9643b330245d560f4193956b0749a8651\", \"peerUdid\": \
50 \"dac6f8016d28d6cefa0671a1cdaba4928a53fa4e3b3a6b749c3887deda620564\", \"wlanRelation\": 1, \
51 \"brRelation\": 0, \"bleRelation\": 0, \"ethRelation\": 0}]}";
52 constexpr char MSG_3[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": [{\"peerUdid\": \
53 \"dac6f8016d28d6cefa0671a1cdaba4928a53fa4e3b3a6b749c3887deda620564\", \"wlanRelation\": 1, \
54 \"brRelation\": 0, \"bleRelation\": 0, \"ethRelation\": 0}]}";
55 constexpr char MSG_4[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": [{\"udid\": \
56 \"83b37d243c8aac5a660d0cb231a7dbf9643b330245d560f4193956b0749a8651\", \"wlanRelation\": 1, \
57 \"brRelation\": 0, \"bleRelation\": 0, \"ethRelation\": 0}]}";
58 constexpr char MSG_5[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": [{\"udid\": \"\", \"peerUdid\": \
59 \"dac6f8016d28d6cefa0671a1cdaba4928a53fa4e3b3a6b749c3887deda620564\", \"wlanRelation\": 1, \
60 \"brRelation\": 0, \"bleRelation\": 0, \"ethRelation\": 0}]}";
61 constexpr char MSG_6[] = "{\"type\": 0, \"seq\": 20, \"complete\": 1, \"info\": [{\"udid\": \
62 \"83b37d243c8aac5a660d0cb231a7dbf9643b330245d560f4193956b0749a8651\", \"peerUdid\": \"\", \"wlanRelation\": 1, \
63 \"brRelation\": 0, \"bleRelation\": 0, \"ethRelation\": 0}]}";
64 constexpr char MSG_7[] = "{\"seq\": 20, \"complete\": 1}";
65 constexpr char MSG_8[] = "{\"type\": 0, \"complete\": 1}";
66 constexpr char MSG_9[] = "{\"type\": 0, \"seq\": 20}";
67 constexpr char MSG_10[] = "{\"type\": 1, \"seq\": 20, \"complete\": 1}";
68 constexpr char MSG_11[] = "{\"type\": 0, \"seq\": 20, \"complete\": 0}";
69 constexpr char RAND_STR1[] = "-20";
70 constexpr char RAND_STR2[] = "20";
71
72 class LNNTopoManagerTest : public testing::Test {
73 public:
74 static void SetUpTestCase();
75 static void TearDownTestCase();
76 void SetUp();
77 void TearDown();
78 };
79
SetUpTestCase()80 void LNNTopoManagerTest::SetUpTestCase()
81 {
82 }
83
TearDownTestCase()84 void LNNTopoManagerTest::TearDownTestCase()
85 {
86 }
87
SetUp()88 void LNNTopoManagerTest::SetUp()
89 {
90 }
91
TearDown()92 void LNNTopoManagerTest::TearDown()
93 {
94 }
95
96 /*
97 * @tc.name: LNN_INIT_TOPO_MANAGER_TEST_001
98 * @tc.desc: LnnInitTopoManager test
99 * @tc.type: FUNC
100 * @tc.require: I5OMIK
101 */
102 HWTEST_F(LNNTopoManagerTest, LNN_INIT_TOPO_MANAGER_TEST_001, TestSize.Level1)
103 {
104 unsigned char *isNoSupportTopo = reinterpret_cast<unsigned char *>(const_cast<char *>("0"));
105 unsigned char *isSupportTopo = reinterpret_cast<unsigned char *>(const_cast<char *>("1"));
106 NiceMock<LnnServicetInterfaceMock> serviceMock;
107 EXPECT_CALL(serviceMock, SoftbusGetConfig).WillOnce(Return(SOFTBUS_ERR))
108 .WillOnce(DoAll(SetArgPointee<1>(*isNoSupportTopo), Return(SOFTBUS_OK)))
109 .WillRepeatedly(DoAll(SetArgPointee<1>(*isSupportTopo), Return(SOFTBUS_OK)));
110 EXPECT_CALL(serviceMock, LnnRegisterEventHandler).WillOnce(Return(SOFTBUS_ERR))
111 .WillRepeatedly(Return(SOFTBUS_OK));
112 EXPECT_CALL(serviceMock, LnnUnregisterEventHandler).WillRepeatedly(Return());
113 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
114 EXPECT_CALL(lnnSyncInfoMock, LnnRegSyncInfoHandler).WillOnce(Return(SOFTBUS_ERR))
115 .WillRepeatedly(Return(SOFTBUS_OK));
116 EXPECT_CALL(lnnSyncInfoMock, LnnUnregSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_OK));
117 int32_t ret = LnnInitTopoManager();
118 EXPECT_EQ(ret, SOFTBUS_ERR);
119 ret = LnnInitTopoManager();
120 EXPECT_EQ(ret, SOFTBUS_ERR);
121 LnnDeinitTopoManager();
122 ret = LnnInitTopoManager();
123 EXPECT_EQ(ret, SOFTBUS_OK);
124 }
125
126 /*
127 * @tc.name: LNN_GET_RELATION_TEST_001
128 * @tc.desc: LnnGetRelation test
129 * @tc.type: FUNC
130 * @tc.require: I5OMIK
131 */
132 HWTEST_F(LNNTopoManagerTest, LNN_GET_RELATION_TEST_001, TestSize.Level1)
133 {
134 uint8_t relation[CONNECTION_ADDR_MAX + 1] = { 0 };
135 int ret = LnnGetRelation(UDID, PEER_UDID, relation, CONNECTION_ADDR_MAX + 1);
136 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
137 ret = LnnGetRelation(nullptr, PEER_UDID, relation, CONNECTION_ADDR_MAX);
138 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
139 ret = LnnGetRelation(UDID, nullptr, relation, CONNECTION_ADDR_MAX);
140 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
141 ret = LnnGetRelation(UDID, PEER_UDID, nullptr, CONNECTION_ADDR_MAX);
142 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
143 ret = LnnGetRelation(UDID, PEER_UDID, relation, CONNECTION_ADDR_MAX);
144 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
145 ret = LnnGetRelation(UDID, PEER_UDID, relation, CONNECTION_ADDR_MAX);
146 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
147 }
148
149 /*
150 * @tc.name: ADD_TOPO_INFO_TEST_001
151 * @tc.desc: AddTopoInfo test
152 * @tc.type: FUNC
153 * @tc.require: I5OMIK
154 */
155 HWTEST_F(LNNTopoManagerTest, ADD_TOPO_INFO_TEST_001, TestSize.Level1)
156 {
157 int32_t ret = AddTopoInfo(UDID, PEER_UDID, OLD_RELATION, RELATION_LEN);
158 EXPECT_EQ(ret, SOFTBUS_OK);
159 ret = AddTopoInfo(UDID, PEER_UDID, OLD_RELATION, RELATION_LEN);
160 EXPECT_EQ(ret, SOFTBUS_OK);
161 ret = AddTopoInfo(UDID, PEER_UDID, OLD_RELATION, RELATION_LEN);
162 EXPECT_EQ(ret, SOFTBUS_OK);
163 uint8_t relation[CONNECTION_ADDR_MAX + 1] = { 0 };
164 ret = LnnGetRelation(UDID_1, PEER_UDID_1, relation, CONNECTION_ADDR_MAX);
165 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
166 ret = LnnGetRelation(UDID, PEER_UDID_1, relation, CONNECTION_ADDR_MAX);
167 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
168 ret = LnnGetRelation(UDID, PEER_UDID, relation, CONNECTION_ADDR_MAX);
169 EXPECT_EQ(ret, SOFTBUS_OK);
170 ret = LnnGetRelation(UDID_1, PEER_UDID, relation, CONNECTION_ADDR_MAX);
171 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
172 }
173
174 /*
175 * @tc.name: IS_SAME_RELATION_TEST_001
176 * @tc.desc: IsSameRelation test
177 * @tc.type: FUNC
178 * @tc.require: I5OMIK
179 */
180 HWTEST_F(LNNTopoManagerTest, IS_SAME_RELATION_TEST_001, TestSize.Level1)
181 {
182 bool ret = IsSameRelation(NEW_RELATION_2, NEW_RELATION_1, RELATION_LEN);
183 EXPECT_EQ(ret, true);
184 ret = IsSameRelation(NEW_RELATION_1, NEW_RELATION_2, RELATION_LEN);
185 EXPECT_EQ(ret, true);
186 ret = IsSameRelation(NEW_RELATION_2, NEW_RELATION_2, RELATION_LEN);
187 EXPECT_EQ(ret, true);
188 ret = IsSameRelation(NEW_RELATION_1, NEW_RELATION_1, RELATION_LEN);
189 EXPECT_EQ(ret, true);
190 }
191
192 /*
193 * @tc.name: HAS_RELATION_TEST_001
194 * @tc.desc: HasRelation test
195 * @tc.type: FUNC
196 * @tc.require: I5OMIK
197 */
198 HWTEST_F(LNNTopoManagerTest, HAS_RELATION_TEST_001, TestSize.Level1)
199 {
200 bool ret = HasRelation(NEW_RELATION_1, RELATION_LEN);
201 EXPECT_EQ(ret, true);
202 ret = HasRelation(NEW_RELATION_2, RELATION_LEN);
203 EXPECT_EQ(ret, true);
204 }
205
206 /*
207 * @tc.name: CREATE_TOPO_ITEM_TEST_001
208 * @tc.desc: CreateTopoItem test
209 * @tc.type: FUNC
210 * @tc.require: I5OMIK
211 */
212 HWTEST_F(LNNTopoManagerTest, CREATE_TOPO_ITEM_TEST_001, TestSize.Level1)
213 {
214 TopoTableItem *item = CreateTopoItem(INVALID_UUID);
215 EXPECT_EQ(item, nullptr);
216 TopoInfo *topo = CreateTopoInfo(INVALID_UUID, OLD_RELATION, RELATION_LEN);
217 EXPECT_EQ(topo, nullptr);
218 topo = CreateTopoInfo(UDID, OLD_RELATION, INVALID_RELATION_LEN);
219 EXPECT_EQ(topo, nullptr);
220 item = FindTopoItem(UDID);
221 EXPECT_EQ(topo, nullptr);
222 item = FindTopoItem(UDID_1);
223 EXPECT_EQ(topo, nullptr);
224 TopoTableItem *topoItem = nullptr;
225 TopoInfo *topoInfo = nullptr;
226 int32_t ret = FindTopoInfo(UDID_1, UDID_1, &topoItem, &topoInfo);
227 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
228 ret = FindTopoInfo(UDID, UDID_1, &topoItem, &topoInfo);
229 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
230 ret = FindTopoInfo(UDID_1, PEER_UDID, &topoItem, &topoInfo);
231 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
232 ret = FindTopoInfo(UDID, PEER_UDID, &topoItem, &topoInfo);
233 EXPECT_EQ(ret, SOFTBUS_OK);
234 }
235
236 /*
237 * @tc.name: PACK_COMMON_TOPO_MSG_TEST_001
238 * @tc.desc: PackCommonTopoMsg test
239 * @tc.type: FUNC
240 * @tc.require: I5OMIK
241 */
242 HWTEST_F(LNNTopoManagerTest, PACK_COMMON_TOPO_MSG_TEST_001, TestSize.Level1)
243 {
244 cJSON *json = NULL;
245 cJSON *info = NULL;
246 unsigned char *randStr1 = reinterpret_cast<unsigned char *>(const_cast<char *>(RAND_STR1));
247 unsigned char *randStr2 = reinterpret_cast<unsigned char *>(const_cast<char *>(RAND_STR2));
248 NiceMock<LnnServicetInterfaceMock> serviceMock;
249 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray)
250 .WillOnce(Return(SOFTBUS_ERR))
251 .WillOnce(DoAll(SetArgPointee<0>(*randStr1), Return(SOFTBUS_OK)))
252 .WillRepeatedly(DoAll(SetArgPointee<0>(*randStr2), Return(SOFTBUS_OK)));
253 int32_t ret = PackCommonTopoMsg(&json, &info);
254 EXPECT_EQ(ret, SOFTBUS_ERR);
255 ret = PackCommonTopoMsg(&json, &info);
256 EXPECT_EQ(ret, SOFTBUS_OK);
257 ret = PackCommonTopoMsg(&json, &info);
258 EXPECT_EQ(ret, SOFTBUS_OK);
259 }
260
261 /*
262 * @tc.name: PACK_TOPO_INFO_TEST_001
263 * @tc.desc: PackTopoInfo test
264 * @tc.type: FUNC
265 * @tc.require: I5OMIK
266 */
267 HWTEST_F(LNNTopoManagerTest, PACK_TOPO_INFO_TEST_001, TestSize.Level1)
268 {
269 cJSON info;
270 (void)memset_s(&info, sizeof(cJSON), 0, sizeof(cJSON));
271 int32_t ret = PackTopoInfo(&info, UDID, PEER_UDID, OLD_RELATION, CONNECTION_ADDR_MAX);
272 EXPECT_EQ(ret, SOFTBUS_OK);
273 ret = PackTopoInfo(&info, UDID, PEER_UDID, OLD_RELATION, INVALID_RELATION_LEN);
274 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
275 ret = PackTopoInfo(&info, nullptr, PEER_UDID, OLD_RELATION, CONNECTION_ADDR_MAX);
276 EXPECT_EQ(ret, SOFTBUS_ERR);
277 ret = PackTopoInfo(&info, UDID, nullptr, OLD_RELATION, CONNECTION_ADDR_MAX);
278 EXPECT_EQ(ret, SOFTBUS_ERR);
279 }
280
281 /*
282 * @tc.name: PACK_ONE_LNN_RELATION_TEST_001
283 * @tc.desc: PackOneLnnRelation test
284 * @tc.type: FUNC
285 * @tc.require: I5OMIK
286 */
287 HWTEST_F(LNNTopoManagerTest, PACK_ONE_LNN_RELATION_TEST_001, TestSize.Level1)
288 {
289 unsigned char *randStr1 = reinterpret_cast<unsigned char *>(const_cast<char *>(RAND_STR1));
290 NiceMock<LnnServicetInterfaceMock> serviceMock;
291 EXPECT_CALL(serviceMock, SoftBusGenerateRandomArray)
292 .WillOnce(Return(SOFTBUS_ERR))
293 .WillRepeatedly(DoAll(SetArgPointee<0>(*randStr1), Return(SOFTBUS_OK)));
294 const char *msg = PackOneLnnRelation(UDID, PEER_UDID, OLD_RELATION, CONNECTION_ADDR_MAX);
295 EXPECT_EQ(msg, nullptr);
296 msg = PackOneLnnRelation(nullptr, PEER_UDID, OLD_RELATION, INVALID_RELATION_LEN);
297 EXPECT_EQ(msg, nullptr);
298 msg = PackOneLnnRelation(UDID, PEER_UDID, OLD_RELATION, CONNECTION_ADDR_MAX);
299 EXPECT_NE(msg, nullptr);
300 }
301
302 /*
303 * @tc.name: UPDATE_LOCAL_TOPO_TEST_001
304 * @tc.desc: UpdateLocalTopo test
305 * @tc.type: FUNC
306 * @tc.require: I5OMIK
307 */
308 HWTEST_F(LNNTopoManagerTest, UPDATE_LOCAL_TOPO_TEST_001, TestSize.Level1)
309 {
310 int32_t ret = UpdateLocalTopo(UDID_1, UDID_1, NEW_RELATION_1, RELATION_LEN);
311 EXPECT_EQ(ret, SOFTBUS_OK);
312 ret = UpdateLocalTopo(UDID_1, UDID_1, NEW_RELATION_1, RELATION_LEN);
313 EXPECT_EQ(ret, SOFTBUS_ERR);
314 ret = UpdateLocalTopo(UDID_1, UDID_1, NEW_RELATION_1, RELATION_LEN);
315 EXPECT_EQ(ret, SOFTBUS_ERR);
316 ret = UpdateLocalTopo(UDID_1, UDID_1, NEW_RELATION_2, RELATION_LEN);
317 EXPECT_EQ(ret, SOFTBUS_ERR);
318 ret = UpdateLocalTopo(UDID, PEER_UDID, NEW_RELATION_1, RELATION_LEN);
319 EXPECT_EQ(ret, SOFTBUS_ERR);
320 }
321
322 /*
323 * @tc.name: FORWARD_TOPO_MSG_TO_ALL_TEST_001
324 * @tc.desc: ForwardTopoMsgToAll test
325 * @tc.type: FUNC
326 * @tc.require: I5OMIK
327 */
328 HWTEST_F(LNNTopoManagerTest, FORWARD_TOPO_MSG_TO_ALL_TEST_001, TestSize.Level1)
329 {
330 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
331 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo)
332 .WillOnce(Return(SOFTBUS_ERR))
333 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
334 EXPECT_CALL(ledgerMock, LnnIsLSANode)
335 .WillOnce(Return(true))
336 .WillRepeatedly(Return(false));
337 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
338 EXPECT_CALL(lnnSyncInfoMock, LnnSendSyncInfoMsg).WillOnce(Return(SOFTBUS_ERR))
339 .WillRepeatedly(Return(SOFTBUS_OK));
340 ForwardTopoMsgToAll(NETWORK_ID, MSG, MSG_LEN);
341 ForwardTopoMsgToAll(NETWORK_ID, MSG, MSG_LEN);
342 ForwardTopoMsgToAll(NETWORK_ID, MSG, MSG_LEN);
343 ForwardTopoMsgToAll(NETWORK_ID_1, MSG, MSG_LEN);
344 ForwardTopoMsgToAll(NETWORK_ID_1, MSG, MSG_LEN);
345 }
346
347 /*
348 * @tc.name: TRY_CORRECT_RELATION_TEST_001
349 * @tc.desc: TryCorrectRelation test
350 * @tc.type: FUNC
351 * @tc.require: I5OMIK
352 */
353 HWTEST_F(LNNTopoManagerTest, TRY_CORRECT_RELATION_TEST_001, TestSize.Level1)
354 {
355 char *localUdid1 = const_cast<char *>(UDID);
356 char *localUdid2 = const_cast<char *>(UDID_1);
357 uint8_t *relation = const_cast<uint8_t *>(NEW_RELATION_2);
358 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
359 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo)
360 .WillOnce(Return(SOFTBUS_ERR))
361 .WillOnce(DoAll(SetArgPointee<1>(*localUdid1), Return(SOFTBUS_OK)))
362 .WillRepeatedly(DoAll(SetArgPointee<1>(*localUdid2), Return(SOFTBUS_OK)));
363 EXPECT_CALL(ledgerMock, LnnGetLnnRelation)
364 .WillRepeatedly(DoAll(SetArgPointee<2>(*relation), Return(SOFTBUS_OK)));
365 TryCorrectRelation(NETWORK_ID, UDID, PEER_UDID, NEW_RELATION_2, RELATION_LEN);
366 TryCorrectRelation(NETWORK_ID, UDID, PEER_UDID, NEW_RELATION_2, RELATION_LEN);
367 TryCorrectRelation(NETWORK_ID, UDID, PEER_UDID, NEW_RELATION_1, RELATION_LEN);
368 TryCorrectRelation(NETWORK_ID, UDID, nullptr, NEW_RELATION_1, RELATION_LEN);
369 TryCorrectRelation(NETWORK_ID, UDID, PEER_UDID, NEW_RELATION_1, RELATION_LEN);
370 TryCorrectRelation(NETWORK_ID, UDID, PEER_UDID, NEW_RELATION_1, RELATION_LEN);
371 }
372
373 /*
374 * @tc.name: PROCESS_TOPO_UPDATEINFO_TEST_001
375 * @tc.desc: ProcessTopoUpdateInfo test
376 * @tc.type: FUNC
377 * @tc.require: I5OMIK
378 */
379 HWTEST_F(LNNTopoManagerTest, PROCESS_TOPO_UPDATEINFO_TEST_001, TestSize.Level1)
380 {
381 char *localUdid1 = const_cast<char *>(UDID);
382 char *localUdid2 = const_cast<char *>(PEER_UDID);
383 char *localUdid3 = const_cast<char *>(UDID_1);
384 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
385 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo)
386 .WillOnce(Return(SOFTBUS_ERR))
387 .WillOnce(DoAll(SetArgPointee<1>(*localUdid1), Return(SOFTBUS_OK)))
388 .WillOnce(DoAll(SetArgPointee<1>(*localUdid2), Return(SOFTBUS_OK)))
389 .WillRepeatedly(DoAll(SetArgPointee<1>(*localUdid3), Return(SOFTBUS_OK)));
390 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_ERR));
391 char *msg1 = const_cast<char *>(MSG_1);
392 char *msg2 = const_cast<char *>(MSG_2);
393 cJSON *json = cJSON_ParseWithLength(msg1, strlen(msg1));
394 EXPECT_NE(json, nullptr);
395 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
396 json = cJSON_ParseWithLength(msg2, strlen(msg2));
397 EXPECT_NE(json, nullptr);
398 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
399 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
400 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
401 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
402 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
403 char *msg3 = const_cast<char *>(MSG_3);
404 char *msg4 = const_cast<char *>(MSG_4);
405 json = cJSON_ParseWithLength(msg3, strlen(msg3));
406 EXPECT_NE(json, nullptr);
407 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
408 json = cJSON_ParseWithLength(msg4, strlen(msg4));
409 EXPECT_NE(json, nullptr);
410 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
411 char *msg5 = const_cast<char *>(MSG_5);
412 char *msg6 = const_cast<char *>(MSG_6);
413 json = cJSON_ParseWithLength(msg5, strlen(msg5));
414 EXPECT_NE(json, nullptr);
415 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
416 json = cJSON_ParseWithLength(msg6, strlen(msg6));
417 EXPECT_NE(json, nullptr);
418 ProcessTopoUpdateInfo(json, NETWORK_ID, MSG, MSG_LEN);
419 }
420
421 /*
422 * @tc.name: ON_RECEIVE_TOPO_UPDATE_MSG_TEST_001
423 * @tc.desc: OnReceiveTopoUpdateMsg test
424 * @tc.type: FUNC
425 * @tc.require: I5OMIK
426 */
427 HWTEST_F(LNNTopoManagerTest, ON_RECEIVE_TOPO_UPDATE_MSG_TEST_001, TestSize.Level1)
428 {
429 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
430 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_ERR));
431 uint8_t *msg1 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_2));
432 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_CONNECTION_INFO, NETWORK_ID, msg1, strlen(MSG_2));
433 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg1, 0);
434 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg1, strlen(MSG_2));
435 uint8_t *msg2 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_7));
436 uint8_t *msg3 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_8));
437 uint8_t *msg4 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_9));
438 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg2, strlen(MSG_7));
439 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg3, strlen(MSG_8));
440 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg4, strlen(MSG_9));
441 uint8_t *msg5 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_10));
442 uint8_t *msg6 = reinterpret_cast<uint8_t *>(const_cast<char *>(MSG_11));
443 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg5, strlen(MSG_10));
444 OnReceiveTopoUpdateMsg(LNN_INFO_TYPE_TOPO_UPDATE, NETWORK_ID, msg6, strlen(MSG_11));
445 OnLnnRelationChangedDelay(nullptr);
446 LnnRelationChangedMsg *msg =
447 reinterpret_cast<LnnRelationChangedMsg *>(SoftBusCalloc(sizeof(LnnRelationChangedMsg)));
448 EXPECT_NE(msg, nullptr);
449 void *para = reinterpret_cast<void *>(msg);
450 OnLnnRelationChangedDelay(para);
451 }
452
453 /*
454 * @tc.name: FILL_ALL_RELATION_TEST_001
455 * @tc.desc: FillAllRelation test
456 * @tc.type: FUNC
457 * @tc.require: I5OMIK
458 */
459 HWTEST_F(LNNTopoManagerTest, FILL_ALL_RELATION_TEST_001, TestSize.Level1)
460 {
461 LnnRelationChanedEventInfo eventInfo = {
462 .basic.event = LNN_EVENT_NODE_MIGRATE,
463 .udid = nullptr,
464 .type = CONNECTION_ADDR_MAX,
465 };
466 NiceMock<LnnServicetInterfaceMock> serviceMock;
467 EXPECT_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillOnce(Return(SOFTBUS_ERR))
468 .WillRepeatedly(Return(SOFTBUS_OK));
469 LnnEventBasicInfo *info =
470 reinterpret_cast<LnnEventBasicInfo *>(const_cast<LnnRelationChanedEventInfo *>(&eventInfo));
471 OnLnnRelationChanged(nullptr);
472 OnLnnRelationChanged(info);
473 eventInfo.basic.event = LNN_EVENT_RELATION_CHANGED;
474 info = reinterpret_cast<LnnEventBasicInfo *>(const_cast<LnnRelationChanedEventInfo *>(&eventInfo));
475 OnLnnRelationChanged(info);
476 eventInfo.udid = "udidTest";
477 info = reinterpret_cast<LnnEventBasicInfo *>(const_cast<LnnRelationChanedEventInfo *>(&eventInfo));
478 OnLnnRelationChanged(info);
479 eventInfo.type = CONNECTION_ADDR_WLAN;
480 info = reinterpret_cast<LnnEventBasicInfo *>(const_cast<LnnRelationChanedEventInfo *>(&eventInfo));
481 OnLnnRelationChanged(info);
482 OnLnnRelationChanged(info);
483 LnnRelation *relation = nullptr;
484 uint32_t relationNum = 0;
485 int32_t ret = LnnGetAllRelation(&relation, &relationNum);
486 EXPECT_EQ(ret, SOFTBUS_OK);
487 ret = LnnGetAllRelation(nullptr, &relationNum);
488 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
489 ret = LnnGetAllRelation(&relation, nullptr);
490 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
491 EXPECT_CALL(serviceMock, LnnUnregisterEventHandler).WillRepeatedly(Return());
492 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
493 EXPECT_CALL(lnnSyncInfoMock, LnnUnregSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_OK));
494 LnnDeinitTopoManager();
495 }
496 } // namespace OHOS