1 /*
2 * Copyright (c) 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 "bus_center_event.h"
20 #include "lnn_usb_network_impl.c"
21 #include "lnn_usb_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 namespace OHOS {
31 using namespace testing::ext;
32 using namespace testing;
33
34 LnnProtocolManager self;
35 LnnNetIfMgr netifMgr;
36
37 class LNNUsbNetworkImplMockTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void LNNUsbNetworkImplMockTest::SetUpTestCase()
46 {
47 LooperInit();
48 }
49
TearDownTestCase()50 void LNNUsbNetworkImplMockTest::TearDownTestCase()
51 {
52 LooperDeinit();
53 }
54
SetUp()55 void LNNUsbNetworkImplMockTest::SetUp() { }
56
TearDown()57 void LNNUsbNetworkImplMockTest::TearDown() { }
58
59 /*
60 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_001
61 * @tc.desc: LnnEnableUsbProtocol Test
62 * @tc.type: FUNC
63 * @tc.require: NONE
64 */
65 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_001, TestSize.Level1)
66 {
67 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
68
69 EXPECT_CALL(usbMock, LnnRegistPhysicalSubnet)
70 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
71 .WillRepeatedly(Return(SOFTBUS_OK));
72
73 memset_s(&self, sizeof(LnnProtocolManager), 0, sizeof(LnnProtocolManager));
74 memset_s(&netifMgr, sizeof(LnnNetIfMgr), 0, sizeof(LnnNetIfMgr));
75 int32_t ret = strcpy_s(netifMgr.ifName, sizeof("name"), "name");
76 ASSERT_EQ(ret, EOK);
77
78 int32_t res = LnnEnableUsbProtocol(nullptr, nullptr);
79 EXPECT_NE(res, SOFTBUS_OK);
80 res = LnnEnableUsbProtocol(&self, &netifMgr);
81 EXPECT_NE(res, SOFTBUS_OK);
82 res = LnnEnableUsbProtocol(&self, &netifMgr);
83 EXPECT_EQ(res, SOFTBUS_OK);
84 }
85
86 /*
87 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_002
88 * @tc.desc: LnnInitUsbProtocol Test
89 * @tc.type: FUNC
90 * @tc.require: NONE
91 */
92 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_002, TestSize.Level1)
93 {
94 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
95
96 EXPECT_CALL(usbMock, LnnRegisterEventHandler)
97 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
98 EXPECT_CALL(usbMock, LnnSetLocalStrInfoByIfnameIdx)
99 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
100 .WillRepeatedly(Return(SOFTBUS_OK));
101
102 int32_t res = LnnInitUsbProtocol(&self);
103 EXPECT_NE(res, SOFTBUS_OK);
104
105 EXPECT_CALL(usbMock, LnnRegisterEventHandler)
106 .WillOnce(Return(SOFTBUS_OK))
107 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
108 .WillRepeatedly(Return(SOFTBUS_OK));
109 res = LnnInitUsbProtocol(&self);
110 EXPECT_NE(res, SOFTBUS_OK);
111 res = LnnInitUsbProtocol(&self);
112 EXPECT_NE(res, SOFTBUS_OK);
113 res = LnnInitUsbProtocol(&self);
114 EXPECT_EQ(res, SOFTBUS_OK);
115 }
116
117 /*
118 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_003
119 * @tc.desc: LnnGetUsbListenerModule Test
120 * @tc.type: FUNC
121 * @tc.require: NONE
122 */
123 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_003, TestSize.Level1)
124 {
125 ListenerModule ret = LnnGetUsbListenerModule(LNN_LISTENER_MODE_PROXY);
126 EXPECT_EQ(ret, DIRECT_CHANNEL_SERVER_USB);
127 ret = LnnGetUsbListenerModule(LNN_LISTENER_MODE_DIRECT);
128 EXPECT_EQ(ret, DIRECT_CHANNEL_SERVER_USB);
129 ret = LnnGetUsbListenerModule(LNN_LISTENER_MODE_AUTH);
130 EXPECT_EQ(ret, UNUSE_BUTT);
131
132 LnnDeinitUsbNetwork(&self);
133 }
134
135 /*
136 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_004
137 * @tc.desc: NotifyUsbAddressChanged Test
138 * @tc.type: FUNC
139 * @tc.require: NONE
140 */
141 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_004, TestSize.Level1)
142 {
143 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
144 EXPECT_CALL(usbMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
145
146 VisitNextChoice visit = NotifyUsbAddressChanged(nullptr, nullptr);
147 EXPECT_EQ(visit, CHOICE_VISIT_NEXT);
148 netifMgr.type = LNN_NETIF_TYPE_WLAN;
149 visit = NotifyUsbAddressChanged(&netifMgr, nullptr);
150 EXPECT_EQ(visit, CHOICE_VISIT_NEXT);
151 netifMgr.type = LNN_NETIF_TYPE_USB;
152 visit = NotifyUsbAddressChanged(&netifMgr, nullptr);
153 EXPECT_EQ(visit, CHOICE_VISIT_NEXT);
154 }
155
156 /*
157 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_005
158 * @tc.desc: OnIpNetifStatusChanged Test
159 * @tc.type: FUNC
160 * @tc.require: NONE
161 */
162 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_005, TestSize.Level1)
163 {
164 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
165
166 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName).WillRepeatedly(Return(SOFTBUS_NETWORK_GET_IP_ADDR_FAILED));
167 EXPECT_CALL(usbMock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
168 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
169
170 LnnProtocolManager lnnProtocolManager = {
171 .id = LNN_PROTOCOL_IP,
172 };
173 LnnPhysicalSubnet subnet = {
174 .protocol = &lnnProtocolManager,
175 .status = LNN_SUBNET_RUNNING,
176 };
177 OnIpNetifStatusChanged(&subnet, nullptr);
178 EXPECT_EQ(subnet.status, LNN_SUBNET_SHUTDOWN);
179
180 subnet.status = LNN_SUBNET_IDLE;
181 OnIpNetifStatusChanged(&subnet, nullptr);
182 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
183
184 IpSubnetManagerEvent *eventPtr = static_cast<IpSubnetManagerEvent*>(SoftBusCalloc(sizeof(IpSubnetManagerEvent)));
185 ASSERT_TRUE(eventPtr != nullptr);
186 *eventPtr = USB_SUBNET_MANAGER_EVENT_IF_READY;
187 subnet.status = LNN_SUBNET_IDLE;
188 OnIpNetifStatusChanged(&subnet, (void*)eventPtr);
189 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
190
191 eventPtr = static_cast<IpSubnetManagerEvent*>(SoftBusCalloc(sizeof(IpSubnetManagerEvent)));
192 ASSERT_TRUE(eventPtr != nullptr);
193 *eventPtr = USB_SUBNET_MANAGER_EVENT_IF_CHANGED;
194 subnet.status = LNN_SUBNET_IDLE;
195 OnIpNetifStatusChanged(&subnet, (void*)eventPtr);
196 EXPECT_EQ(subnet.status, LNN_SUBNET_RESETTING);
197
198 eventPtr = static_cast<IpSubnetManagerEvent*>(SoftBusCalloc(sizeof(IpSubnetManagerEvent)));
199 ASSERT_TRUE(eventPtr != nullptr);
200 *eventPtr = (IpSubnetManagerEvent)(USB_SUBNET_MANAGER_EVENT_IF_READY - 1);
201 subnet.status = LNN_SUBNET_IDLE;
202 OnIpNetifStatusChanged(&subnet, (void*)eventPtr);
203 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
204
205 eventPtr = static_cast<IpSubnetManagerEvent*>(SoftBusCalloc(sizeof(IpSubnetManagerEvent)));
206 ASSERT_TRUE(eventPtr != nullptr);
207 *eventPtr = (IpSubnetManagerEvent)(USB_SUBNET_MANAGER_EVENT_MAX + 1);
208 subnet.status = LNN_SUBNET_IDLE;
209 OnIpNetifStatusChanged(&subnet, (void*)eventPtr);
210 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
211 }
212
213 /*
214 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_006
215 * @tc.desc: OnSoftbusIpNetworkDisconnected Test
216 * @tc.type: FUNC
217 * @tc.require: NONE
218 */
219 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_006, TestSize.Level1)
220 {
221 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
222
223 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName).WillRepeatedly(Return(SOFTBUS_NETWORK_GET_IP_ADDR_FAILED));
224
225 LnnProtocolManager lnnProtocolManager = {
226 .id = LNN_PROTOCOL_IP,
227 };
228 LnnPhysicalSubnet subnet = {
229 .protocol = &lnnProtocolManager,
230 .status = LNN_SUBNET_RUNNING,
231 };
232
233 OnSoftbusIpNetworkDisconnected(nullptr);
234 subnet.status = LNN_SUBNET_RESETTING;
235 OnSoftbusIpNetworkDisconnected(&subnet);
236 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
237
238 subnet.status = LNN_SUBNET_IDLE;
239 OnSoftbusIpNetworkDisconnected(&subnet);
240 EXPECT_EQ(subnet.status, LNN_SUBNET_IDLE);
241
242 subnet.status = LNN_SUBNET_RUNNING;
243 OnSoftbusIpNetworkDisconnected(&subnet);
244 EXPECT_EQ(subnet.status, LNN_SUBNET_RUNNING);
245 }
246
247 /*
248 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_007
249 * @tc.desc: DestroyUsbSubnetManager Test
250 * @tc.type: FUNC
251 * @tc.require: NONE
252 */
253 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_007, TestSize.Level1)
254 {
255 DestroyUsbSubnetManager(nullptr);
256
257 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
258 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
259 LnnPhysicalSubnet *subnetPtr = static_cast<LnnPhysicalSubnet*>(SoftBusCalloc(sizeof(LnnPhysicalSubnet)));
260 ASSERT_TRUE(subnetPtr != nullptr);
261 subnetPtr->status = LNN_SUBNET_RUNNING;
262 DestroyUsbSubnetManager(subnetPtr);
263 }
264
265 /*
266 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_008
267 * @tc.desc: GetAvailableIpAddr Test
268 * @tc.type: FUNC
269 * @tc.require: NONE
270 */
271 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_008, TestSize.Level1)
272 {
273 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
274 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName)
275 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
276 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
277 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfGetNetworkIpv6ByIfName);
278 char address[IP_LEN] = {0};
279 int32_t ret = GetAvailableIpAddr("usb", address, sizeof(address));
280 EXPECT_NE(ret, SOFTBUS_OK);
281 ret = GetAvailableIpAddr("ncm0", address, sizeof(address));
282 EXPECT_NE(ret, SOFTBUS_OK);
283 ret = GetAvailableIpAddr("ncm0", address, sizeof(address));
284 EXPECT_EQ(ret, SOFTBUS_OK);
285 }
286
287 /*
288 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_009
289 * @tc.desc: GetIpEventInRunning And GetIpEventInOther Test
290 * @tc.type: FUNC
291 * @tc.require: NONE
292 */
293 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_009, TestSize.Level1)
294 {
295 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
296
297 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName)
298 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
299 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfGetNetworkIpv6ByIfName);
300 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
301 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
302 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfLnnGetLocalStrInfoByIfnameIdx);
303 LnnPhysicalSubnet subnet = {
304 .ifName = "noDeviceName",
305 .status = LNN_SUBNET_RUNNING,
306 };
307 IpSubnetManagerEvent res = GetIpEventInRunning(&subnet);
308 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_DOWN);
309
310 res = GetIpEventInRunning(&subnet);
311 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_READY);
312
313 res = GetIpEventInRunning(&subnet);
314 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_READY);
315
316 int32_t ret = strcpy_s(subnet.ifName, sizeof("deviceName"), "deviceName");
317 ASSERT_EQ(ret, EOK);
318
319 res = GetIpEventInRunning(&subnet);
320 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_MAX);
321
322 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName)
323 .WillOnce(LnnUsbNetworkImplInterfaceMock::ActionOfGetNetworkIpv6ByIfName2);
324 res = GetIpEventInRunning(&subnet);
325 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_CHANGED);
326
327 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName)
328 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
329 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfGetNetworkIpv6ByIfName);
330 subnet.status = LNN_SUBNET_SHUTDOWN;
331 res = GetIpEventInOther(&subnet);
332 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_DOWN);
333
334 res = GetIpEventInOther(&subnet);
335 EXPECT_EQ(res, USB_SUBNET_MANAGER_EVENT_IF_READY);
336 }
337
338 /*
339 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_010
340 * @tc.desc: add ip and port to ledger
341 * @tc.type: FUNC
342 * @tc.require: NONE
343 */
344 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_010, TestSize.Level1)
345 {
346 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
347 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
348 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
349 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfLnnGetLocalStrInfoByIfnameIdx);
350 EXPECT_CALL(usbMock, LnnSetLocalStrInfoByIfnameIdx)
351 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
352 .WillRepeatedly(Return(SOFTBUS_OK));
353 int32_t ret = RequestMainPort("lo", "::1");
354 EXPECT_NE(ret, SOFTBUS_OK);
355 ret = RequestMainPort("ncm0", "::1");
356 EXPECT_NE(ret, SOFTBUS_OK);
357 ret = RequestMainPort("ncm0", "::2");
358 EXPECT_NE(ret, SOFTBUS_OK);
359 ret = RequestMainPort("ncm0", "::2");
360 EXPECT_NE(ret, SOFTBUS_OK);
361 ret = RequestMainPort("deviceName", "::2");
362 EXPECT_NE(ret, SOFTBUS_OK);
363 ret = RequestMainPort("deviceName", "::2");
364 EXPECT_EQ(ret, SOFTBUS_OK);
365 }
366
367 /*
368 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_011
369 * @tc.desc: OpenAuthPort Test
370 * @tc.type: FUNC
371 * @tc.require: NONE
372 */
373 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_011, TestSize.Level1)
374 {
375 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
376 EXPECT_CALL(usbMock, LnnGetLocalNumInfoByIfnameIdx)
377 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
378 .WillRepeatedly(Return(SOFTBUS_OK));
379 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
380 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
381 .WillRepeatedly(Return(SOFTBUS_OK));
382 EXPECT_CALL(usbMock, AuthStartListening)
383 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
384 .WillRepeatedly(Return(SOFTBUS_OK));
385 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
386 int32_t ret = OpenAuthPort();
387 EXPECT_NE(ret, SOFTBUS_OK);
388 ret = OpenAuthPort();
389 EXPECT_NE(ret, SOFTBUS_OK);
390 ret = OpenAuthPort();
391 EXPECT_EQ(ret, SOFTBUS_OK);
392 }
393
394 /*
395 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_012
396 * @tc.desc: OpenSessionPort Test
397 * @tc.type: FUNC
398 * @tc.require: NONE
399 */
400 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_012, TestSize.Level1)
401 {
402 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
403 EXPECT_CALL(usbMock, LnnGetLocalNumInfoByIfnameIdx)
404 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
405 .WillRepeatedly(Return(SOFTBUS_OK));
406 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
407 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
408 .WillRepeatedly(Return(SOFTBUS_OK));
409 EXPECT_CALL(usbMock, TransTdcStartSessionListener)
410 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
411 .WillRepeatedly(Return(SOFTBUS_OK));
412 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
413 int32_t ret = OpenSessionPort();
414 EXPECT_NE(ret, SOFTBUS_OK);
415 ret = OpenSessionPort();
416 EXPECT_NE(ret, SOFTBUS_OK);
417 ret = OpenSessionPort();
418 EXPECT_EQ(ret, SOFTBUS_OK);
419 ret = OpenSessionPort();
420 EXPECT_EQ(ret, SOFTBUS_OK);
421 }
422
423 /*
424 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_013
425 * @tc.desc: OpenIpLink Test
426 * @tc.type: FUNC
427 * @tc.require: NONE
428 */
429 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_013, TestSize.Level1)
430 {
431 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
432 EXPECT_CALL(usbMock, LnnGetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
433 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
434 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
435 EXPECT_CALL(usbMock, AuthStartListening)
436 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
437 .WillRepeatedly(Return(SOFTBUS_OK));
438 EXPECT_CALL(usbMock, TransTdcStartSessionListener)
439 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
440 .WillRepeatedly(Return(SOFTBUS_OK));
441
442 int32_t ret = OpenIpLink();
443 EXPECT_NE(ret, SOFTBUS_OK);
444
445 ret = OpenIpLink();
446 EXPECT_NE(ret, SOFTBUS_OK);
447
448 ret = OpenIpLink();
449 EXPECT_EQ(ret, SOFTBUS_OK);
450 }
451
452 /*
453 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_014
454 * @tc.desc: EnableIpSubnet Test
455 * @tc.type: FUNC
456 * @tc.require: NONE
457 */
458 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_014, TestSize.Level1)
459 {
460 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
461 LnnPhysicalSubnet subnet = {
462 .ifName = "deviceName",
463 .status = LNN_SUBNET_RUNNING,
464 };
465 EXPECT_CALL(usbMock, GetNetworkIpv6ByIfName)
466 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
467 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfGetNetworkIpv6ByIfName);
468 int32_t ret = EnableIpSubnet(&subnet);
469 EXPECT_NE(ret, SOFTBUS_OK);
470
471 int32_t cpyRet = strcpy_s(subnet.ifName, sizeof("lo"), "lo");
472 ASSERT_EQ(cpyRet, EOK);
473 ret = EnableIpSubnet(&subnet);
474 EXPECT_NE(ret, SOFTBUS_OK);
475
476 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
477 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfLnnGetLocalStrInfoByIfnameIdx);
478 EXPECT_CALL(usbMock, LnnGetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
479 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
480 EXPECT_CALL(usbMock, AuthStartListening)
481 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
482 .WillRepeatedly(Return(SOFTBUS_OK));
483 EXPECT_CALL(usbMock, TransTdcStartSessionListener).WillRepeatedly(Return(SOFTBUS_OK));
484
485 cpyRet = strcpy_s(subnet.ifName, sizeof("deviceName"), "deviceName");
486 ASSERT_EQ(cpyRet, EOK);
487 ret = EnableIpSubnet(&subnet);
488 EXPECT_NE(ret, SOFTBUS_OK);
489
490 ret = EnableIpSubnet(&subnet);
491 EXPECT_EQ(ret, SOFTBUS_OK);
492
493 EXPECT_CALL(usbMock, LnnGetLocalNumU32Info)
494 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
495 .WillRepeatedly(Return(SOFTBUS_OK));
496 EXPECT_CALL(usbMock, LnnSetNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
497 EXPECT_CALL(usbMock, LnnClearNetCapability).WillRepeatedly(Return(SOFTBUS_OK));
498 EXPECT_CALL(usbMock, LnnSetLocalNumInfo)
499 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
500 .WillRepeatedly(Return(SOFTBUS_OK));
501
502 ret = EnableIpSubnet(&subnet);
503 EXPECT_EQ(ret, SOFTBUS_OK);
504
505 ret = EnableIpSubnet(&subnet);
506 EXPECT_EQ(ret, SOFTBUS_OK);
507 }
508
509 /*
510 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_015
511 * @tc.desc: release ip and port to ledger
512 * @tc.type: FUNC
513 * @tc.require: NONE
514 */
515 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_015, TestSize.Level1)
516 {
517 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
518 EXPECT_CALL(usbMock, LnnGetLocalStrInfoByIfnameIdx)
519 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
520 .WillRepeatedly(LnnUsbNetworkImplInterfaceMock::ActionOfLnnGetLocalStrInfoByIfnameIdx);
521 EXPECT_CALL(usbMock, LnnSetLocalStrInfoByIfnameIdx)
522 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
523 .WillRepeatedly(Return(SOFTBUS_OK));
524
525 int32_t ret = ReleaseMainPort("deviceName");
526 EXPECT_NE(ret, SOFTBUS_OK);
527 ret = ReleaseMainPort("deviceName1");
528 EXPECT_NE(ret, SOFTBUS_OK);
529 ret = ReleaseMainPort("deviceName");
530 EXPECT_EQ(ret, SOFTBUS_OK);
531
532 EXPECT_CALL(usbMock, LnnGetAddrTypeByIfName)
533 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
534 .WillRepeatedly(Return(SOFTBUS_OK));
535 EXPECT_CALL(usbMock, LnnRequestLeaveByAddrType)
536 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
537 .WillRepeatedly(Return(SOFTBUS_OK));
538 LeaveOldIpNetwork(nullptr);
539 LeaveOldIpNetwork(nullptr);
540 LeaveOldIpNetwork(nullptr);
541
542 EXPECT_CALL(usbMock, LnnSetLocalNumInfoByIfnameIdx).WillRepeatedly(Return(SOFTBUS_OK));
543 CloseAuthPort();
544 CloseSessionPort();
545
546 memset_s(&self, sizeof(LnnProtocolManager), 0, sizeof(LnnProtocolManager));
547 LnnDeinitUsbNetwork(&self);
548 }
549
550 /*
551 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_016
552 * @tc.desc: IsValidUsbIfname Test
553 * @tc.type: FUNC
554 * @tc.require: NONE
555 */
556 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_016, TestSize.Level1)
557 {
558 EXPECT_FALSE(IsValidUsbIfname(nullptr));
559 EXPECT_FALSE(IsValidUsbIfname("usb"));
560 EXPECT_TRUE(IsValidUsbIfname("ncm0"));
561 EXPECT_TRUE(IsValidUsbIfname("wwan0"));
562 }
563
564 /*
565 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_017
566 * @tc.desc: IpAddrChangeEventHandler Test
567 * @tc.type: FUNC
568 * @tc.require: NONE
569 */
570 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_017, TestSize.Level1)
571 {
572 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
573 LnnMonitorAddressChangedEvent event = {.basic.event = LNN_EVENT_WIFI_STATE_CHANGED, .ifName = {0}};
574 IpAddrChangeEventHandler(nullptr);
575 IpAddrChangeEventHandler((const LnnEventBasicInfo *)&event);
576 EXPECT_NE(event.basic.event, LNN_EVENT_IP_ADDR_CHANGED);
577
578 event.basic.event = LNN_EVENT_IP_ADDR_CHANGED;
579 IpAddrChangeEventHandler((const LnnEventBasicInfo *)&event);
580 EXPECT_EQ(event.basic.event, LNN_EVENT_IP_ADDR_CHANGED);
581
582 EXPECT_CALL(usbMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
583 int32_t ret = strcpy_s(event.ifName, sizeof("ncm0"), "ncm0");
584 ASSERT_EQ(ret, EOK);
585 IpAddrChangeEventHandler((const LnnEventBasicInfo *)&event);
586 EXPECT_EQ(event.basic.event, LNN_EVENT_IP_ADDR_CHANGED);
587 }
588
589 /*
590 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_018
591 * @tc.desc: UsbNcmChangeHandler Test
592 * @tc.type: FUNC
593 * @tc.require: NONE
594 */
595 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_018, TestSize.Level1)
596 {
597 LnnMonitorNetlinkStateInfo event = {.basic.event = LNN_EVENT_DEVICE_INFO_CHANGED,
598 .status = SOFTBUS_NETMANAGER_IFNAME_REMOVED, .ifName = {0}};
599 UsbNcmChangeHandler(nullptr);
600 UsbNcmChangeHandler((const LnnEventBasicInfo *)&event);
601 EXPECT_NE(event.basic.event, LNN_EVENT_NET_LINK_STATE_CHANGE);
602
603 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
604 EXPECT_CALL(usbMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
605 event.basic.event = LNN_EVENT_NET_LINK_STATE_CHANGE;
606 UsbNcmChangeHandler((const LnnEventBasicInfo *)&event);
607 EXPECT_EQ(event.basic.event, LNN_EVENT_NET_LINK_STATE_CHANGE);
608
609 int32_t ret = strcpy_s(event.ifName, sizeof("usb"), "usb");
610 ASSERT_EQ(ret, EOK);
611 UsbNcmChangeHandler((const LnnEventBasicInfo *)&event);
612 EXPECT_EQ(event.basic.event, LNN_EVENT_NET_LINK_STATE_CHANGE);
613
614 ret = strcpy_s(event.ifName, sizeof("ncm0"), "ncm0");
615 ASSERT_EQ(ret, EOK);
616 UsbNcmChangeHandler((const LnnEventBasicInfo *)&event);
617 EXPECT_EQ(event.status, SOFTBUS_NETMANAGER_IFNAME_REMOVED);
618
619 event.status = SOFTBUS_NETMANAGER_IFNAME_ADDED;
620 UsbNcmChangeHandler((const LnnEventBasicInfo *)&event);
621 EXPECT_NE(event.status, SOFTBUS_NETMANAGER_IFNAME_REMOVED);
622 }
623
624 /*
625 * @tc.name: LNN_USB_NETWORK_IMPL_TEST_019
626 * @tc.desc: RegistUsbProtocolManager Test
627 * @tc.type: FUNC
628 * @tc.require: NONE
629 */
630 HWTEST_F(LNNUsbNetworkImplMockTest, LNN_USB_NETWORK_IMPL_TEST_019, TestSize.Level1)
631 {
632 NiceMock<LnnUsbNetworkImplInterfaceMock> usbMock;
633 EXPECT_CALL(usbMock, LnnRegistProtocol).WillRepeatedly(Return(SOFTBUS_OK));
634 int32_t ret = RegistUsbProtocolManager();
635 EXPECT_EQ(ret, SOFTBUS_OK);
636 }
637
638 } // namespace OHOS