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_network_info.c"
20 #include "lnn_network_info.h"
21 #include "lnn_net_builder_mock.h"
22 #include "lnn_net_ledger_mock.h"
23 #include "lnn_service_mock.h"
24 #include "lnn_sync_info_mock.h"
25 #include "softbus_common.h"
26 #include "softbus_errcode.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
49 class LNNNetworkInfoTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55 };
56
SetUpTestCase()57 void LNNNetworkInfoTest::SetUpTestCase()
58 {
59 }
60
TearDownTestCase()61 void LNNNetworkInfoTest::TearDownTestCase()
62 {
63 }
64
SetUp()65 void LNNNetworkInfoTest::SetUp()
66 {
67 }
68
TearDown()69 void LNNNetworkInfoTest::TearDown()
70 {
71 }
72
73 /*
74 * @tc.name: LNN_INIT_NETWORK_INFO_TEST_001
75 * @tc.desc: test LnnInitNetworkInfo
76 * @tc.type: FUNC
77 * @tc.require: I5PRUD
78 */
79 HWTEST_F(LNNNetworkInfoTest, LNN_INIT_NETWORK_INFO_TEST_001, TestSize.Level1)
80 {
81 NiceMock<LnnServicetInterfaceMock> serviceMock;
82 EXPECT_CALL(serviceMock, SoftBusHasWifiDirectCapability).WillRepeatedly(Return(true));
83 EXPECT_CALL(serviceMock, SoftBusGetWifiInterfaceCoexistCap).WillRepeatedly(Return(nullptr));
84 EXPECT_CALL(serviceMock, LnnRegisterEventHandler)
85 .WillOnce(Return(SOFTBUS_ERR))
86 .WillOnce(Return(SOFTBUS_OK))
87 .WillOnce(Return(SOFTBUS_ERR))
88 .WillRepeatedly(Return(SOFTBUS_OK));
89 NiceMock<LnnSyncInfoInterfaceMock> syncInfoMock;
90 EXPECT_CALL(syncInfoMock, LnnRegSyncInfoHandler).WillOnce(Return(SOFTBUS_ERR))
91 .WillRepeatedly(Return(SOFTBUS_OK));
92 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
93 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(false)).WillRepeatedly(Return(true));
94 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_ERR))
95 .WillRepeatedly(Return(SOFTBUS_OK));
96 const char *networkId = NETWORKID;
97 uint32_t capability = TYPE_128;
98 HandlePeerNetCapchanged(networkId, capability);
99 HandlePeerNetCapchanged(networkId, capability);
100 HandlePeerNetCapchanged(networkId, capability);
101 HandlePeerNetCapchanged(networkId, capability);
102 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
103 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillRepeatedly(Return(SOFTBUS_OK));
104 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
105 HandlePeerNetCapchanged(networkId, capability);
106 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillOnce(Return(false)).WillRepeatedly(Return(true));
107 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
108 HandlePeerNetCapchanged(networkId, capability);
109 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
110 EXPECT_CALL(netLedgerMock, LnnHasCapability).WillOnce(Return(true)).WillRepeatedly(Return(false));
111 HandlePeerNetCapchanged(networkId, capability);
112 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid).WillOnce(Return(SOFTBUS_ERR))
113 .WillRepeatedly(Return(SOFTBUS_OK));
114 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
115 UpdateNetworkInfo(UUID);
116 UpdateNetworkInfo(UUID);
117 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
118 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
119 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
120 EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_OK);
121 }
122
123 /*
124 * @tc.name: CONVERT_MSG_TO_CAPABILITY_TEST_001
125 * @tc.desc: test ConvertMsgToCapability
126 * @tc.type: FUNC
127 * @tc.require:
128 */
129 HWTEST_F(LNNNetworkInfoTest, CONVERT_MSG_TO_CAPABILITY_TEST_001, TestSize.Level1)
130 {
131 NiceMock<LnnNetBuilderInterfaceMock> netBuilderMock;
132 EXPECT_CALL(netBuilderMock, LnnRequestLeaveSpecific).WillOnce(Return(SOFTBUS_ERR))
133 .WillRepeatedly(Return(SOFTBUS_OK));
134 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
135 PostNetchangedInfo(nullptr, CONNECTION_ADDR_ETH);
136 uint32_t capability;
137 uint32_t len = BITS - 1;
138 uint32_t ret = ConvertMsgToCapability(nullptr, MSG, len);
139 EXPECT_EQ(ret, SOFTBUS_ERR);
140 ret = ConvertMsgToCapability(&capability, nullptr, len);
141 EXPECT_EQ(ret, SOFTBUS_ERR);
142 ret = ConvertMsgToCapability(&capability, MSG, len);
143 EXPECT_EQ(ret, SOFTBUS_ERR);
144 ret = ConvertMsgToCapability(&capability, MSG, BITS);
145 EXPECT_EQ(ret, SOFTBUS_OK);
146 }
147
148 /*
149 * @tc.name: IS_P2P_AVAILABLE_TEST_001
150 * @tc.desc: test IsP2pAvailable
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(LNNNetworkInfoTest, IS_P2P_AVAILABLE_TEST_001, TestSize.Level1)
155 {
156 const char *networkId = NETWORKID;
157 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_DEVICE_NAME, networkId, MSG, BITS);
158 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, nullptr, MSG, BITS);
159 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, nullptr, BITS);
160 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, 0);
161 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
162 NodeInfo info = { .discoveryType = DISCOVERY_TYPE, };
163 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_ERR))
164 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
165 EXPECT_CALL(netLedgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_ERR));
166 EXPECT_CALL(netLedgerMock, LnnSetDLConnCapability).WillRepeatedly(Return(SOFTBUS_OK));
167 NiceMock<LnnServicetInterfaceMock> serviceMock;
168 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
169 OnReceiveCapaSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, networkId, MSG, BITS);
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 EXPECT_CALL(serviceMock, SoftBusIsWifiTripleMode).WillRepeatedly(Return(true));
175 bool ret = IsP2pAvailable(true);
176 EXPECT_EQ(ret, false);
177 }
178
179 /*
180 * @tc.name: WIFI_STATE_EVENT_HANDLER_TEST_002
181 * @tc.desc: test WifiStateEventHandler
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(LNNNetworkInfoTest, WIFI_STATE_EVENT_HANDLER_TEST_002, TestSize.Level1)
186 {
187 LnnMonitorWlanStateChangedEvent event = {
188 .basic.event = LNN_EVENT_IP_ADDR_CHANGED,
189 .status = SOFTBUS_WIFI_UNKNOWN
190 };
191 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
192 WifiStateEventHandler(nullptr);
193 WifiStateEventHandler(info);
194 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
195 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
196 event.basic.event = LNN_EVENT_WIFI_STATE_CHANGED;
197 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
198 WifiStateEventHandler(info1);
199 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
200 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
201 WifiStateEventHandler(info1);
202 const char *coexistCap2 = COEXISTCAP2;
203 EXPECT_EQ(IsSupportApCoexist(coexistCap2), false);
204 }
205
206 /*
207 * @tc.name: BT_STATE_CHANGE_EVENT_HANDLER_TEST_001
208 * @tc.desc: test BtStateChangeEventHandler
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(LNNNetworkInfoTest, BT_STATE_CHANGE_EVENT_HANDLER_TEST_001, TestSize.Level1)
213 {
214 LnnMonitorHbStateChangedEvent event = {
215 .basic.event = LNN_EVENT_WIFI_STATE_CHANGED,
216 .status = SOFTBUS_BT_UNKNOWN,
217 };
218 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
219 BtStateChangeEventHandler(nullptr);
220 BtStateChangeEventHandler(info);
221 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
222 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
223 event.basic.event = LNN_EVENT_BT_STATE_CHANGED;
224 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
225 BtStateChangeEventHandler(info1);
226 EXPECT_CALL(netLedgerMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
227 event.status = SOFTBUS_BR_TURN_ON;
228 EXPECT_CALL(netLedgerMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
229 EXPECT_CALL(netLedgerMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
230 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
231 const LnnEventBasicInfo *info2 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
232 BtStateChangeEventHandler(info2);
233 event.status = SOFTBUS_BLE_TURN_ON;
234 const LnnEventBasicInfo *info3 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
235 BtStateChangeEventHandler(info3);
236 event.status = SOFTBUS_BR_TURN_OFF;
237 const LnnEventBasicInfo *info4 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
238 BtStateChangeEventHandler(info4);
239 event.status = SOFTBUS_BLE_TURN_OFF;
240 const LnnEventBasicInfo *info5 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
241 BtStateChangeEventHandler(info5);
242 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
243 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_ERR));
244 BtStateChangeEventHandler(info5);
245 event.status = SOFTBUS_BR_TURN_OFF;
246 const LnnEventBasicInfo *info6 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
247 BtStateChangeEventHandler(info6);
248 const char *coexistCap1 = COEXISTCAP1;
249 EXPECT_EQ(IsSupportApCoexist(coexistCap1), false);
250 }
251
252 /*
253 * @tc.name: CONVERT_CAPABILITY_TO_MSG_TEST_001
254 * @tc.desc: test ConvertCapabilityToMsg
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(LNNNetworkInfoTest, CONVERT_CAPABILITY_TO_MSG_TEST_001, TestSize.Level1)
259 {
260 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
261 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(
262 LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnlineNodeInfo);
263 EXPECT_CALL(netLedgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
264 EXPECT_CALL(netLedgerMock, LnnSetLocalNumInfo).WillOnce(Return(SOFTBUS_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 } // namespace OHOS
372