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_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
67 /*
68 * @tc.name: LNN_INIT_NETWORK_INFO_TEST_001
69 * @tc.desc: test LnnInitNetworkInfo
70 * @tc.type: FUNC
71 * @tc.require: I5PRUD
72 */
73 HWTEST_F(LNNNetworkInfoTest, LNN_INIT_NETWORK_INFO_TEST_001, TestSize.Level1)
74 {
75 NiceMock<LnnServicetInterfaceMock> serviceMock;
76 EXPECT_CALL(serviceMock, SoftBusHasWifiDirectCapability).WillRepeatedly(Return(true));
77 EXPECT_CALL(serviceMock, SoftBusGetWifiInterfaceCoexistCap).WillRepeatedly(Return(nullptr));
78 EXPECT_CALL(serviceMock, LnnRegisterEventHandler)
79 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
80 .WillOnce(Return(SOFTBUS_OK))
81 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
82 .WillRepeatedly(Return(SOFTBUS_OK));
83 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
84 EXPECT_CALL(syncInfoMock, LnnRegSyncInfoHandler)
85 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
86 .WillRepeatedly(Return(SOFTBUS_OK));
87 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
88 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(false)).WillRepeatedly(Return(true));
89 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
90 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
91 .WillRepeatedly(Return(SOFTBUS_OK));
92 const char *networkId = NETWORKID;
93 uint32_t capability = TYPE_128;
94 HandlePeerNetCapchanged(networkId, capability);
95 HandlePeerNetCapchanged(networkId, capability);
96 HandlePeerNetCapchanged(networkId, capability);
97 HandlePeerNetCapchanged(networkId, capability);
98 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
99 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
100 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
101 HandlePeerNetCapchanged(networkId, capability);
102 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillOnce(Return(false)).WillRepeatedly(Return(true));
103 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
104 HandlePeerNetCapchanged(networkId, capability);
105 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
106 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
107 HandlePeerNetCapchanged(networkId, capability);
108 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid)
109 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
110 .WillRepeatedly(Return(SOFTBUS_OK));
111 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
112 UpdateNetworkInfo(UUID);
113 UpdateNetworkInfo(UUID);
114 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
115 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
116 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_INVALID_PARAM);
117 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_OK);
118 }
119
120 /*
121 * @tc.name: CONVERT_MSG_TO_CAPABILITY_TEST_001
122 * @tc.desc: test ConvertMsgToCapability
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_CAPABILITY_TEST_001, TestSize.Level1)
127 {
128 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
129 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific)
130 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
131 .WillRepeatedly(Return(SOFTBUS_OK));
132 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
133 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
134 uint32_t capability;
135 uint32_t len = BITS - 1;
136 uint32_t ret = ConvertMsgToCapability(nullptr, MSG, len);
137 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
138 ret = ConvertMsgToCapability(&capability, nullptr, len);
139 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
140 ret = ConvertMsgToCapability(&capability, MSG, len);
141 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
142 ret = ConvertMsgToCapability(&capability, MSG, BITS);
143 EXPECT_EQ(ret, SOFTBUS_OK);
144 }
145
146 /*
147 * @tc.name: IS_P2P_AVAILABLE_TEST_001
148 * @tc.desc: test IsP2pAvailable
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(LNNNetworkInfoTest, IS_P2P_AVAILABLE_TEST_001, TestSize.Level1)
153 {
154 const char *networkId = NETWORKID;
155 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_DEVICE_NAME, networkId, MSG, BITS);
156 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, nullptr, MSG, BITS);
157 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, nullptr, BITS);
158 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, 0);
159 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
160 NodeInfo info = {
161 .discoveryType = DISCOVERY_TYPE,
162 };
163 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
164 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
165 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
166 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
167 EXPECT_CALL(netLedgerMock, LnnSetDLConnCapability).WillRepeatedly(Return(SOFTBUS_OK));
168 NiceMock<LnnServicetInterfaceMock> serviceMock;
169 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
170 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
171 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
172 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
173 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
174 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
175 EXPECT_CALL(serviceMock, SoftBusIsWifiTripleMode).WillRepeatedly(Return(true));
176 bool ret = IsP2pAvailable(true);
177 EXPECT_EQ(ret, false);
178 }
179
180 /*
181 * @tc.name: WIFI_STATE_EVENT_HANDLER_TEST_002
182 * @tc.desc: test WifiStateEventHandler
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(LNNNetworkInfoTest, WIFI_STATE_EVENT_HANDLER_TEST_002, TestSize.Level1)
187 {
188 LnnMonitorWlanStateChangedEvent event = { .basic.event = LNN_EVENT_IP_ADDR_CHANGED,
189 .status = SOFTBUS_WIFI_UNKNOWN };
190 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
191 WifiStateEventHandler(nullptr);
192 WifiStateEventHandler(info);
193 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
194 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
195 event.basic.event = LNN_EVENT_WIFI_STATE_CHANGED;
196 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
197 WifiStateEventHandler(info1);
198 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
199 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
200 WifiStateEventHandler(info1);
201 const char *coexistCap2 = COEXISTCAP2;
202 EXPECT_EQ(IsSupportApCoexist(coexistCap2), false);
203 }
204
205 /*
206 * @tc.name: BT_STATE_CHANGE_EVENT_HANDLER_TEST_001
207 * @tc.desc: test BtStateChangeEventHandler
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(LNNNetworkInfoTest, BT_STATE_CHANGE_EVENT_HANDLER_TEST_001, TestSize.Level1)
212 {
213 LnnMonitorHbStateChangedEvent event = {
214 .basic.event = LNN_EVENT_WIFI_STATE_CHANGED,
215 .status = SOFTBUS_BT_UNKNOWN,
216 };
217 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
218 BtStateChangeEventHandler(nullptr);
219 BtStateChangeEventHandler(info);
220 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
221 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
222 event.basic.event = LNN_EVENT_BT_STATE_CHANGED;
223 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
224 BtStateChangeEventHandler(info1);
225 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
226 event.status = SOFTBUS_BR_TURN_ON;
227 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
228 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
229 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR));
230 const LnnEventBasicInfo *info2 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
231 BtStateChangeEventHandler(info2);
232 event.status = SOFTBUS_BLE_TURN_ON;
233 const LnnEventBasicInfo *info3 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
234 BtStateChangeEventHandler(info3);
235 event.status = SOFTBUS_BR_TURN_OFF;
236 const LnnEventBasicInfo *info4 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
237 BtStateChangeEventHandler(info4);
238 event.status = SOFTBUS_BLE_TURN_OFF;
239 const LnnEventBasicInfo *info5 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
240 BtStateChangeEventHandler(info5);
241 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
242 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR));
243 BtStateChangeEventHandler(info5);
244 event.status = SOFTBUS_BR_TURN_OFF;
245 const LnnEventBasicInfo *info6 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
246 BtStateChangeEventHandler(info6);
247 const char *coexistCap1 = COEXISTCAP1;
248 EXPECT_EQ(IsSupportApCoexist(coexistCap1), false);
249 }
250
251 /*
252 * @tc.name: CONVERT_CAPABILITY_TO_MSG_TEST_001
253 * @tc.desc: test ConvertCapabilityToMsg
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(LNNNetworkInfoTest, CONVERT_CAPABILITY_TO_MSG_TEST_001, TestSize.Level1)
258 {
259 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
260 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo)
261 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnlineNodeInfo);
262 EXPECT_CALL(netLedgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
263 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo)
264 .WillOnce(Return(SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR))
265 .WillRepeatedly(Return(SOFTBUS_OK));
266 WifiStateProcess(TYPE_63, true);
267 WifiStateProcess(TYPE_63, false);
268 SendNetCapabilityToRemote(TYPE_63, TYPE_1);
269 uint8_t *ret = ConvertCapabilityToMsg(TYPE_63);
270 EXPECT_TRUE(ret != nullptr);
271 SoftBusFree(ret);
272 }
273
274 /*
275 * @tc.name: IS_NEED_TO_SEND_TEST_001
276 * @tc.desc: test IsNeedToSend
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(LNNNetworkInfoTest, IS_NEED_TO_SEND_TEST_001, TestSize.Level1)
281 {
282 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
283 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
284 NiceMock<LnnServicetInterfaceMock> serviceMock;
285 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(false));
286 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
287 EXPECT_CALL(syncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_OK));
288 NodeInfo nodeInfo;
289 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
290 NodeBasicInfo netInfo;
291 (void)memset_s(&netInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
292 EXPECT_EQ(EOK, strcpy_s(netInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
293 uint32_t netCapability = TYPE_0;
294 uint32_t tmpMsg = TYPE_63;
295 uint8_t *msg = reinterpret_cast<uint8_t *>(&tmpMsg);
296 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_8);
297 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(true));
298 EXPECT_CALL(serviceMock, LnnStartHbByTypeAndStrategy).WillRepeatedly(Return(SOFTBUS_OK));
299 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_8);
300 DoSendCapability(nodeInfo, netInfo, msg, netCapability, TYPE_2);
301 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
302 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
303 LnnClearNetBandCapability(&netCapability);
304 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_24G));
305 LnnSetNetBandCapability(&netCapability);
306 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_5G));
307 LnnSetNetBandCapability(&netCapability);
308 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_UNKNOWN));
309 LnnSetNetBandCapability(&netCapability);
310 bool ret = IsNeedToSend(&nodeInfo, TYPE_8);
311 EXPECT_EQ(ret, true);
312 ret = IsNeedToSend(&nodeInfo, TYPE_4);
313 EXPECT_EQ(ret, true);
314 ret = IsNeedToSend(&nodeInfo, TYPE_2);
315 EXPECT_EQ(ret, true);
316 ret = IsNeedToSend(&nodeInfo, TYPE_16);
317 EXPECT_EQ(ret, false);
318 }
319
320 /*
321 * @tc.name: GET_NETWORK_CAPABILITY_TEST_001
322 * @tc.desc: test GetNetworkCapability
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 HWTEST_F(LNNNetworkInfoTest, GET_NETWORK_CAPABILITY_TEST_001, TestSize.Level1)
327 {
328 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
329 NiceMock<LnnServicetInterfaceMock> serviceMock;
330 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
331 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
332 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(BAND_24G));
333 EXPECT_CALL(serviceMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
334 EXPECT_CALL(serviceMock, SoftBusIsWifiTripleMode).WillRepeatedly(Return(true));
335 uint32_t capability;
336 bool needSync = false;
337 GetNetworkCapability(SOFTBUS_WIFI_OBTAINING_IPADDR, &capability, &needSync);
338 EXPECT_EQ(needSync, false);
339 GetNetworkCapability(SOFTBUS_WIFI_ENABLED, &capability, &needSync);
340 EXPECT_EQ(needSync, true);
341 GetNetworkCapability(SOFTBUS_WIFI_CONNECTED, &capability, &needSync);
342 EXPECT_EQ(needSync, true);
343 GetNetworkCapability(SOFTBUS_WIFI_DISCONNECTED, &capability, &needSync);
344 EXPECT_EQ(needSync, true);
345 GetNetworkCapability(SOFTBUS_WIFI_DISABLED, &capability, &needSync);
346 EXPECT_EQ(needSync, true);
347 GetNetworkCapability(SOFTBUS_AP_ENABLED, &capability, &needSync);
348 EXPECT_EQ(needSync, true);
349 GetNetworkCapability(SOFTBUS_AP_DISABLED, &capability, &needSync);
350 EXPECT_EQ(needSync, true);
351 GetNetworkCapability(SOFTBUS_WIFI_SEMI_ACTIVE, &capability, &needSync);
352 EXPECT_EQ(needSync, true);
353 EXPECT_CALL(serviceMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_UNKNOWN));
354 LnnSetP2pNetCapability(&capability);
355 EXPECT_EQ(needSync, true);
356 }
357
358 /*
359 * @tc.name: IS_SUPPORT_AP_COEXIST_TEST_001
360 * @tc.desc: test IsSupportApCoexist
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(LNNNetworkInfoTest, IS_SUPPORT_AP_COEXIST_TEST_001, TestSize.Level1)
365 {
366 const char *coexistCap3 = COEXISTCAP3;
367 EXPECT_EQ(IsSupportApCoexist(coexistCap3), false);
368 const char *coexistCap4 = COEXISTCAP4;
369 EXPECT_EQ(IsSupportApCoexist(coexistCap4), false);
370 }
371
372 /*
373 * @tc.name: CONVERT_MSG_TO_USER_ID_TEST_001
374 * @tc.desc: test ConvertMsgToUserId
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_USER_ID_TEST_001, TestSize.Level1)
379 {
380 uint32_t len = BITLEN - 1;
381 EXPECT_EQ(ConvertMsgToUserId(nullptr, nullptr, len), SOFTBUS_INVALID_PARAM);
382 int32_t userId = 0;
383 EXPECT_EQ(ConvertMsgToUserId(&userId, nullptr, len), SOFTBUS_INVALID_PARAM);
384 EXPECT_EQ(ConvertMsgToUserId(&userId, USER_ID_MSG, len), SOFTBUS_INVALID_PARAM);
385 len = BITLEN;
386 EXPECT_EQ(ConvertMsgToUserId(&userId, USER_ID_MSG, len), SOFTBUS_OK);
387 }
388
389 /*
390 * @tc.name: ON_RECEIVE_USER_ID_SYNCINFO_MSG_TEST_001
391 * @tc.desc: test OnReceiveUserIdSyncInfoMsg
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(LNNNetworkInfoTest, ON_RECEIVE_USER_ID_SYNCINFO_MSG_TEST_001, TestSize.Level1)
396 {
397 LnnSyncInfoType type = LNN_INFO_TYPE_PTK;
398 uint32_t len = BITLEN;
399 const char *networkId = NETWORKID;
400 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
401 type = LNN_INFO_TYPE_USERID;
402 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, nullptr, USER_ID_MSG, len));
403 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, nullptr, len));
404 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, 0));
405 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
406 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
407 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
408 .WillRepeatedly(Return(SOFTBUS_OK));
409 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
410 EXPECT_CALL(netBuilderMock, LnnSetDLConnUserId)
411 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
412 .WillRepeatedly(Return(SOFTBUS_OK));
413 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
414 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
415 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
416 EXPECT_NO_FATAL_FAILURE(OnReceiveUserIdSyncInfoMsg(type, networkId, USER_ID_MSG, len));
417 }
418
419 /*
420 * @tc.name: ON_LNN_PROCESS_USER_CHANGE_MSG_DELAY_TEST_001
421 * @tc.desc: test OnLnnProcessUserChangeMsgDelay
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(LNNNetworkInfoTest, ON_LNN_PROCESS_USER_CHANGE_MSG_DELAY_TEST_001, TestSize.Level1)
426 {
427 EXPECT_NO_FATAL_FAILURE(OnLnnProcessUserChangeMsgDelay(nullptr));
428 void *para = static_cast<void *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
429 if (para == nullptr) {
430 return;
431 }
432 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
433 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
434 EXPECT_NO_FATAL_FAILURE(OnLnnProcessUserChangeMsgDelay(para));
435 }
436
437 /*
438 * @tc.name: LNN_ASYNC_SEND_USER_ID_TEST_001
439 * @tc.desc: test LnnAsyncSendUserId
440 * @tc.type: FUNC
441 * @tc.require:
442 */
443 HWTEST_F(LNNNetworkInfoTest, LNN_ASYNC_SEND_USER_ID_TEST_001, TestSize.Level1)
444 {
445 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(nullptr));
446 SendSyncInfoParam *data = reinterpret_cast<SendSyncInfoParam *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
447 if (data == nullptr) {
448 return;
449 }
450 data->msg = nullptr;
451 void *param = reinterpret_cast<void *>(data);
452 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(param));
453 SendSyncInfoParam *data1 = reinterpret_cast<SendSyncInfoParam *>(SoftBusCalloc(sizeof(SendSyncInfoParam)));
454 if (data1 == nullptr) {
455 return;
456 }
457 data1->len = LEN;
458 data1->msg = reinterpret_cast<uint8_t *>(SoftBusCalloc(data1->len));
459 if (data1->msg == nullptr) {
460 SoftBusFree(data1);
461 return;
462 }
463 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
464 EXPECT_CALL(syncInfoMock, LnnSendSyncInfoMsg).WillRepeatedly(Return(SOFTBUS_OK));
465 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
466 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
467 void *param1 = reinterpret_cast<void *>(data1);
468 EXPECT_NO_FATAL_FAILURE(LnnAsyncSendUserId(param1));
469 }
470
471 /*
472 * @tc.name: DO_SEND_USER_ID_TEST_001
473 * @tc.desc: test DoSendUserId
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(LNNNetworkInfoTest, DO_SEND_USER_ID_TEST_001, TestSize.Level1)
478 {
479 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
480 NodeInfo info;
481 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
482 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
483 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
484 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
485 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
486 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
487 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
488 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType)
489 .WillOnce(Return(true))
490 .WillRepeatedly(Return(false));
491 const char *udid = "udidTest";
492 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
493 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
494 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusMalloc(sizeof(SendSyncInfoParam));
495 if (data == nullptr) {
496 return;
497 }
498 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
499 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr))
500 .WillRepeatedly(Return(data));
501 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
502 NiceMock<LnnServicetInterfaceMock> serviceMock;
503 EXPECT_CALL(serviceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
504 EXPECT_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
505 EXPECT_NO_FATAL_FAILURE(DoSendUserId(udid, const_cast<uint8_t *>(USER_ID_MSG)));
506 }
507
508 /*
509 * @tc.name: CONVERT_USER_ID_TO_MSG_TEST_001
510 * @tc.desc: test ConvertUserIdToMsg
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(LNNNetworkInfoTest, CONVERT_USER_ID_TO_MSG_TEST_001, TestSize.Level1)
515 {
516 EXPECT_NE(ConvertUserIdToMsg(100), nullptr);
517 }
518
519 /*
520 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_001
521 * @tc.desc: test NotifyRemoteDevOffLineByUserId
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_001, TestSize.Level1)
526 {
527 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
528 NodeInfo info = { .userId = 101 };
529 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
530 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
531 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
532 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(DP_INACTIVE_DEFAULT_USERID, nullptr));
533 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(100, nullptr));
534 }
535
536 /*
537 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_002
538 * @tc.desc: test NotifyRemoteDevOffLineByUserId
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_002, TestSize.Level1)
543 {
544 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
545 NodeInfo info = { .userId = 0 };
546 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
547 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
548 .WillOnce(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)))
549 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
550 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(0, nullptr));
551 }
552
553 /*
554 * @tc.name: NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_003
555 * @tc.desc: test NotifyRemoteDevOffLineByUserId
556 * @tc.type: FUNC
557 * @tc.require:
558 */
559 HWTEST_F(LNNNetworkInfoTest, NOTIFY_REMOTE_DEV_OFFLINE_BY_USER_ID_TEST_003, TestSize.Level1)
560 {
561 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
562 NodeInfo info = { .userId = 100 };
563 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORKID));
564 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
565 .WillOnce(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)))
566 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
567 EXPECT_NO_FATAL_FAILURE(NotifyRemoteDevOffLineByUserId(100, nullptr));
568 }
569 } // namespace OHOS
570