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