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