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.c"
22 #include "lnn_network_manager.h"
23 #include "lnn_network_manager_mock.h"
24 #include "lnn_oobe_manager.h"
25 #include "lnn_physical_subnet_manager.h"
26 #include "lnn_settingdata_event_monitor.h"
27 #include "lnn_trans_mock.h"
28 #include "message_handler.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_conn_interface.h"
32 #include "softbus_error_code.h"
33 #include "softbus_protocol_def.h"
34
35 namespace OHOS {
36 using namespace testing::ext;
37 using namespace testing;
38
39 LnnNetIfMgr g_netIfMgr1 = {
40 .type = LNN_NETIF_TYPE_ETH,
41 .ifName = "ETH",
42 };
43 LnnNetIfMgr g_netIfMgr2 = {
44 .type = LNN_NETIF_TYPE_WLAN,
45 .ifName = "WLAN",
46 };
47 LnnNetIfMgr g_netIfMgr3 = {
48 .type = LNN_NETIF_TYPE_BR,
49 .ifName = "BR",
50 };
51 LnnNetIfMgr g_netIfMgr4 = {
52 .type = LNN_NETIF_TYPE_BLE,
53 .ifName = "BLE",
54 };
55 class LNNNetworkManagerMockTest : public testing::Test {
56 public:
57 static void SetUpTestCase();
58 static void TearDownTestCase();
59 void SetUp();
60 void TearDown();
61 };
62
SetUpTestCase()63 void LNNNetworkManagerMockTest::SetUpTestCase()
64 {
65 ListTailInsert(&g_netIfNameList, &g_netIfMgr1.node);
66 ListTailInsert(&g_netIfNameList, &g_netIfMgr2.node);
67 ListTailInsert(&g_netIfNameList, &g_netIfMgr3.node);
68 ListTailInsert(&g_netIfNameList, &g_netIfMgr4.node);
69 }
70
TearDownTestCase()71 void LNNNetworkManagerMockTest::TearDownTestCase() { }
72
SetUp()73 void LNNNetworkManagerMockTest::SetUp() { }
74
TearDown()75 void LNNNetworkManagerMockTest::TearDown() { }
76
LnnInitBtProtocolOk(LnnProtocolManager * self)77 int32_t LnnInitBtProtocolOk(LnnProtocolManager *self)
78 {
79 (void)self;
80 return SOFTBUS_OK;
81 }
82
LnnInitBtProtocolErr(LnnProtocolManager * self)83 int32_t LnnInitBtProtocolErr(LnnProtocolManager *self)
84 {
85 (void)self;
86 return SOFTBUS_INVALID_PARAM;
87 }
88
LnnEnableBtProtocol(LnnProtocolManager * self,LnnNetIfMgr * netifMgr)89 int32_t LnnEnableBtProtocol(LnnProtocolManager *self, LnnNetIfMgr *netifMgr)
90 {
91 (void)self;
92 (void)netifMgr;
93 return SOFTBUS_OK;
94 }
95
LnnGetBtListenerModule(ListenerMode mode)96 static ListenerModule LnnGetBtListenerModule(ListenerMode mode)
97 {
98 (void)mode;
99 return UNUSE_BUTT;
100 }
101
102 /*
103 * @tc.name: LNN_NETWORK_MANAGER_TEST_001
104 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
105 * @tc.type: FUNC
106 * @tc.require: I5OMIK
107 */
108 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_001, TestSize.Level1)
109 {
110 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
111 NiceMock<LnnAuthtInterfaceMock> authMock;
112 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
113 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
114 EXPECT_CALL(managerMock, RegistIPProtocolManager)
115 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
116 .WillRepeatedly(Return(SOFTBUS_OK));
117 EXPECT_CALL(authMock, RegGroupChangeListener)
118 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
119 .WillRepeatedly(Return(SOFTBUS_OK));
120 EXPECT_CALL(managerMock, LnnInitPhysicalSubnetManager)
121 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
122 .WillRepeatedly(Return(SOFTBUS_OK));
123 EXPECT_CALL(ledgerMock, LnnSetLocalNum64Info)
124 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
125 .WillRepeatedly(Return(SOFTBUS_OK));
126 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillRepeatedly(Return(SOFTBUS_OK));
127 int32_t ret = LnnInitNetworkManager();
128 EXPECT_TRUE(ret != SOFTBUS_OK);
129 ret = LnnInitNetworkManager();
130 EXPECT_TRUE(ret != SOFTBUS_OK);
131 ret = LnnInitNetworkManager();
132 EXPECT_TRUE(ret != SOFTBUS_OK);
133 ret = LnnInitNetworkManager();
134 EXPECT_TRUE(ret != SOFTBUS_OK);
135 ret = LnnInitNetworkManager();
136 EXPECT_EQ(ret, SOFTBUS_OK);
137 }
138
139 /*
140 * @tc.name: LNN_NETWORK_MANAGER_TEST_002
141 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
142 * @tc.type: FUNC
143 * @tc.require: I5OMIK
144 */
145 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_002, TestSize.Level1)
146 {
147 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
148 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
149 int32_t ret = LnnGetAddrTypeByIfName(nullptr, nullptr);
150 EXPECT_TRUE(ret != SOFTBUS_OK);
151
152 ConnectionAddrType type1 = CONNECTION_ADDR_ETH;
153 ret = LnnGetAddrTypeByIfName("ETH", &type1);
154 EXPECT_TRUE(ret == SOFTBUS_OK);
155
156 ConnectionAddrType type2 = CONNECTION_ADDR_WLAN;
157 ret = LnnGetAddrTypeByIfName("WLAN", &type2);
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159
160 ConnectionAddrType type3 = CONNECTION_ADDR_BR;
161 ret = LnnGetAddrTypeByIfName("BR", &type3);
162 EXPECT_TRUE(ret == SOFTBUS_OK);
163
164 ConnectionAddrType type4 = CONNECTION_ADDR_BLE;
165 ret = LnnGetAddrTypeByIfName("BLE", &type4);
166 EXPECT_TRUE(ret == SOFTBUS_OK);
167
168 ret = LnnGetNetIfTypeByName(nullptr, nullptr);
169 EXPECT_TRUE(ret != SOFTBUS_OK);
170 }
171
172 /*
173 * @tc.name: LNN_NETWORK_MANAGER_TEST_003
174 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
175 * @tc.type: FUNC
176 * @tc.require: I5OMIK
177 */
178 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_003, TestSize.Level1)
179 {
180 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
181 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
182 int32_t ret = LnnRegistProtocol(nullptr);
183 EXPECT_TRUE(ret != SOFTBUS_OK);
184
185 LnnProtocolManager protocolMgr;
186 memset_s(&protocolMgr, sizeof(protocolMgr), 0, sizeof(protocolMgr));
187 protocolMgr.init = LnnInitBtProtocolErr;
188 protocolMgr.enable = LnnEnableBtProtocol;
189 protocolMgr.getListenerModule = LnnGetBtListenerModule;
190
191 ret = LnnRegistProtocol(&protocolMgr);
192 EXPECT_TRUE(ret != SOFTBUS_OK);
193
194 protocolMgr.init = LnnInitBtProtocolOk;
195 ret = LnnRegistProtocol(&protocolMgr);
196 EXPECT_TRUE(ret == SOFTBUS_OK);
197
198 ret = UnregistProtocol(nullptr);
199 EXPECT_TRUE(ret != SOFTBUS_OK);
200
201 ret = UnregistProtocol(&protocolMgr);
202 EXPECT_TRUE(ret == SOFTBUS_OK);
203
204 ProtocolType protocol = LNN_PROTOCOL_BR;
205
206 ListenerModule listenerModule = LnnGetProtocolListenerModule(protocol, LNN_LISTENER_MODE_DIRECT);
207 EXPECT_TRUE(listenerModule == UNUSE_BUTT);
208
209 FindProtocolByTypeRequest data = {
210 .protocol = LNN_PROTOCOL_BR,
211 };
212 LnnProtocolManager manager = {
213 .id = LNN_PROTOCOL_BR,
214 };
215 VisitNextChoice visitNextChoice = FindProtocolByType(&manager, (void *)&data);
216 EXPECT_TRUE(visitNextChoice == CHOICE_FINISH_VISITING);
217 manager.id = LNN_PROTOCOL_BLE;
218 visitNextChoice = FindProtocolByType(&manager, (void *)&data);
219 EXPECT_TRUE(visitNextChoice == CHOICE_VISIT_NEXT);
220
221 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
222 ON_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillByDefault(Return(true));
223 ret = LnnInitNetworkManagerDelay();
224 EXPECT_TRUE(ret == SOFTBUS_OK);
225 }
226
227 /*
228 * @tc.name: LNN_NETWORK_MANAGER_TEST_004
229 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
230 * @tc.type: FUNC
231 * @tc.require: I5OMIK
232 */
233 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_004, TestSize.Level1)
234 {
235 int32_t len = 0;
236 char buf[] = "nullptr";
237 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
238 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
239 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
240 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
241 bool ret = LnnIsAutoNetWorkingEnabled();
242 EXPECT_TRUE(ret == true);
243 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
244 ret = LnnIsAutoNetWorkingEnabled();
245 EXPECT_TRUE(ret == false);
246
247 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
248 int32_t res = LnnInitManagerByConfig();
249 EXPECT_TRUE(res != SOFTBUS_OK);
250
251 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
252 res = LnnInitManagerByConfig();
253 EXPECT_TRUE(res == SOFTBUS_OK);
254
255 res = ParseIfNameConfig(nullptr, len);
256 EXPECT_TRUE(res != SOFTBUS_OK);
257 res = ParseIfNameConfig(buf, sizeof("nullptr"));
258 EXPECT_TRUE(res == SOFTBUS_OK);
259
260 res = SetIfNameDefaultVal();
261 EXPECT_TRUE(res == SOFTBUS_OK);
262 }
263
264 HWTEST_F(LNNNetworkManagerMockTest, NET_USER_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
265 {
266 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
267 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
268 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
269 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
270 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
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_FOREGROUND;
284 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
285 (void)NetUserStateEventHandler(info2);
286
287 info1->status = SOFTBUS_USER_UNKNOWN;
288 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
289 (void)NetUserStateEventHandler(info2);
290
291 delete info1;
292 info1 = nullptr;
293 }
294
295 HWTEST_F(LNNNetworkManagerMockTest, NET_LOCK_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
296 {
297 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
298 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
299 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
300 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
301 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
302 ;
303 LnnEventBasicInfo info;
304 (void)NetLockStateEventHandler(nullptr);
305
306 info.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
307 (void)NetLockStateEventHandler(&info);
308 }
309
310 HWTEST_F(LNNNetworkManagerMockTest, NET_OOB_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
311 {
312 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
313 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
314 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
315 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
316 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
317 (void)NetOOBEStateEventHandler(nullptr);
318 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
319 EXPECT_TRUE(info1 != nullptr);
320 info1->basic.event = LNN_EVENT_OOBE_STATE_CHANGED;
321 info1->status = SOFTBUS_OOBE_RUNNING;
322 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
323 (void)NetOOBEStateEventHandler(info2);
324
325 info1->status = SOFTBUS_OOBE_END;
326 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
327 (void)NetOOBEStateEventHandler(info2);
328
329 info1->status = SOFTBUS_OOBE_UNKNOWN;
330 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
331 (void)NetOOBEStateEventHandler(info2);
332
333 delete info1;
334 info1 = nullptr;
335 }
336
337 HWTEST_F(LNNNetworkManagerMockTest, ON_DEVICE_BOUND_TEST_001, TestSize.Level1)
338 {
339 const char *udid = nullptr;
340 const char *groupInfo = nullptr;
341 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
342 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
343 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
344 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
345 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
346 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
347 (void)OnDeviceBound(udid, groupInfo);
348 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
349 (void)OnDeviceBound(udid, groupInfo);
350 }
351
352 HWTEST_F(LNNNetworkManagerMockTest, CREAT_NETIFMGR_TEST_001, TestSize.Level1)
353 {
354 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
355 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
356 const char *netIfName = "Softbus";
357 LnnNetIfMgr *ret = CreateNetifMgr(netIfName);
358 EXPECT_NE(ret, nullptr);
359 if (ret != nullptr) {
360 SoftBusFree(ret);
361 }
362 ret = CreateNetifMgr(nullptr);
363 EXPECT_EQ(ret, nullptr);
364 if (ret != nullptr) {
365 SoftBusFree(ret);
366 }
367 }
368
369 HWTEST_F(LNNNetworkManagerMockTest, CREAT_NETIFMGR_TEST_002, TestSize.Level1)
370 {
371 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
372 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
373 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
374 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
375 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
376 info1->status = SOFTBUS_USER_UNLOCK;
377 const LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
378 (void)NetLockStateEventHandler(info2);
379 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
380 info1->status = SOFTBUS_SCREEN_UNLOCK;
381 const LnnEventBasicInfo *info3 = reinterpret_cast<LnnEventBasicInfo *>(info1);
382 (void)NetLockStateEventHandler(info3);
383 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
384 info1->status = SOFTBUS_SCREEN_LOCK;
385 const LnnEventBasicInfo *info4 = reinterpret_cast<LnnEventBasicInfo *>(info1);
386 (void)NetLockStateEventHandler(info4);
387 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
388 info1->status = SOFTBUS_SCREEN_LOCK_UNKNOWN;
389 const LnnEventBasicInfo *info5 = reinterpret_cast<LnnEventBasicInfo *>(info1);
390 (void)NetLockStateEventHandler(info5);
391 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
392 LnnNetIfMgr *ret = CreateNetifMgr(nullptr);
393 EXPECT_EQ(ret, nullptr);
394
395 delete info1;
396 info1 = nullptr;
397 }
398
399 HWTEST_F(LNNNetworkManagerMockTest, SAVE_BRNETWORK_DEVICE_TEST_001, TestSize.Level1)
400 {
401 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
402 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
403 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
404 (void)SaveBrNetworkDevices();
405 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
406 (void)SaveBrNetworkDevices();
407 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
408 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
409 (void)SaveBrNetworkDevices();
410 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
411 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
412 (void)SaveBrNetworkDevices();
413 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
414 (void)SaveBrNetworkDevices();
415 }
416
417 HWTEST_F(LNNNetworkManagerMockTest, NET_ACCOUNT_STATECHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
418 {
419 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
420 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
421 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
422 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
423 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
424 (void)NetAccountStateChangeEventHandler(nullptr);
425 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
426 EXPECT_TRUE(info1 != nullptr);
427 info1->basic.event = LNN_EVENT_ACCOUNT_CHANGED;
428 info1->status = SOFTBUS_ACCOUNT_LOG_IN;
429 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
430 (void)NetAccountStateChangeEventHandler(info2);
431
432 info1->status = SOFTBUS_ACCOUNT_LOG_OUT;
433 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
434 (void)NetAccountStateChangeEventHandler(info2);
435
436 info1->status = SOFTBUS_ACCOUNT_UNKNOWN;
437 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
438 (void)NetAccountStateChangeEventHandler(info2);
439
440 delete info1;
441 info1 = nullptr;
442 }
443
444 HWTEST_F(LNNNetworkManagerMockTest, GET_ALL_PROTOCOLS_TEST_001, TestSize.Level1)
445 {
446 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
447 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
448 const char *groupId = "groupId";
449 int32_t groupType = AUTH_IDENTICAL_ACCOUNT_GROUP;
450 EXPECT_CALL(managerMock, LnnUpdateOhosAccount).WillRepeatedly(Return());
451 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
452 EXPECT_CALL(managerMock, LnnNotifyAccountStateChangeEvent).WillRepeatedly(Return());
453 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
454 (void)OnGroupCreated(groupId, groupType);
455 groupType = AUTH_PEER_TO_PEER_GROUP;
456 EXPECT_CALL(managerMock, LnnUpdateOhosAccount).WillRepeatedly(Return());
457 EXPECT_CALL(managerMock, LnnNotifyAccountStateChangeEvent).WillRepeatedly(Return());
458 (void)OnGroupCreated(groupId, groupType);
459 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
460 void *data = nullptr;
461 VisitNextChoice ret = GetAllProtocols(nullptr, data);
462 EXPECT_TRUE(ret == CHOICE_FINISH_VISITING);
463 LnnProtocolManager manager;
464 data = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnProtocolManager)));
465 EXPECT_TRUE(data != nullptr);
466 ret = GetAllProtocols(&manager, data);
467 EXPECT_TRUE(ret == CHOICE_VISIT_NEXT);
468 SoftBusFree(data);
469 }
470
471 HWTEST_F(LNNNetworkManagerMockTest, NIGHT_MODE_CHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
472 {
473 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
474 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
475 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
476 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
477 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
478 (void)NightModeChangeEventHandler(nullptr);
479 LnnEventBasicInfo info;
480 info.event = LNN_EVENT_NIGHT_MODE_CHANGED;
481 (void)NightModeChangeEventHandler(&info);
482
483 EXPECT_CALL(managerMock, LnnRequestLeaveByAddrType).WillRepeatedly(Return(SOFTBUS_OK));
484 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
485 EXPECT_NE(info1, nullptr);
486 info1->basic.event = LNN_EVENT_NIGHT_MODE_CHANGED;
487 info1->status = SOFTBUS_NIGHT_MODE_ON;
488 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
489 (void)NightModeChangeEventHandler(info2);
490
491 delete info1;
492 info1 = nullptr;
493 }
494
495 HWTEST_F(LNNNetworkManagerMockTest, REGIST_NETIFMGR_TEST_001, TestSize.Level1)
496 {
497 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
498 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
499
500 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
501 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
502 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
503 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
504 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
505 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
506 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL));
507 (void)RestartCoapDiscovery();
508
509 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
510 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
511 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
512 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
513 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
514 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
515 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL));
516 EXPECT_CALL(managerMock, LnnStopDiscovery).WillRepeatedly(Return());
517 EXPECT_CALL(managerMock, LnnStartDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
518 (void)RestartCoapDiscovery();
519
520 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
521 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
522 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
523 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
524 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
525 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
526 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL));
527 EXPECT_CALL(managerMock, LnnStopDiscovery).WillRepeatedly(Return());
528 EXPECT_CALL(managerMock, LnnStartDiscovery).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL));
529 (void)RestartCoapDiscovery();
530
531 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
532 LnnNetIfNameType type = LNN_MAX_NUM_TYPE;
533 LnnNetIfManagerBuilder builder = nullptr;
534 int32_t ret = RegistNetIfMgr(type, builder);
535 EXPECT_TRUE(ret != SOFTBUS_OK);
536
537 type = LNN_MAX_NUM_TYPE;
538 const char *ifName = "Softbus";
539 LnnNetIfMgr *res = NetifMgrFactory(type, ifName);
540 EXPECT_TRUE(res == nullptr);
541 }
542
543 HWTEST_F(LNNNetworkManagerMockTest, CONVERT_TO_NET_IF_TYPE_001, TestSize.Level1)
544 {
545 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
546 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
547 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
548 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
549 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
550 (void)RestartCoapDiscovery();
551 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
552 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
553 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
554 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
555 (void)RestartCoapDiscovery();
556 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
557 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
558 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
559 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
560 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
561 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
562 (void)RestartCoapDiscovery();
563 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
564 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
565 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
566 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
567 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
568 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
569 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_OK));
570 (void)RestartCoapDiscovery();
571 LnnNetIfNameType type = LNN_MAX_NUM_TYPE;
572 LnnNetIfType lnnNetIfType = ConvertToNetIfType(type);
573 EXPECT_EQ(lnnNetIfType, 0);
574 type = LNN_ETH_TYPE;
575 lnnNetIfType = ConvertToNetIfType(type);
576 EXPECT_NE(lnnNetIfType, 0);
577 type = LNN_WLAN_TYPE;
578 lnnNetIfType = ConvertToNetIfType(type);
579 EXPECT_NE(lnnNetIfType, 0);
580 }
581
582 HWTEST_F(LNNNetworkManagerMockTest, LNN_REGISTER_EVENT_001, TestSize.Level1)
583 {
584 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
585 const char *groupId = "groupId";
586 int32_t groupType = AUTH_IDENTICAL_ACCOUNT_GROUP;
587 EXPECT_CALL(managerMock, LnnOnOhosAccountLogout).WillRepeatedly(Return());
588 (void)OnGroupDeleted(groupId, groupType);
589 groupType = AUTH_PEER_TO_PEER_GROUP;
590 EXPECT_CALL(managerMock, LnnOnOhosAccountLogout).WillRepeatedly(Return());
591 (void)OnGroupDeleted(groupId, groupType);
592 int32_t ret = SOFTBUS_OK;
593 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillOnce(Return(SOFTBUS_INVALID_PARAM));
594 ret = LnnRegisterEvent();
595 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
596 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
597 .WillOnce(Return(SOFTBUS_OK))
598 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
599 ret = LnnRegisterEvent();
600 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
601 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
602 .WillOnce(Return(SOFTBUS_OK))
603 .WillOnce(Return(SOFTBUS_OK))
604 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
605 ret = LnnRegisterEvent();
606 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
607 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
608 .WillOnce(Return(SOFTBUS_OK))
609 .WillOnce(Return(SOFTBUS_OK))
610 .WillOnce(Return(SOFTBUS_OK))
611 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
612 ret = LnnRegisterEvent();
613 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
614 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
615 .WillOnce(Return(SOFTBUS_OK))
616 .WillOnce(Return(SOFTBUS_OK))
617 .WillOnce(Return(SOFTBUS_OK))
618 .WillOnce(Return(SOFTBUS_OK))
619 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
620 ret = LnnRegisterEvent();
621 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
622 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillRepeatedly(Return(SOFTBUS_OK));
623 ret = LnnRegisterEvent();
624 EXPECT_EQ(ret, SOFTBUS_OK);
625 }
626
627 } // namespace OHOS
628