1 /*
2 * Copyright (c) 2022-2025 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_builder_mock.h"
20 #include "lnn_net_ledger_mock.h"
21 #include "lnn_network_info.c"
22 #include "lnn_network_info.h"
23 #include "lnn_service_mock.h"
24 #include "lnn_sync_info_mock.h"
25 #include "softbus_common.h"
26 #include "softbus_error_code.h"
27
28 namespace OHOS {
29 using namespace testing::ext;
30 using namespace testing;
31
32 constexpr char UUID[SHA_256_HEX_HASH_LEN] = "abc";
33 constexpr uint8_t MSG[] = "63";
34 constexpr char NETWORKID[] = "123456789";
35 constexpr char COEXISTCAP1[] = "[[{\"IF\":\"if1\",\"MODE\":1}],[{\"IF\":\"if2\",\"MODE\":2}]]";
36 constexpr char COEXISTCAP2[] = "[[{\"IF\":\"if1\",\"MODE\":2}],[{\"IF\":\"if2\",\"MODE\":8}]]";
37 constexpr char COEXISTCAP3[] = "{\"IF\":\"if1\",\"MODE\":2}";
38 constexpr char COEXISTCAP4[] = "[{\"IF\":\"if1\",\"MODE\":2}]";
39 constexpr uint32_t TYPE_0 = 0;
40 constexpr uint32_t TYPE_1 = 1;
41 constexpr uint32_t TYPE_2 = 2;
42 constexpr uint32_t TYPE_4 = 4;
43 constexpr uint32_t TYPE_8 = 8;
44 constexpr uint32_t TYPE_16 = 16;
45 constexpr uint32_t TYPE_63 = 63;
46 constexpr uint32_t TYPE_128 = 128;
47 constexpr uint32_t DISCOVERY_TYPE = 13111;
48 constexpr uint8_t USER_ID_MSG[] = "100";
49 constexpr uint32_t LEN = 10;
50
51 class LNNNetworkInfoTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void LNNNetworkInfoTest::SetUpTestCase() { }
60
TearDownTestCase()61 void LNNNetworkInfoTest::TearDownTestCase() { }
62
SetUp()63 void LNNNetworkInfoTest::SetUp() { }
64
TearDown()65 void LNNNetworkInfoTest::TearDown() { }
66
TestLnnRequestLeaveSpecific(const char * networkId,ConnectionAddrType addrType)67 int32_t TestLnnRequestLeaveSpecific(const char *networkId, ConnectionAddrType addrType)
68 {
69 (void)networkId;
70 (void)addrType;
71 return SOFTBUS_OK;
72 }
73
74 /*
75 * @tc.name: LNN_INIT_NETWORK_INFO_TEST_001
76 * @tc.desc: test LnnInitNetworkInfo
77 * @tc.type: FUNC
78 * @tc.require: I5PRUD
79 */
80 HWTEST_F(LNNNetworkInfoTest, LNN_INIT_NETWORK_INFO_TEST_001, TestSize.Level1)
81 {
82 NiceMock<LnnServicetInterfaceMock> serviceMock;
83 EXPECT_CALL(serviceMock, SoftBusHasWifiDirectCapability).WillRepeatedly(Return(true));
84 EXPECT_CALL(serviceMock, SoftBusGetWifiInterfaceCoexistCap).WillRepeatedly(Return(nullptr));
85 EXPECT_CALL(serviceMock, LnnRegisterEventHandler)
86 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
87 .WillOnce(Return(SOFTBUS_OK))
88 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
89 .WillRepeatedly(Return(SOFTBUS_OK));
90 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
91 EXPECT_CALL(syncInfoMock, LnnRegSyncInfoHandler)
92 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
93 .WillRepeatedly(Return(SOFTBUS_OK));
94 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
95 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(false)).WillRepeatedly(Return(true));
96 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
97 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
98 .WillRepeatedly(Return(SOFTBUS_OK));
99 const char *networkId = NETWORKID;
100 uint32_t capability = TYPE_128;
101 HandlePeerNetCapchanged(networkId, capability);
102 HandlePeerNetCapchanged(networkId, capability);
103 HandlePeerNetCapchanged(networkId, capability);
104 HandlePeerNetCapchanged(networkId, capability);
105 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
106 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
107 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
108 HandlePeerNetCapchanged(networkId, capability);
109 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillOnce(Return(false)).WillRepeatedly(Return(true));
110 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
111 HandlePeerNetCapchanged(networkId, capability);
112 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
113 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
114 HandlePeerNetCapchanged(networkId, capability);
115 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid)
116 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
117 .WillRepeatedly(Return(SOFTBUS_OK));
118 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
119 UpdateNetworkInfo(UUID);
120 UpdateNetworkInfo(UUID);
121 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
122 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
123 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
124 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_OK);
125 }
126
127 /*
128 * @tc.name: CONVERT_MSG_TO_CAPABILITY_TEST_001
129 * @tc.desc: test ConvertMsgToCapability
130 * @tc.type: FUNC
131 * @tc.require:
132 */
133 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_CAPABILITY_TEST_001, TestSize.Level1)
134 {
135 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
136 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific)
137 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
138 .WillRepeatedly(Return(SOFTBUS_OK));
139 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
140 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
141 uint32_t capability;
142 uint32_t len = BITS - 1;
143 uint32_t ret = ConvertMsgToCapability(nullptr, MSG, len);
144 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
145 ret = ConvertMsgToCapability(&capability, nullptr, len);
146 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
147 ret = ConvertMsgToCapability(&capability, MSG, len);
148 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
149 ret = ConvertMsgToCapability(&capability, MSG, BITS);
150 EXPECT_EQ(ret, SOFTBUS_OK);
151 }
152
153 /*
154 * @tc.name: IS_P2P_AVAILABLE_TEST_001
155 * @tc.desc: test IsP2pAvailable
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(LNNNetworkInfoTest, IS_P2P_AVAILABLE_TEST_001, TestSize.Level1)
160 {
161 const char *networkId = NETWORKID;
162 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_DEVICE_NAME, networkId, MSG, BITS);
163 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, nullptr, MSG, BITS);
164 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, nullptr, BITS);
165 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, 0);
166 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
167 NodeInfo info = {
168 .discoveryType = DISCOVERY_TYPE,
169 };
170 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
171 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
172 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
173 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
174 EXPECT_CALL(netLedgerMock, LnnSetDLConnCapability).WillRepeatedly(Return(SOFTBUS_OK));
175 NiceMock<LnnServicetInterfaceMock> serviceMock;
176 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
177 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
178 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
179 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
180 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
181 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
182 EXPECT_CALL(serviceMock, SoftBusIsWifiTripleMode).WillRepeatedly(Return(true));
183 bool ret = IsP2pAvailable();
184 EXPECT_EQ(ret, false);
185 }
186
187 /*
188 * @tc.name: WIFI_STATE_EVENT_HANDLER_TEST_002
189 * @tc.desc: test WifiStateEventHandler
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(LNNNetworkInfoTest, WIFI_STATE_EVENT_HANDLER_TEST_002, TestSize.Level1)
194 {
195 LnnMonitorWlanStateChangedEvent event = { .basic.event = LNN_EVENT_IP_ADDR_CHANGED,
196 .status = SOFTBUS_WIFI_UNKNOWN };
197 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
198 WifiStateEventHandler(nullptr);
199 WifiStateEventHandler(info);
200 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
201 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
202 event.basic.event = LNN_EVENT_WIFI_STATE_CHANGED;
203 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
204 WifiStateEventHandler(info1);
205 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
206 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
207 WifiStateEventHandler(info1);
208 const char *coexistCap2 = COEXISTCAP2;
209 EXPECT_EQ(IsSupportApCoexist(coexistCap2), false);
210 }
211
212 /*
213 * @tc.name: BT_STATE_CHANGE_EVENT_HANDLER_TEST_001
214 * @tc.desc: test BtStateChangeEventHandler
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(LNNNetworkInfoTest, BT_STATE_CHANGE_EVENT_HANDLER_TEST_001, TestSize.Level1)
219 {
220 LnnMonitorHbStateChangedEvent event = {
221 .basic.event = LNN_EVENT_WIFI_STATE_CHANGED,
222 .status = SOFTBUS_BT_UNKNOWN,
223 };
224 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
225 BtStateChangeEventHandler(nullptr);
226 BtStateChangeEventHandler(info);
227 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
228 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
229 event.basic.event = LNN_EVENT_BT_STATE_CHANGED;
230 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
231 BtStateChangeEventHandler(info1);
232 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
233 event.status = SOFTBUS_BR_TURN_ON;
234 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
235 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
236 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR));
237 const LnnEventBasicInfo *info2 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
238 BtStateChangeEventHandler(info2);
239 event.status = SOFTBUS_BLE_TURN_ON;
240 const LnnEventBasicInfo *info3 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
241 BtStateChangeEventHandler(info3);
242 event.status = SOFTBUS_BR_TURN_OFF;
243 const LnnEventBasicInfo *info4 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
244 BtStateChangeEventHandler(info4);
245 event.status = SOFTBUS_BLE_TURN_OFF;
246 const LnnEventBasicInfo *info5 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
247 BtStateChangeEventHandler(info5);
248 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
249 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR));
250 BtStateChangeEventHandler(info5);
251 event.status = SOFTBUS_BR_TURN_OFF;
252 const LnnEventBasicInfo *info6 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
253 BtStateChangeEventHandler(info6);
254 const char *coexistCap1 = COEXISTCAP1;
255 EXPECT_EQ(IsSupportApCoexist(coexistCap1), false);
256 }
257
258 /*
259 * @tc.name: CONVERT_CAPABILITY_TO_MSG_TEST_001
260 * @tc.desc: test ConvertCapabilityToMsg
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(LNNNetworkInfoTest, CONVERT_CAPABILITY_TO_MSG_TEST_001, TestSize.Level1)
265 {
266 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
267 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo)
268 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnlineNodeInfo);
269 EXPECT_CALL(netLedgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
270 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo)
271 .WillOnce(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR))
272 .WillRepeatedly(Return(SOFTBUS_OK));
273 WifiStateProcess(TYPE_63, true);
274 WifiStateProcess(TYPE_63, false);
275 SendNetCapabilityToRemote(TYPE_63, TYPE_1, false);
276 uint8_t *ret = ConvertCapabilityToMsg(TYPE_63);
277 EXPECT_TRUE(ret != nullptr);
278 SoftBusFree(ret);
279 }
280
281 /*
282 * @tc.name: IS_NEED_TO_SEND_TEST_001
283 * @tc.desc: test IsNeedToSend
284 * @tc.type: FUNC
285 * @tc.require:
286 */
287 HWTEST_F(LNNNetworkInfoTest, IS_NEED_TO_SEND_TEST_001, TestSize.Level1)
288 {
289 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
290 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
291 NiceMock<LnnServicetInterfaceMock> serviceMock;
292 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(false));
293 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
294 EXPECT_CALL(syncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_OK));
295 NodeInfo nodeInfo;
296 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
297 NodeBasicInfo netInfo;
298 (void)memset_s(&netInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
299 EXPECT_EQ(EOK, strcpy_s(netInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
300 uint32_t netCapability = TYPE_0;
301 uint32_t tmpMsg = TYPE_63;
302 uint8_t *msg = reinterpret_cast<uint8_t *>(&tmpMsg);
303 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_8);
304 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(true));
305 EXPECT_CALL(serviceMock, LnnStartHbByTypeAndStrategy).WillRepeatedly(Return(SOFTBUS_OK));
306 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_8);
307 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_2);
308 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
309 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
310 LnnClearNetBandCapability(&netCapability);
311 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_24G));
312 LnnSetNetBandCapability(&netCapability);
313 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_5G));
314 LnnSetNetBandCapability(&netCapability);
315 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_UNKNOWN));
316 LnnSetNetBandCapability(&netCapability);
317 bool ret = IsNeedToSend(&nodeInfo, TYPE_8);
318 EXPECT_EQ(ret, true);
319 ret = IsNeedToSend(&nodeInfo, TYPE_4);
320 EXPECT_EQ(ret, true);
321 ret = IsNeedToSend(&nodeInfo, TYPE_2);
322 EXPECT_EQ(ret, true);
323 ret = IsNeedToSend(&nodeInfo, TYPE_16);
324 EXPECT_EQ(ret, false);
325 }
326
327 /*
328 * @tc.name: GET_NETWORK_CAPABILITY_TEST_001
329 * @tc.desc: test GetNetworkCapability
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(LNNNetworkInfoTest, GET_NETWORK_CAPABILITY_TEST_001, TestSize.Level1)
334 {
335 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
336 NiceMock<LnnServicetInterfaceMock> serviceMock;
337 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
338 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
339 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_24G));
340 EXPECT_CALL(serviceMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
341 EXPECT_CALL(serviceMock, SoftBusIsWifiTripleMode).WillRepeatedly(Return(true));
342 uint32_t capability;
343 bool needSync = false;
344 GetNetworkCapability(SOFTBUS_WIFI_OBTAINING_IPADDR, &capability, &needSync);
345 EXPECT_EQ(needSync, false);
346 GetNetworkCapability(SOFTBUS_WIFI_ENABLED, &capability, &needSync);
347 EXPECT_EQ(needSync, true);
348 GetNetworkCapability(SOFTBUS_WIFI_CONNECTED, &capability, &needSync);
349 EXPECT_EQ(needSync, true);
350 GetNetworkCapability(SOFTBUS_WIFI_DISCONNECTED, &capability, &needSync);
351 EXPECT_EQ(needSync, true);
352 GetNetworkCapability(SOFTBUS_WIFI_DISABLED, &capability, &needSync);
353 EXPECT_EQ(needSync, true);
354 GetNetworkCapability(SOFTBUS_AP_ENABLED, &capability, &needSync);
355 EXPECT_EQ(needSync, true);
356 GetNetworkCapability(SOFTBUS_AP_DISABLED, &capability, &needSync);
357 EXPECT_EQ(needSync, true);
358 GetNetworkCapability(SOFTBUS_WIFI_SEMI_ACTIVE, &capability, &needSync);
359 EXPECT_EQ(needSync, true);
360 EXPECT_CALL(serviceMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_UNKNOWN));
361 LnnSetP2pNetCapability(&capability);
362 EXPECT_EQ(needSync, true);
363 }
364
365 /*
366 * @tc.name: IS_SUPPORT_AP_COEXIST_TEST_001
367 * @tc.desc: test IsSupportApCoexist
368 * @tc.type: FUNC
369 * @tc.require:
370 */
371 HWTEST_F(LNNNetworkInfoTest, IS_SUPPORT_AP_COEXIST_TEST_001, TestSize.Level1)
372 {
373 const char *coexistCap3 = COEXISTCAP3;
374 EXPECT_EQ(IsSupportApCoexist(coexistCap3), false);
375 const char *coexistCap4 = COEXISTCAP4;
376 EXPECT_EQ(IsSupportApCoexist(coexistCap4), false);
377 }
378
379 /*
380 * @tc.name: CONVERT_MSG_TO_USER_ID_TEST_001
381 * @tc.desc: test ConvertMsgToUserId
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USER_ID_TEST_001, TestSize.Level1)
386 {
387 uint32_t len = BITLEN - 1;
388 EXPECT_EQ(ConvertMsgToUserId(nullptr, nullptr, len), SOFTBUS_INVALID_PARAM);
389 int32_t userId = 0;
390 EXPECT_EQ(ConvertMsgToUserId(&userId, nullptr, len), SOFTBUS_INVALID_PARAM);
391 EXPECT_EQ(ConvertMsgToUserId(&userId, USER_ID_MSG, len), SOFTBUS_INVALID_PARAM);
392 len = BITLEN;
393 EXPECT_EQ(ConvertMsgToUserId(&userId, USER_ID_MSG, len), SOFTBUS_OK);
394 }
395
396 /*
397 * @tc.name: ON_RECEIVE_USER_ID_SYNCINFO_MSG_TEST_001
398 * @tc.desc: test OnReceiveUserIdSyncInfoMsg
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(LNNNetworkInfoTest, ON_RECEIVE_USER_ID_SYNCINFO_MSG_TEST_001, TestSize.Level1)
403 {
404 LnnSyncInfoType type = LNN_INFO_TYPE_PTK;
405 uint32_t len = BITLEN;
406 const char *networkId = NETWORKID;
407 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
408 type = LNN_INFO_TYPE_USERID;
409 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, nullptr, USER_ID_MSG, len));
410 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, nullptr, len));
411 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, 0));
412 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
413 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
414 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
415 .WillRepeatedly(Return(SOFTBUS_OK));
416 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
417 EXPECT_CALL(netBuilderMock, LnnSetDLConnUserId)
418 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
419 .WillRepeatedly(Return(SOFTBUS_OK));
420 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
421 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
422 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
423 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
424 }
425
426 /*
427 * @tc.name: ON_LNN_PROCESS_USER_CHANGE_MSG_DELAY_TEST_001
428 * @tc.desc: test OnLnnProcessUserChangeMsgDelay
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(LNNNetworkInfoTest, ON_LNN_PROCESS_USER_CHANGE_MSG_DELAY_TEST_001, TestSize.Level1)
433 {
434 EXPECT_NO_FATAL_FAILURE(OnLnnProcessUserChangeMsgDelay(nullptr));
435 void *para = static_cast<void *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
436 if (para == nullptr) {
437 return;
438 }
439 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
440 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
441 EXPECT_NO_FATAL_FAILURE(OnLnnProcessUserChangeMsgDelay(para));
442 }
443
444 /*
445 * @tc.name: LNN_ASYNC_SEND_USER_ID_TEST_001
446 * @tc.desc: test LnnAsyncSendUserId
447 * @tc.type: FUNC
448 * @tc.require:
449 */
450 HWTEST_F(LNNNetworkInfoTest, LNN_ASYNC_SEND_USER_ID_TEST_001, TestSize.Level1)
451 {
452 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(nullptr));
453 SendSyncInfoParam *data = reinterpret_cast<SendSyncInfoParam *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
454 if (data == nullptr) {
455 return;
456 }
457 data->msg = nullptr;
458 void *param = reinterpret_cast<void *>(data);
459 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(param));
460 SendSyncInfoParam *data1 = reinterpret_cast<SendSyncInfoParam *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
461 if (data1 == nullptr) {
462 return;
463 }
464 data1->len = LEN;
465 data1->msg = reinterpret_cast<uint8_t *>(SoftBusCalloc(data1->len));
466 if (data1->msg == nullptr) {
467 SoftBusFree(data1);
468 return;
469 }
470 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
471 EXPECT_CALL(syncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_OK));
472 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
473 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
474 void *param1 = reinterpret_cast<void *>(data1);
475 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(param1));
476 }
477
478 /*
479 * @tc.name: DO_SEND_USER_ID_TEST_001
480 * @tc.desc: test DoSendUserId
481 * @tc.type: FUNC
482 * @tc.require:
483 */
484 HWTEST_F(LNNNetworkInfoTest, DO_SEND_USER_ID_TEST_001, TestSize.Level1)
485 {
486 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
487 NodeInfo info;
488 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
489 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
490 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
491 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
492 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
493 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
494 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
495 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillOnce(Return(true)).WillRepeatedly(Return(false));
496 const char *udid = "udidTest";
497 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
498 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
499 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusMalloc(sizeof(SendSyncInfoParam));
500 if (data == nullptr) {
501 return;
502 }
503 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
504 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr)).WillRepeatedly(Return(data));
505 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
506 NiceMock<LnnServicetInterfaceMock> serviceMock;
507 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
508 EXPECT_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
509 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
510 }
511
512 /*
513 * @tc.name: CONVERT_USER_ID_TO_MSG_TEST_001
514 * @tc.desc: test ConvertUserIdToMsg
515 * @tc.type: FUNC
516 * @tc.require:
517 */
518 HWTEST_F(LNNNetworkInfoTest, CONVERT_USER_ID_TO_MSG_TEST_001, TestSize.Level1)
519 {
520 EXPECT_NE(ConvertUserIdToMsg(100), nullptr);
521 }
522
523 /*
524 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_001
525 * @tc.desc: test NotifyRemoteDevOffLineByUserId
526 * @tc.type: FUNC
527 * @tc.require:
528 */
529 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_001, TestSize.Level1)
530 {
531 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
532 NodeInfo info = { .userId = 101 };
533 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
534 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
535 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
536 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(DP_INACTIVE_DEFAULT_USERID, nullptr));
537 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(100, nullptr));
538 }
539
540 /*
541 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_002
542 * @tc.desc: test NotifyRemoteDevOffLineByUserId
543 * @tc.type: FUNC
544 * @tc.require:
545 */
546 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_002, TestSize.Level1)
547 {
548 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
549 NodeInfo info = { .userId = 0 };
550 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
551 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
552 .WillOnce(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)))
553 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
554 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(0, nullptr));
555 }
556
557 /*
558 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_003
559 * @tc.desc: test NotifyRemoteDevOffLineByUserId
560 * @tc.type: FUNC
561 * @tc.require:
562 */
563 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_003, TestSize.Level1)
564 {
565 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
566 NodeInfo info = { .userId = 100 };
567 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
568 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
569 .WillOnce(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)))
570 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
571 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(100, nullptr));
572 }
573
574 /*
575 * @tc.name: IS_SUPPORT_AP_COEXIST_TEST_002
576 * @tc.desc: test IsSupportApCoexist
577 * @tc.type: FUNC
578 * @tc.require:
579 */
580 HWTEST_F(LNNNetworkInfoTest, IS_SUPPORT_AP_COEXIST_TEST_002, TestSize.Level1)
581 {
582 const char *coexistCap3 = COEXISTCAP3;
583 EXPECT_EQ(IsSupportApCoexist(coexistCap3), false);
584 const char *coexistCap4 = COEXISTCAP4;
585 EXPECT_EQ(IsSupportApCoexist(coexistCap4), false);
586 }
587
588 /*
589 * @tc.name: CONVERT_MSG_TO_USERID_TEST_001
590 * @tc.desc: Test case for ConvertMsgToUserId with valid input.
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_001, TestSize.Level1)
595 {
596 int32_t userId = 0;
597 uint8_t msg[BITLEN] = { 0xFF, 0xFF, 0xFF, 0xFF };
598 uint32_t len = BITLEN;
599 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
600 EXPECT_EQ(ret, SOFTBUS_OK);
601 EXPECT_EQ(userId, 0xFFFFFFFF);
602 }
603
604 /*
605 * @tc.name: CONVERT_MSG_TO_USERID_TEST_002
606 * @tc.desc: Test case for ConvertMsgToUserId with all zeros in the message.
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_002, TestSize.Level1)
611 {
612 int32_t userId = 0;
613 uint8_t msg[BITLEN] = { 0x00, 0x00, 0x00, 0x00 };
614 uint32_t len = BITLEN;
615 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
616 EXPECT_EQ(ret, SOFTBUS_OK);
617 EXPECT_EQ(userId, 0x0);
618 }
619
620 /*
621 * @tc.name: CONVERT_MSG_TO_USERID_TEST_003
622 * @tc.desc: Test case for ConvertMsgToUserId with the first two bytes set to FF.
623 * @tc.type: FUNC
624 * @tc.require:
625 */
626 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_003, TestSize.Level1)
627 {
628 int32_t userId = 0;
629 uint8_t msg[BITLEN] = { 0xFF, 0xFF, 0x00, 0x00 };
630 uint32_t len = BITLEN;
631 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
632 EXPECT_EQ(ret, SOFTBUS_OK);
633 }
634
635 /*
636 * @tc.name: CONVERT_MSG_TO_USERID_TEST_004
637 * @tc.desc: Test case for ConvertMsgToUserId with the last two bytes set to FF.
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_004, TestSize.Level1)
642 {
643 int32_t userId = 0;
644 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
645 uint32_t len = BITLEN;
646 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
647 EXPECT_EQ(ret, SOFTBUS_OK);
648 }
649
650 /*
651 * @tc.name: CONVERT_MSG_TO_USERID_TEST_005
652 * @tc.desc: Test case for ConvertMsgToUserId with len one less than BITLEN.
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_005, TestSize.Level1)
657 {
658 int32_t userId = 0;
659 uint8_t msg[BITLEN] = { 0x00, 0x00, 0x00, 0x00 };
660 uint32_t len = BITLEN - 1;
661 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
662 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
663 }
664
665 /*
666 * @tc.name: CONVERT_MSG_TO_USERID_TEST_006
667 * @tc.desc: Test case for ConvertMsgToUserId with userId as NULL.
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_006, TestSize.Level1)
672 {
673 uint8_t msg[BITLEN] = { 0x00, 0x00, 0x00, 0x00 };
674 uint32_t len = BITLEN;
675 uint32_t ret = ConvertMsgToUserId(nullptr, msg, len);
676 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
677 }
678
679 /*
680 * @tc.name: CONVERT_MSG_TO_USERID_TEST_007
681 * @tc.desc: Test case for ConvertMsgToUserId with msg as NULL.
682 * @tc.type: FUNC
683 * @tc.require:
684 */
685 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_007, TestSize.Level1)
686 {
687 int32_t userId = 0;
688 uint32_t len = BITLEN;
689 uint32_t ret = ConvertMsgToUserId(&userId, nullptr, len);
690 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
691 }
692
693 /*
694 * @tc.name: CONVERT_MSG_TO_USERID_TEST_008
695 * @tc.desc: Test case for ConvertMsgToUserId and OnReceiveUserIdSyncInfoMsg with valid input.
696 * @tc.type: FUNC
697 * @tc.require:
698 */
699 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USERID_TEST_008, TestSize.Level1)
700 {
701 const char *networkId = NETWORKID;
702 int32_t userId = 0;
703 uint8_t msg[BITLEN] = { 0xFF, 0xFF, 0xFF, 0xFF };
704 uint32_t len = BITLEN;
705 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
706 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
707 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_CONNECTION_INFO, networkId, msg, len);
708 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, nullptr, msg, len);
709 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, nullptr, len);
710 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, 0);
711 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, len - 1);
712 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
713 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
714 .WillRepeatedly(Return(SOFTBUS_OK));
715 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, len);
716 EXPECT_CALL(netBuilderMock, LnnSetDLConnUserId)
717 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
718 .WillRepeatedly(Return(SOFTBUS_OK));
719 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, len);
720 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, len);
721 OnReceiveUserIdSyncInfoMsg(LNN_INFO_TYPE_USERID, networkId, msg, len);
722 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
723 EXPECT_EQ(ret, SOFTBUS_OK);
724 EXPECT_EQ(userId, 0xFFFFFFFF);
725 }
726
727 /*
728 * @tc.name: LnnProcessUserChangeMsg_Test_001
729 * @tc.desc: Test LnnProcessUserChangeMsg with all possible conditions
730 * @tc.type: FUNC
731 * @tc.require:
732 */
733 HWTEST_F(LNNNetworkInfoTest, LnnProcessUserChangeMsg_Test_001, TestSize.Level1)
734 {
735 int32_t userId = 0;
736 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
737 uint32_t len = BITLEN;
738 const char *networkId = NETWORKID;
739 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
740 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
741 LnnProcessUserChangeMsg(LNN_INFO_TYPE_DEVICE_NAME, networkId, msg, len);
742 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
743 EXPECT_EQ(ret, SOFTBUS_OK);
744 }
745
746 /*
747 * @tc.name: OnLnnProcessUserChangeMsgDelay_Test_001
748 * @tc.desc: Test OnLnnProcessUserChangeMsgDelay with all possible conditions
749 * @tc.type: FUNC
750 * @tc.require:
751 */
752 HWTEST_F(LNNNetworkInfoTest, OnLnnProcessUserChangeMsgDelay_Test_001, TestSize.Level1)
753 {
754 int32_t userId = 0;
755 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
756 uint32_t len = BITLEN;
757 OnLnnProcessUserChangeMsgDelay(nullptr);
758 LnnAsyncSendUserId(nullptr);
759 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
760 EXPECT_EQ(ret, SOFTBUS_OK);
761 }
762
763 /*
764 * @tc.name: LnnAsyncSendUserId_Test_001
765 * @tc.desc: Test LnnAsyncSendUserId with all possible conditions
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(LNNNetworkInfoTest, LnnAsyncSendUserId_Test_001, TestSize.Level1)
770 {
771 int32_t userId = 0;
772 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
773 uint32_t len = BITLEN;
774 SendSyncInfoParam *dataInfo = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
775 ASSERT_NE(dataInfo, nullptr);
776 LnnAsyncSendUserId(dataInfo);
777 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
778 EXPECT_EQ(ret, SOFTBUS_OK);
779 }
780
781 /*
782 * @tc.name: LnnAsyncSendUserId_Test_002
783 * @tc.desc: Test LnnAsyncSendUserId with all possible conditions
784 * @tc.type: FUNC
785 * @tc.require:
786 */
787 HWTEST_F(LNNNetworkInfoTest, LnnAsyncSendUserId_Test_002, TestSize.Level1)
788 {
789 int32_t userId = 0;
790 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
791 uint32_t len = BITLEN;
792 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
793 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
794 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
795 EXPECT_CALL(syncInfoMock, LnnSendSyncInfoMsg)
796 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
797 .WillRepeatedly(Return(SOFTBUS_OK));
798 SendSyncInfoParam *dataInfo = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
799 ASSERT_NE(dataInfo, nullptr);
800 dataInfo->msg = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
801 if (dataInfo->msg == nullptr) {
802 SoftBusFree(dataInfo);
803 ASSERT_NE(dataInfo->msg, nullptr);
804 }
805
806 LnnAsyncSendUserId(dataInfo);
807 dataInfo = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
808 ASSERT_NE(dataInfo, nullptr);
809 dataInfo->msg = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
810 if (dataInfo->msg == nullptr) {
811 SoftBusFree(dataInfo);
812 ASSERT_NE(dataInfo->msg, nullptr);
813 }
814 LnnAsyncSendUserId(dataInfo);
815 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
816 EXPECT_EQ(ret, SOFTBUS_OK);
817 }
818
819 /*
820 * @tc.name: DoSendUserId_Test_001
821 * @tc.desc: Test DoSendUserId with all possible conditions
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_001, TestSize.Level1)
826 {
827 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
828 ASSERT_NE(data, nullptr);
829
830 int32_t userId = 0;
831 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
832 uint32_t len = BITLEN;
833 const char *udid = NETWORKID;
834
835 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
836 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
837 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
838 NiceMock<LnnServicetInterfaceMock> serviceMock;
839 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
840 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
841 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
842 .WillRepeatedly(Return(SOFTBUS_OK));
843 DoSendUserId(udid, msg);
844 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
845 DoSendUserId(udid, msg);
846 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
847 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
848 EXPECT_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
849 DoSendUserId(udid, msg);
850 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
851 EXPECT_EQ(ret, SOFTBUS_OK);
852 SoftBusFree(data);
853 }
854
855 /*
856 * @tc.name: DoSendUserId_Test_002
857 * @tc.desc: Test DoSendUserId with all possible conditions
858 * @tc.type: FUNC
859 * @tc.require:
860 */
861 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_002, TestSize.Level1)
862 {
863 int32_t userId = 0;
864 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
865 uint32_t len = BITLEN;
866 const char *udid = NETWORKID;
867 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
868 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
869 NiceMock<LnnServicetInterfaceMock> serviceMock;
870 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
871 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
872 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
873 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
874 DoSendUserId(udid, msg);
875 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
876 EXPECT_EQ(ret, SOFTBUS_OK);
877 }
878
879 /*
880 * @tc.name: DoSendUserId_Test_003
881 * @tc.desc: Test DoSendUserId with all possible conditions
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_003, TestSize.Level1)
886 {
887 int32_t userId = 0;
888 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
889 uint32_t len = BITLEN;
890 const char *udid = NETWORKID;
891 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
892 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
893 NiceMock<LnnServicetInterfaceMock> serviceMock;
894 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
895 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
896 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
897 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
898 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(nullptr));
899 DoSendUserId(udid, msg);
900 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
901 EXPECT_EQ(ret, SOFTBUS_OK);
902 }
903
904 /*
905 * @tc.name: DoSendUserId_Test_004
906 * @tc.desc: Test DoSendUserId with all possible conditions
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_004, TestSize.Level1)
911 {
912 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
913 ASSERT_NE(data, nullptr);
914 int32_t userId = 0;
915 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
916 uint32_t len = BITLEN;
917 const char *udid = NETWORKID;
918 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
919 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
920 NiceMock<LnnServicetInterfaceMock> serviceMock;
921 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
922 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
923 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
924 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
925 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
926 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
927 DoSendUserId(udid, msg);
928 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
929 EXPECT_EQ(ret, SOFTBUS_OK);
930 if (data != nullptr) {
931 SoftBusFree(data);
932 }
933 }
934
935 /*
936 * @tc.name: DoSendUserId_Test_005
937 * @tc.desc: Test DoSendUserId with all possible conditions
938 * @tc.type: FUNC
939 * @tc.require:LnnAsyncCallbackHelper return SOFTBUS_INVALID_PARAM
940 */
941 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_005, TestSize.Level1)
942 {
943 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
944 ASSERT_NE(data, nullptr);
945 int32_t userId = 0;
946 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
947 uint32_t len = BITLEN;
948 const char *udid = NETWORKID;
949
950 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
951 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
952 NiceMock<LnnServicetInterfaceMock> serviceMock;
953 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
954 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
955 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
956 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
957 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
958 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
959 DoSendUserId(udid, msg);
960 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
961 EXPECT_EQ(ret, SOFTBUS_OK);
962 }
963
964 /*
965 * @tc.name: DoSendUserId_Test_006
966 * @tc.desc: Test DoSendUserId with all possible conditions
967 * @tc.type: FUNC
968 * @tc.require: LnnAsyncCallbackDelayHelper return SOFTBUS_INVALID_PARAM
969 */
970 HWTEST_F(LNNNetworkInfoTest, DoSendUserId_Test_006, TestSize.Level1)
971 {
972 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
973 ASSERT_NE(data, nullptr);
974
975 int32_t userId = 0;
976 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
977 uint32_t len = BITLEN;
978 const char *udid = NETWORKID;
979 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
980 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
981 NiceMock<LnnServicetInterfaceMock> serviceMock;
982 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
983 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
984 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
985 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
986 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
987 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
988 EXPECT_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
989 DoSendUserId(udid, msg);
990 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
991 EXPECT_EQ(ret, SOFTBUS_OK);
992 if (data != nullptr) {
993 SoftBusFree(data);
994 }
995 }
996
997 /*
998 * @tc.name: NotifyRemoteDevOffLineByUserId_Test_001
999 * @tc.desc: TestNotifyRemoteDevOffLineByUserId with all possible conditions
1000 * @tc.type: FUNC
1001 * @tc.require:
1002 */
1003 HWTEST_F(LNNNetworkInfoTest, NotifyRemoteDevOffLineByUserId_Test_001, TestSize.Level1)
1004 {
1005 int32_t userId = 0;
1006 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1007 uint32_t len = BITLEN;
1008 const char *udid = NETWORKID;
1009 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
1010 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
1011 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
1012 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
1013 NiceMock<LnnServicetInterfaceMock> serviceMock;
1014 userId = BITLEN;
1015 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
__anon076b64780102(const char *id, IdCategory type, NodeInfo *nodeInfo) 1016 .WillRepeatedly(testing::Invoke([](const char *id, IdCategory type, NodeInfo *nodeInfo) {
1017 if (nodeInfo != nullptr) {
1018 nodeInfo->userId = BITS;
1019 }
1020 return SOFTBUS_OK;
1021 }));
1022 NotifyRemoteDevOffLineByUserId(userId, udid);
1023 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1024 EXPECT_EQ(ret, SOFTBUS_OK);
1025 }
1026
1027 /*
1028 * @tc.name: NotifyRemoteDevOffLineByUserId_Test_002
1029 * @tc.desc: TestNotifyRemoteDevOffLineByUserId with all possible conditions
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(LNNNetworkInfoTest, NotifyRemoteDevOffLineByUserId_Test_002, TestSize.Level1)
1034 {
1035 int32_t userId = 0;
1036 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1037 uint32_t len = BITLEN;
1038 const char *udid = NETWORKID;
1039 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
1040 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
1041 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
1042 userId = DP_INACTIVE_DEFAULT_USERID;
1043 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
__anon076b64780202(const char *id, IdCategory type, NodeInfo *nodeInfo) 1044 .WillRepeatedly(testing::Invoke([](const char *id, IdCategory type, NodeInfo *nodeInfo) {
1045 if (nodeInfo != nullptr) {
1046 nodeInfo->userId = 123;
1047 }
1048 return SOFTBUS_INVALID_PARAM;
1049 }));
1050 NotifyRemoteDevOffLineByUserId(userId, udid);
1051 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1052 EXPECT_EQ(ret, SOFTBUS_OK);
1053 }
1054
1055 /*
1056 * @tc.name: NotifyRemoteDevOffLineByUserId_Test_003
1057 * @tc.desc: TestNotifyRemoteDevOffLineByUserId with all possible conditions
1058 * @tc.type: FUNC
1059 * @tc.require:
1060 */
1061 HWTEST_F(LNNNetworkInfoTest, NotifyRemoteDevOffLineByUserId_Test_003, TestSize.Level1)
1062 {
1063 int32_t userId = 0;
1064 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1065 uint32_t len = BITLEN;
1066 const char *udid = NETWORKID;
1067 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
1068 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
1069 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
1070 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(nullptr));
1071
1072 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
1073 userId = BITS;
1074 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
__anon076b64780302(const char *id, IdCategory type, NodeInfo *nodeInfo) 1075 .WillRepeatedly(testing::Invoke([](const char *id, IdCategory type, NodeInfo *nodeInfo) {
1076 if (nodeInfo != nullptr) {
1077 nodeInfo->userId = BITS;
1078 }
1079 return SOFTBUS_OK;
1080 }));
1081 NotifyRemoteDevOffLineByUserId(userId, udid);
1082 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1083 EXPECT_EQ(ret, SOFTBUS_OK);
1084 }
1085
1086 /*
1087 * @tc.name: NotifyRemoteDevOffLineByUserId_Test_004
1088 * @tc.desc: TestNotifyRemoteDevOffLineByUserId with all possible conditions
1089 * @tc.type: FUNC
1090 * @tc.require:
1091 */
1092 HWTEST_F(LNNNetworkInfoTest, NotifyRemoteDevOffLineByUserId_Test_004, TestSize.Level1)
1093 {
1094 int32_t userId = 0;
1095 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1096 uint32_t len = BITLEN;
1097 const char *udid = NETWORKID;
1098 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
1099 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
1100 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
1101 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(nullptr));
1102 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
1103 userId = BITS;
1104 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
__anon076b64780402(const char *id, IdCategory type, NodeInfo *nodeInfo) 1105 .WillRepeatedly(testing::Invoke([](const char *id, IdCategory type, NodeInfo *nodeInfo) {
1106 if (nodeInfo != nullptr) {
1107 nodeInfo->userId = 0;
1108 }
1109 return SOFTBUS_OK;
1110 }));
1111 NotifyRemoteDevOffLineByUserId(userId, udid);
1112 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1113 EXPECT_EQ(ret, SOFTBUS_OK);
1114 }
1115
1116 /*
1117 * @tc.name: NotifyRemoteDevOffLineByUserId_Test_005
1118 * @tc.desc: TestNotifyRemoteDevOffLineByUserId with all possible conditions
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(LNNNetworkInfoTest, NotifyRemoteDevOffLineByUserId_Test_005, TestSize.Level1)
1123 {
1124 int32_t userId = 0;
1125 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1126 uint32_t len = BITLEN;
1127 const char *udid = NETWORKID;
1128 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
1129 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
1130 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(TestLnnRequestLeaveSpecific);
1131 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(nullptr));
1132 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
1133 userId = DP_INACTIVE_DEFAULT_USERID;
1134 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
__anon076b64780502(const char *id, IdCategory type, NodeInfo *nodeInfo) 1135 .WillRepeatedly(testing::Invoke([](const char *id, IdCategory type, NodeInfo *nodeInfo) {
1136 if (nodeInfo != nullptr) {
1137 nodeInfo->userId = 0;
1138 }
1139 return SOFTBUS_OK;
1140 }));
1141 NotifyRemoteDevOffLineByUserId(userId, udid);
1142 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1143 EXPECT_EQ(ret, SOFTBUS_OK);
1144 }
1145
1146 /*
1147 * @tc.name: ConvertUserIdToMsg_Test_001
1148 * @tc.desc: TestConvertUserIdToMsg with all possible conditions
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 HWTEST_F(LNNNetworkInfoTest, ConvertUserIdToMsg_Test_001, TestSize.Level1)
1153 {
1154 int32_t userId = 0;
1155 uint8_t msg[BITLEN] = { 0x00, 0xFF, 0xFF, 0xFF };
1156 uint32_t len = BITLEN;
1157 uint8_t *rettest = ConvertUserIdToMsg(userId);
1158 EXPECT_NE(rettest, nullptr);
1159 uint32_t ret = ConvertMsgToUserId(&userId, msg, len);
1160 EXPECT_EQ(ret, SOFTBUS_OK);
1161 }
1162
1163 } // namespace OHOS
1164