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_auth_mock.h"
20 #include "lnn_net_ledger_mock.h"
21 #include "lnn_network_manager.h"
22 #include "lnn_network_manager.c"
23 #include "lnn_network_manager_mock.h"
24 #include "lnn_physical_subnet_manager.h"
25 #include "lnn_trans_mock.h"
26 #include "lnn_oobe_manager.h"
27 #include "message_handler.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_common.h"
30 #include "softbus_conn_interface.h"
31 #include "softbus_errcode.h"
32 #include "softbus_protocol_def.h"
33
34 namespace OHOS {
35 using namespace testing::ext;
36 using namespace testing;
37
38 LnnNetIfMgr g_netIfMgr1 = {
39 .type = LNN_NETIF_TYPE_ETH,
40 .ifName = "ETH",
41 };
42 LnnNetIfMgr g_netIfMgr2 = {
43 .type = LNN_NETIF_TYPE_WLAN,
44 .ifName = "WLAN",
45 };
46 LnnNetIfMgr g_netIfMgr3 = {
47 .type = LNN_NETIF_TYPE_BR,
48 .ifName = "BR",
49 };
50 LnnNetIfMgr g_netIfMgr4 = {
51 .type = LNN_NETIF_TYPE_BLE,
52 .ifName = "BLE",
53 };
54 class LNNNetworkManagerMockTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp();
59 void TearDown();
60 };
61
SetUpTestCase()62 void LNNNetworkManagerMockTest::SetUpTestCase()
63 {
64 ListTailInsert(&g_netIfNameList, &g_netIfMgr1.node);
65 ListTailInsert(&g_netIfNameList, &g_netIfMgr2.node);
66 ListTailInsert(&g_netIfNameList, &g_netIfMgr3.node);
67 ListTailInsert(&g_netIfNameList, &g_netIfMgr4.node);
68 }
69
TearDownTestCase()70 void LNNNetworkManagerMockTest::TearDownTestCase()
71 {
72 }
73
SetUp()74 void LNNNetworkManagerMockTest::SetUp()
75 {
76 }
77
TearDown()78 void LNNNetworkManagerMockTest::TearDown()
79 {
80 }
81
LnnInitBtProtocolOk(LnnProtocolManager * self)82 int32_t LnnInitBtProtocolOk(LnnProtocolManager *self)
83 {
84 (void)self;
85 return SOFTBUS_OK;
86 }
87
LnnInitBtProtocolErr(LnnProtocolManager * self)88 int32_t LnnInitBtProtocolErr(LnnProtocolManager *self)
89 {
90 (void)self;
91 return SOFTBUS_ERR;
92 }
93
LnnEnableBtProtocol(LnnProtocolManager * self,LnnNetIfMgr * netifMgr)94 int32_t LnnEnableBtProtocol(LnnProtocolManager *self, LnnNetIfMgr *netifMgr)
95 {
96 (void)self;
97 (void)netifMgr;
98 return SOFTBUS_OK;
99 }
100
LnnGetBtListenerModule(ListenerMode mode)101 static ListenerModule LnnGetBtListenerModule(ListenerMode mode)
102 {
103 (void)mode;
104 return UNUSE_BUTT;
105 }
106
107 /*
108 * @tc.name: LNN_NETWORK_MANAGER_TEST_001
109 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
110 * @tc.type: FUNC
111 * @tc.require: I5OMIK
112 */
113 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_001, TestSize.Level1)
114 {
115 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
116 NiceMock<LnnAuthtInterfaceMock> authMock;
117 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
118 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_ERR));
119 EXPECT_CALL(managerMock, RegistIPProtocolManager).WillOnce(Return(SOFTBUS_ERR)).
120 WillRepeatedly(Return(SOFTBUS_OK));
121 EXPECT_CALL(authMock, RegGroupChangeListener).WillOnce(Return(SOFTBUS_ERR)).
122 WillRepeatedly(Return(SOFTBUS_OK));
123 EXPECT_CALL(managerMock, LnnInitPhysicalSubnetManager).WillOnce(Return(SOFTBUS_ERR)).
124 WillRepeatedly(Return(SOFTBUS_OK));
125 EXPECT_CALL(ledgerMock, LnnSetLocalNum64Info).WillOnce(Return(SOFTBUS_ERR)).
126 WillRepeatedly(Return(SOFTBUS_OK));
127 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillRepeatedly(Return(SOFTBUS_OK));
128 int ret = LnnInitNetworkManager();
129 EXPECT_TRUE(ret != SOFTBUS_OK);
130 ret = LnnInitNetworkManager();
131 EXPECT_TRUE(ret != SOFTBUS_OK);
132 ret = LnnInitNetworkManager();
133 EXPECT_TRUE(ret != SOFTBUS_OK);
134 ret = LnnInitNetworkManager();
135 EXPECT_TRUE(ret!= SOFTBUS_OK);
136 ret = LnnInitNetworkManager();
137 EXPECT_TRUE(ret != SOFTBUS_ERR);
138 }
139
140 /*
141 * @tc.name: LNN_NETWORK_MANAGER_TEST_002
142 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
143 * @tc.type: FUNC
144 * @tc.require: I5OMIK
145 */
146 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_002, TestSize.Level1)
147 {
148 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
149 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
150 int32_t ret = LnnGetAddrTypeByIfName(nullptr, nullptr);
151 EXPECT_TRUE(ret != SOFTBUS_OK);
152
153 ConnectionAddrType type1 = CONNECTION_ADDR_ETH;
154 ret = LnnGetAddrTypeByIfName("ETH", &type1);
155 EXPECT_TRUE(ret == SOFTBUS_OK);
156
157 ConnectionAddrType type2 = CONNECTION_ADDR_WLAN;
158 ret = LnnGetAddrTypeByIfName("WLAN", &type2);
159 EXPECT_TRUE(ret == SOFTBUS_OK);
160
161 ConnectionAddrType type3 = CONNECTION_ADDR_BR;
162 ret = LnnGetAddrTypeByIfName("BR", &type3);
163 EXPECT_TRUE(ret == SOFTBUS_OK);
164
165 ConnectionAddrType type4 = CONNECTION_ADDR_BLE;
166 ret = LnnGetAddrTypeByIfName("BLE", &type4);
167 EXPECT_TRUE(ret == SOFTBUS_OK);
168
169 ret = LnnGetNetIfTypeByName(nullptr, nullptr);
170 EXPECT_TRUE(ret != SOFTBUS_OK);
171 }
172
173 /*
174 * @tc.name: LNN_NETWORK_MANAGER_TEST_003
175 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
176 * @tc.type: FUNC
177 * @tc.require: I5OMIK
178 */
179 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_003, TestSize.Level1)
180 {
181 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
182 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
183 int ret = LnnRegistProtocol(nullptr);
184 EXPECT_TRUE(ret != SOFTBUS_OK);
185
186 LnnProtocolManager protocolMgr;
187 memset_s(&protocolMgr, sizeof(protocolMgr), 0, sizeof(protocolMgr));
188 protocolMgr.init = LnnInitBtProtocolErr;
189 protocolMgr.enable = LnnEnableBtProtocol;
190 protocolMgr.getListenerModule = LnnGetBtListenerModule;
191
192 ret = LnnRegistProtocol(&protocolMgr);
193 EXPECT_TRUE(ret != SOFTBUS_OK);
194
195 protocolMgr.init = LnnInitBtProtocolOk;
196 ret = LnnRegistProtocol(&protocolMgr);
197 EXPECT_TRUE(ret == SOFTBUS_OK);
198
199 ret = UnregistProtocol(nullptr);
200 EXPECT_TRUE(ret != SOFTBUS_OK);
201
202 ret = UnregistProtocol(&protocolMgr);
203 EXPECT_TRUE(ret == SOFTBUS_OK);
204
205 ProtocolType protocol = LNN_PROTOCOL_BR;
206
207 ListenerModule listenerModule = LnnGetProtocolListenerModule(protocol, LNN_LISTENER_MODE_DIRECT);
208 EXPECT_TRUE(listenerModule == UNUSE_BUTT);
209
210 FindProtocolByTypeRequest data = {
211 .protocol = LNN_PROTOCOL_BR,
212 };
213 LnnProtocolManager manager = {
214 .id = LNN_PROTOCOL_BR,
215 };
216 VisitNextChoice visitNextChoice = FindProtocolByType(&manager, (void *)&data);
217 EXPECT_TRUE(visitNextChoice == CHOICE_FINISH_VISITING);
218 manager.id = LNN_PROTOCOL_BLE;
219 visitNextChoice = FindProtocolByType(&manager, (void *)&data);
220 EXPECT_TRUE(visitNextChoice == CHOICE_VISIT_NEXT);
221
222 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
223 ON_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillByDefault(Return(true));
224 ret = LnnInitNetworkManagerDelay();
225 EXPECT_TRUE(ret == SOFTBUS_OK);
226 }
227
228 /*
229 * @tc.name: LNN_NETWORK_MANAGER_TEST_004
230 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
231 * @tc.type: FUNC
232 * @tc.require: I5OMIK
233 */
234 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_004, TestSize.Level1)
235 {
236 int len = 0;
237 char buf[] = "nullptr";
238 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
239 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
240 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
241 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_ERR));
242 bool ret = LnnIsAutoNetWorkingEnabled();
243 EXPECT_TRUE(ret == true);
244 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
245 ret = LnnIsAutoNetWorkingEnabled();
246 EXPECT_TRUE(ret == false);
247
248 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
249 int res = LnnInitManagerByConfig();
250 EXPECT_TRUE(res != SOFTBUS_OK);
251
252 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_ERR));
253 res = LnnInitManagerByConfig();
254 EXPECT_TRUE(res == SOFTBUS_OK);
255
256 res = ParseIfNameConfig(nullptr, len);
257 EXPECT_TRUE(res != SOFTBUS_OK);
258 res = ParseIfNameConfig(buf, sizeof("nullptr"));
259 EXPECT_TRUE(res == SOFTBUS_OK);
260
261 res = SetIfNameDefaultVal();
262 EXPECT_TRUE(res == SOFTBUS_OK);
263 }
264
265 HWTEST_F(LNNNetworkManagerMockTest, NET_USER_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
266 {
267 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
268 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
269 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
270 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
271 (void)NetUserStateEventHandler(nullptr);
272 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
273 EXPECT_TRUE(info1 != nullptr);
274 info1->basic.event = LNN_EVENT_USER_STATE_CHANGED;
275 info1->status = SOFTBUS_USER_FOREGROUND;
276 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
277 (void)NetUserStateEventHandler(info2);
278
279 info1->status = SOFTBUS_USER_BACKGROUND;
280 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
281 (void)NetUserStateEventHandler(info2);
282
283 info1->status = SOFTBUS_USER_UNKNOWN;
284 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
285 (void)NetUserStateEventHandler(info2);
286
287 delete info1;
288 info1 = nullptr;
289 }
290
291 HWTEST_F(LNNNetworkManagerMockTest, NET_LOCK_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
292 {
293 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
294 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
295 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
296 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
297 LnnEventBasicInfo info;
298 (void)NetLockStateEventHandler(nullptr);
299
300 info.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
301 (void)NetLockStateEventHandler(&info);
302 }
303
304 HWTEST_F(LNNNetworkManagerMockTest, NET_OOB_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
305 {
306 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
307 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
308 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
309 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
310 (void)NetOOBEStateEventHandler(nullptr);
311 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
312 EXPECT_TRUE(info1 != nullptr);
313 info1->basic.event = LNN_EVENT_OOBE_STATE_CHANGED;
314 info1->status = SOFTBUS_OOBE_RUNNING;
315 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
316 (void)NetOOBEStateEventHandler(info2);
317
318 info1->status = SOFTBUS_OOBE_END;
319 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
320 (void)NetOOBEStateEventHandler(info2);
321
322 info1->status = SOFTBUS_OOBE_UNKNOWN;
323 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
324 (void)NetOOBEStateEventHandler(info2);
325
326 delete info1;
327 info1 = nullptr;
328 }
329
330 HWTEST_F(LNNNetworkManagerMockTest, ON_DEVICE_BOUND_TEST_001, TestSize.Level1)
331 {
332 const char *udid = nullptr;
333 const char *groupInfo = nullptr;
334 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
335 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
336 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
337 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
338 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
339 (void)OnDeviceBound(udid, groupInfo);
340 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
341 (void)OnDeviceBound(udid, groupInfo);
342 }
343
344 HWTEST_F(LNNNetworkManagerMockTest, CREAT_NETIFMGR_TEST_001, TestSize.Level1)
345 {
346 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
347 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
348 const char *netIfName = "Softbus";
349 LnnNetIfMgr *ret = CreateNetifMgr(netIfName);
350 EXPECT_TRUE(ret != NULL);
351 }
352
353 HWTEST_F(LNNNetworkManagerMockTest, SAVE_BRNETWORK_DEVICE_TEST_001, TestSize.Level1)
354 {
355 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
356 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
357 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
358 (void)SaveBrNetworkDevices();
359 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_ERR));
360 (void)SaveBrNetworkDevices();
361 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
362 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_ERR));
363 (void)SaveBrNetworkDevices();
364 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
365 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
366 (void)SaveBrNetworkDevices();
367 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
368 (void)SaveBrNetworkDevices();
369 }
370
371 HWTEST_F(LNNNetworkManagerMockTest, NET_ACCOUNT_STATECHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
372 {
373 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
374 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
375 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
376 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
377 (void)NetAccountStateChangeEventHandler(nullptr);
378 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
379 EXPECT_TRUE(info1 != nullptr);
380 info1->basic.event = LNN_EVENT_ACCOUNT_CHANGED;
381 info1->status = SOFTBUS_ACCOUNT_LOG_IN;
382 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
383 (void)NetAccountStateChangeEventHandler(info2);
384
385 info1->status = SOFTBUS_ACCOUNT_LOG_OUT;
386 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
387 (void)NetAccountStateChangeEventHandler(info2);
388
389 info1->status = SOFTBUS_ACCOUNT_UNKNOWN;
390 info2 = reinterpret_cast<LnnEventBasicInfo*>(info1);
391 (void)NetAccountStateChangeEventHandler(info2);
392
393 delete info1;
394 info1 = nullptr;
395 }
396
397 HWTEST_F(LNNNetworkManagerMockTest, GET_ALL_PROTOCOLS_TEST_001, TestSize.Level1)
398 {
399 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
400 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
401 void *data = nullptr;
402 VisitNextChoice ret = GetAllProtocols(nullptr, data);
403 EXPECT_TRUE(ret == CHOICE_FINISH_VISITING);
404
405 LnnProtocolManager manager;
406 data = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnProtocolManager)));
407 EXPECT_TRUE(data != nullptr);
408 ret = GetAllProtocols(&manager, data);
409 EXPECT_TRUE(ret == CHOICE_VISIT_NEXT);
410 SoftBusFree(data);
411 }
412
413 HWTEST_F(LNNNetworkManagerMockTest, NIGHT_MODE_CHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
414 {
415 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
416 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
417 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
418 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
419 (void)NightModeChangeEventHandler(nullptr);
420 LnnEventBasicInfo info;
421 info.event = LNN_EVENT_NIGHT_MODE_CHANGED;
422 (void)NightModeChangeEventHandler(&info);
423 }
424
425 HWTEST_F(LNNNetworkManagerMockTest, REGIST_NETIFMGR_TEST_001, TestSize.Level1)
426 {
427 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
428 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
429 LnnNetIfNameType type = LNN_MAX_NUM_TYPE;
430 LnnNetIfManagerBuilder builder = nullptr;
431 int32_t ret = RegistNetIfMgr(type, builder);
432 EXPECT_TRUE(ret != SOFTBUS_OK);
433
434 type = LNN_MAX_NUM_TYPE;
435 const char *ifName = "Softbus";
436 LnnNetIfMgr *res = NetifMgrFactory(type, ifName);
437 EXPECT_TRUE(res == nullptr);
438 }
439 }
440