1 /*
2 * Copyright (c) 2022 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 "bus_center_event.h"
20 #include "lnn_ip_network_impl.c"
21 #include "lnn_ip_network_impl_mock.h"
22 #include "lnn_net_ledger_mock.h"
23 #include "lnn_network_manager.h"
24 #include "lnn_physical_subnet_manager.h"
25 #include "lnn_trans_mock.h"
26 #include "message_handler.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_common.h"
29 #include "softbus_error_code.h"
30
31 #define BLE_DISABLE 0
32 #define SIZE 20
33 #define LNN_DEFAULT_IF_NAME_BR "br0"
34 namespace OHOS {
35 using namespace testing::ext;
36 using namespace testing;
37 LnnProtocolManager self;
38 LnnNetIfMgr netifMgr;
39 constexpr char WLAN_IP0[] = "192.168.1.1";
40 constexpr char WLAN_IP1[] = "127.0.0.1";
41 constexpr char WLAN_IP2[] = "127.0.0.2";
42 constexpr char IFNAME_TEST0[] = "wlan0";
43 constexpr char IFNAME_TEST1[] = "wlan1";
44 class LNNIpNetworkImplMockTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp();
49 void TearDown();
50 };
51
SetUpTestCase()52 void LNNIpNetworkImplMockTest::SetUpTestCase()
53 {
54 LooperInit();
55 }
56
TearDownTestCase()57 void LNNIpNetworkImplMockTest::TearDownTestCase()
58 {
59 LooperDeinit();
60 }
61
SetUp()62 void LNNIpNetworkImplMockTest::SetUp() { }
63
TearDown()64 void LNNIpNetworkImplMockTest::TearDown() { }
65
66 /*
67 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_001
68 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
69 * @tc.type: FUNC
70 * @tc.require: I5OMIK
71 */
72 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_001, TestSize.Level1)
73 {
74 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
75 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
76
77 ListenerModule ret = LnnGetIpListenerModule(LNN_LISTENER_MODE_PROXY);
78 EXPECT_TRUE(ret == PROXY);
79
80 ret = LnnGetIpListenerModule(LNN_LISTENER_MODE_DIRECT);
81 EXPECT_TRUE(ret == DIRECT_CHANNEL_SERVER_WIFI);
82
83 ret = LnnGetIpListenerModule(LNN_LISTENER_MODE_AUTH);
84 EXPECT_TRUE(ret == UNUSE_BUTT);
85
86 EXPECT_CALL(ipMock, LnnRegistPhysicalSubnet)
87 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
88 .WillRepeatedly(Return(SOFTBUS_OK));
89
90 memset_s(&self, sizeof(LnnProtocolManager), 0, sizeof(LnnProtocolManager));
91 memset_s(&netifMgr, sizeof(LnnNetIfMgr), 0, sizeof(LnnNetIfMgr));
92 strcpy_s(netifMgr.ifName, sizeof("name"), "name");
93 int32_t res = LnnEnableIpProtocol(nullptr, nullptr);
94 EXPECT_NE(res, SOFTBUS_OK);
95 res = LnnEnableIpProtocol(&self, &netifMgr);
96 EXPECT_NE(res, SOFTBUS_OK);
97 res = LnnEnableIpProtocol(&self, &netifMgr);
98 EXPECT_TRUE(res == SOFTBUS_OK);
99
100 EXPECT_CALL(ipMock, LnnRegisterEventHandler)
101 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
102 .WillRepeatedly(Return(SOFTBUS_OK));
103 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
104 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
105 .WillRepeatedly(Return(SOFTBUS_OK));
106
107 res = LnnInitIpProtocol(&self);
108 EXPECT_NE(res, SOFTBUS_OK);
109 res = LnnInitIpProtocol(&self);
110 EXPECT_NE(res, SOFTBUS_OK);
111 res = LnnInitIpProtocol(&self);
112 EXPECT_TRUE(res == SOFTBUS_OK);
113
114 WifiStateChangeEventHandler(nullptr);
115 LnnEventBasicInfo info = {
116 .event = LNN_EVENT_WIFI_STATE_CHANGED,
117 };
118 WifiStateChangeEventHandler(&info);
119 }
120
121 /*
122 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_002
123 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
124 * @tc.type: FUNC
125 * @tc.require: I5OMIK
126 */
127 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_002, TestSize.Level1)
128 {
129 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
130 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
131 EXPECT_CALL(ipMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
132 EXPECT_CALL(ipMock, LnnVisitPhysicalSubnet).WillRepeatedly(Return(true));
133 EXPECT_CALL(ipMock, LnnIsLinkReady).WillRepeatedly(Return(true));
134 EXPECT_CALL(ipMock, GetNetworkIpByIfName).WillRepeatedly(Return(SOFTBUS_OK));
135 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
136 VisitNextChoice visit = NotifyWlanAddressChanged(&netifMgr, nullptr);
137 EXPECT_TRUE(visit == CHOICE_VISIT_NEXT);
138 netifMgr.type = LNN_NETIF_TYPE_WLAN;
139 visit = NotifyWlanAddressChanged(&netifMgr, nullptr);
140 EXPECT_TRUE(visit == CHOICE_VISIT_NEXT);
141
142 LnnProtocolManager lnnProtocolManager = {
143 .id = LNN_PROTOCOL_IP,
144 };
145 LnnPhysicalSubnet subnet = {
146 .protocol = &lnnProtocolManager,
147 .status = LNN_SUBNET_RUNNING,
148 };
149
150 OnIpNetifStatusChanged(&subnet, nullptr);
151 OnSoftbusIpNetworkDisconnected(&subnet);
152 subnet.status = LNN_SUBNET_IDLE;
153 OnIpNetifStatusChanged(&subnet, nullptr);
154 OnSoftbusIpNetworkDisconnected(&subnet);
155 }
156
157 /*
158 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_003
159 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
160 * @tc.type: FUNC
161 * @tc.require: I5OMIK
162 */
163 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_003, TestSize.Level1)
164 {
165 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
166 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
167 EXPECT_CALL(ipMock, GetNetworkIpByIfName)
168 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
169 .WillRepeatedly(Return(SOFTBUS_OK));
170 int32_t ret = GetAvailableIpAddr(IFNAME_TEST0, const_cast<char *>(WLAN_IP1), SIZE);
171 EXPECT_NE(ret, SOFTBUS_OK);
172 ret = GetAvailableIpAddr(IFNAME_TEST1, const_cast<char *>(WLAN_IP2), SIZE);
173 EXPECT_TRUE(ret == SOFTBUS_OK);
174
175 EXPECT_CALL(ipMock, GetNetworkIpByIfName)
176 .WillRepeatedly(LnnIpNetworkImplInterfaceMock::ActionOfGetNetworkIpByIfName);
177 LnnPhysicalSubnet subnet = {
178 .ifName = "noDeviceName",
179 .status = LNN_SUBNET_RUNNING,
180 };
181
182 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
183 IpSubnetManagerEvent res = GetIpEventInRunning(&subnet);
184 EXPECT_TRUE(res == IP_SUBNET_MANAGER_EVENT_IF_DOWN);
185
186 strcpy_s(subnet.ifName, sizeof("DeviceName"), "DeviceName");
187 res = GetIpEventInRunning(&subnet);
188 EXPECT_TRUE(res != IP_SUBNET_MANAGER_EVENT_MAX);
189 }
190
191 /*
192 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_004
193 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
194 * @tc.type: FUNC
195 * @tc.require: I5OMIK
196 */
197 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_004, TestSize.Level1)
198 {
199 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
200 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
201 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo)
202 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
203 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
204 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
205 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
206 .WillRepeatedly(Return(SOFTBUS_OK));
207 int32_t ret = RequestMainPort("lo", "127.0.0.1");
208 EXPECT_NE(ret, SOFTBUS_OK);
209 ret = RequestMainPort("lol", "127.0.0.1");
210 EXPECT_NE(ret, SOFTBUS_OK);
211 ret = RequestMainPort("lol", "127.0.0.2");
212 EXPECT_NE(ret, SOFTBUS_OK);
213 ret = RequestMainPort("lol", "127.0.0.2");
214 EXPECT_NE(ret, SOFTBUS_OK);
215 ret = RequestMainPort("deviceName", "127.0.0.2");
216 EXPECT_NE(ret, SOFTBUS_OK);
217 ret = RequestMainPort("deviceName", "127.0.0.2");
218 EXPECT_TRUE(ret == SOFTBUS_OK);
219
220 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo)
221 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
222 .WillRepeatedly(Return(SOFTBUS_OK));
223 EXPECT_CALL(ipMock, AuthStartListening).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
224 EXPECT_CALL(ledgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
225 ret = OpenAuthPort();
226 EXPECT_NE(ret, SOFTBUS_OK);
227 ret = OpenAuthPort();
228 EXPECT_NE(ret, SOFTBUS_OK);
229 ret = OpenAuthPort();
230 EXPECT_TRUE(ret == SOFTBUS_OK);
231 ret = OpenIpLink();
232 EXPECT_TRUE(ret == SOFTBUS_OK);
233
234 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
235 ret = OpenIpLink();
236 EXPECT_NE(ret, SOFTBUS_OK);
237
238 EXPECT_CALL(ipMock, LnnIsLinkReady).WillRepeatedly(Return(true));
239 EXPECT_CALL(ipMock, GetNetworkIpByIfName)
240 .WillRepeatedly(LnnIpNetworkImplInterfaceMock::ActionOfGetNetworkIpByIfName);
241 LnnPhysicalSubnet subnet = {
242 .ifName = "deviceName",
243 .status = LNN_SUBNET_RUNNING,
244 };
245 ret = EnableIpSubnet(&subnet);
246 EXPECT_NE(ret, SOFTBUS_OK);
247 }
248 /*
249 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_005
250 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
251 * @tc.type: FUNC
252 * @tc.require: I5OMIK
253 */
254 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_005, TestSize.Level1)
255 {
256 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
257 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
258 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo)
259 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
260 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
261 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
262 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
263 .WillRepeatedly(Return(SOFTBUS_OK));
264 int32_t ret = ReleaseMainPort("deviceName");
265 EXPECT_NE(ret, SOFTBUS_OK);
266 ret = ReleaseMainPort("deviceName1");
267 EXPECT_NE(ret, SOFTBUS_OK);
268 ret = ReleaseMainPort("deviceName");
269 EXPECT_TRUE(ret == SOFTBUS_OK);
270
271 EXPECT_CALL(ipMock, LnnGetAddrTypeByIfName)
272 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
273 .WillRepeatedly(Return(SOFTBUS_OK));
274 EXPECT_CALL(ipMock, LnnRequestLeaveByAddrType)
275 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
276 .WillRepeatedly(Return(SOFTBUS_OK));
277 LeaveOldIpNetwork(nullptr);
278 LeaveOldIpNetwork(nullptr);
279 LeaveOldIpNetwork(nullptr);
280
281 EXPECT_CALL(ledgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
282 EXPECT_CALL(ipMock, ConnStopLocalListening)
283 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
284 .WillRepeatedly(Return(SOFTBUS_OK));
285 CloseProxyPort();
286 CloseProxyPort();
287
288 memset_s(&self, sizeof(LnnProtocolManager), 0, sizeof(LnnProtocolManager));
289 LnnDeinitIpNetwork(&self);
290 IpAddrChangeEventHandler(nullptr);
291 }
292
293 /*
294 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_006
295 * @tc.desc: IsValidLocalIpTest
296 * @tc.type: FUNC
297 * @tc.require: I5OMIK
298 */
299 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_006, TestSize.Level1)
300 {
301 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
302 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
303 bool ret = IsValidLocalIp();
304 EXPECT_EQ(ret, false);
305
306 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
307 ret = IsValidLocalIp();
308 EXPECT_EQ(ret, false);
309 }
310
311 /*
312 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_007
313 * @tc.desc: WifiStateChangeWifiOrApTest
314 * @tc.type: FUNC
315 * @tc.require: I5OMIK
316 */
317 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_007, TestSize.Level1)
318 {
319 bool ret = false;
320 for (int32_t i = SOFTBUS_WIFI_CONNECTED; i <= SOFTBUS_AP_ENABLED; i++) {
321 ret = WifiStateChangeWifiOrAp((SoftBusWifiState)i);
322 if (i == SOFTBUS_AP_ENABLED || i == SOFTBUS_AP_DISABLED || i == SOFTBUS_WIFI_DISCONNECTED ||
323 i == SOFTBUS_WIFI_CONNECTED) {
324 EXPECT_EQ(ret, true);
325 } else {
326 EXPECT_EQ(ret, false);
327 }
328 }
329 }
330
331 /*
332 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_008
333 * @tc.desc: GetWifiServiceIpAddrTest
334 * @tc.type: FUNC
335 * @tc.require: I5OMIK
336 */
337 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_008, TestSize.Level1)
338 {
339 int32_t ret = GetWifiServiceIpAddr(nullptr, nullptr, 0);
340 EXPECT_TRUE(ret != SOFTBUS_OK);
341
342 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
343 EXPECT_CALL(ipMock, GetWlanIpv4Addr).WillRepeatedly(Return(!SOFTBUS_OK));
344 ret = GetWifiServiceIpAddr(IFNAME_TEST0, const_cast<char *>(WLAN_IP0), SIZE);
345 EXPECT_NE(ret, SOFTBUS_OK);
346
347 EXPECT_CALL(ipMock, GetWlanIpv4Addr).WillRepeatedly(Return(SOFTBUS_OK));
348 ret = GetWifiServiceIpAddr(IFNAME_TEST0, const_cast<char *>(WLAN_IP0), SIZE);
349 EXPECT_TRUE(ret != SOFTBUS_OK);
350 }
351
352 /*
353 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_009
354 * @tc.desc: OpenPortAndEnableIPTest
355 * @tc.type: FUNC
356 * @tc.require: I5OMIK
357 */
358 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_009, TestSize.Level1)
359 {
360 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
361 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
362 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(!SOFTBUS_OK));
363 OpenProxyPort();
364
365 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
366 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
367 OpenProxyPort();
368
369 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
370 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
371 EXPECT_CALL(ipMock, ConnStartLocalListening).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
372 OpenProxyPort();
373
374 LnnPhysicalSubnet subnet = {
375 .ifName = "deviceName",
376 .status = LNN_SUBNET_RUNNING,
377 };
378 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
379 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
380 EXPECT_CALL(ipMock, AuthStartListening).WillRepeatedly(Return(SOFTBUS_OK));
381 int32_t ret = OpenAuthPort();
382 EXPECT_TRUE(ret == SOFTBUS_OK);
383
384 EXPECT_CALL(ipMock, LnnIsAutoNetWorkingEnabled).WillRepeatedly(Return(false));
385 ret = EnableIpSubnet(&subnet);
386 EXPECT_TRUE(ret != SOFTBUS_OK);
387
388 EXPECT_CALL(ipMock, LnnIsAutoNetWorkingEnabled).WillRepeatedly(Return(true));
389 EXPECT_CALL(ipMock, LnnStartPublish).WillRepeatedly(Return(!SOFTBUS_OK));
390 ret = EnableIpSubnet(&subnet);
391 EXPECT_TRUE(ret != SOFTBUS_OK);
392
393 EXPECT_CALL(ipMock, LnnIsAutoNetWorkingEnabled).WillRepeatedly(Return(true));
394 EXPECT_CALL(ipMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_OK));
395 EXPECT_CALL(ipMock, LnnStartDiscovery).WillRepeatedly(Return(!SOFTBUS_OK));
396 ret = EnableIpSubnet(&subnet);
397 EXPECT_TRUE(ret != SOFTBUS_OK);
398 }
399
400 /*
401 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_010
402 * @tc.desc: LocalIpInfoTest
403 * @tc.type: FUNC
404 * @tc.require: I5OMIK
405 */
406 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_010, TestSize.Level1)
407 {
408 char localIpAddr[IP_LEN] = { 0 };
409 char localNetifName[NET_IF_NAME_LEN] = { 0 };
410 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
411 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
412 int32_t ret = GetLocalIpInfo(localIpAddr, sizeof(localIpAddr), localNetifName, sizeof(localNetifName));
413 EXPECT_TRUE(ret != SOFTBUS_OK);
414
415 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
416 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
417 ret = GetLocalIpInfo(localIpAddr, sizeof(localIpAddr), localNetifName, sizeof(localNetifName));
418 EXPECT_TRUE(ret != SOFTBUS_OK);
419
420 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
421 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillRepeatedly(Return(!SOFTBUS_OK));
422 ret = SetLocalIpInfo(LNN_LOOPBACK_IP, LNN_LOOPBACK_IFNAME);
423 EXPECT_TRUE(ret != SOFTBUS_OK);
424 }
425 } // namespace OHOS
426