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_physical_subnet_manager.h"
25 #include "lnn_settingdata_event_monitor.h"
26 #include "lnn_trans_mock.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_error_code.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
SetUp()72 void LNNNetworkManagerMockTest::SetUp() { }
73
TearDown()74 void LNNNetworkManagerMockTest::TearDown() { }
75
LnnInitBtProtocolOk(LnnProtocolManager * self)76 int32_t LnnInitBtProtocolOk(LnnProtocolManager *self)
77 {
78 (void)self;
79 return SOFTBUS_OK;
80 }
81
LnnInitBtProtocolErr(LnnProtocolManager * self)82 int32_t LnnInitBtProtocolErr(LnnProtocolManager *self)
83 {
84 (void)self;
85 return SOFTBUS_INVALID_PARAM;
86 }
87
LnnEnableBtProtocol(LnnProtocolManager * self,LnnNetIfMgr * netifMgr)88 int32_t LnnEnableBtProtocol(LnnProtocolManager *self, LnnNetIfMgr *netifMgr)
89 {
90 (void)self;
91 (void)netifMgr;
92 return SOFTBUS_OK;
93 }
94
LnnGetBtListenerModule(ListenerMode mode)95 static ListenerModule LnnGetBtListenerModule(ListenerMode mode)
96 {
97 (void)mode;
98 return UNUSE_BUTT;
99 }
100
101 /*
102 * @tc.name: LNN_NETWORK_MANAGER_TEST_001
103 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
104 * @tc.type: FUNC
105 * @tc.require: I5OMIK
106 */
107 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_001, TestSize.Level1)
108 {
109 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
110 NiceMock<LnnAuthtInterfaceMock> authMock;
111 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
112 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
113 EXPECT_CALL(managerMock, RegistIPProtocolManager)
114 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
115 .WillRepeatedly(Return(SOFTBUS_OK));
116 EXPECT_CALL(managerMock, RegistUsbProtocolManager)
117 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
118 .WillRepeatedly(Return(SOFTBUS_OK));
119 EXPECT_CALL(authMock, RegGroupChangeListener)
120 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
121 .WillRepeatedly(Return(SOFTBUS_OK));
122 EXPECT_CALL(managerMock, LnnInitPhysicalSubnetManager)
123 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
124 .WillRepeatedly(Return(SOFTBUS_OK));
125 EXPECT_CALL(ledgerMock, LnnSetLocalNum64Info)
126 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
127 .WillRepeatedly(Return(SOFTBUS_OK));
128 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillRepeatedly(Return(SOFTBUS_OK));
129 int32_t 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_TRUE(ret != SOFTBUS_OK);
137 ret = LnnInitNetworkManager();
138 EXPECT_TRUE(ret != SOFTBUS_OK);
139 ret = LnnInitNetworkManager();
140 EXPECT_EQ(ret, SOFTBUS_OK);
141 }
142
143 /*
144 * @tc.name: LNN_NETWORK_MANAGER_TEST_002
145 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
146 * @tc.type: FUNC
147 * @tc.require: I5OMIK
148 */
149 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_002, TestSize.Level1)
150 {
151 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
152 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
153 int32_t ret = LnnGetAddrTypeByIfName(nullptr, nullptr);
154 EXPECT_TRUE(ret != SOFTBUS_OK);
155
156 ConnectionAddrType type1 = CONNECTION_ADDR_ETH;
157 ret = LnnGetAddrTypeByIfName("ETH", &type1);
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159
160 ConnectionAddrType type2 = CONNECTION_ADDR_WLAN;
161 ret = LnnGetAddrTypeByIfName("WLAN", &type2);
162 EXPECT_TRUE(ret == SOFTBUS_OK);
163
164 ConnectionAddrType type3 = CONNECTION_ADDR_BR;
165 ret = LnnGetAddrTypeByIfName("BR", &type3);
166 EXPECT_TRUE(ret == SOFTBUS_OK);
167
168 ConnectionAddrType type4 = CONNECTION_ADDR_BLE;
169 ret = LnnGetAddrTypeByIfName("BLE", &type4);
170 EXPECT_TRUE(ret == SOFTBUS_OK);
171
172 ret = LnnGetNetIfTypeByName(nullptr, nullptr);
173 EXPECT_TRUE(ret != SOFTBUS_OK);
174 }
175
176 /*
177 * @tc.name: LNN_NETWORK_MANAGER_TEST_003
178 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
179 * @tc.type: FUNC
180 * @tc.require: I5OMIK
181 */
182 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_003, TestSize.Level1)
183 {
184 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
185 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
186 int32_t ret = LnnRegistProtocol(nullptr);
187 EXPECT_TRUE(ret != SOFTBUS_OK);
188
189 LnnProtocolManager protocolMgr;
190 memset_s(&protocolMgr, sizeof(protocolMgr), 0, sizeof(protocolMgr));
191 protocolMgr.init = LnnInitBtProtocolErr;
192 protocolMgr.enable = LnnEnableBtProtocol;
193 protocolMgr.getListenerModule = LnnGetBtListenerModule;
194
195 ret = LnnRegistProtocol(&protocolMgr);
196 EXPECT_TRUE(ret != SOFTBUS_OK);
197
198 protocolMgr.init = LnnInitBtProtocolOk;
199 ret = LnnRegistProtocol(&protocolMgr);
200 EXPECT_TRUE(ret == SOFTBUS_OK);
201
202 ret = UnregistProtocol(nullptr);
203 EXPECT_TRUE(ret != SOFTBUS_OK);
204
205 ret = UnregistProtocol(&protocolMgr);
206 EXPECT_TRUE(ret == SOFTBUS_OK);
207
208 ProtocolType protocol = LNN_PROTOCOL_BR;
209
210 ListenerModule listenerModule = LnnGetProtocolListenerModule(protocol, LNN_LISTENER_MODE_DIRECT);
211 EXPECT_TRUE(listenerModule == UNUSE_BUTT);
212
213 FindProtocolByTypeRequest data = {
214 .protocol = LNN_PROTOCOL_BR,
215 };
216 LnnProtocolManager manager = {
217 .id = LNN_PROTOCOL_BR,
218 };
219 VisitNextChoice visitNextChoice = FindProtocolByType(&manager, (void *)&data);
220 EXPECT_TRUE(visitNextChoice == CHOICE_FINISH_VISITING);
221 manager.id = LNN_PROTOCOL_BLE;
222 visitNextChoice = FindProtocolByType(&manager, (void *)&data);
223 EXPECT_TRUE(visitNextChoice == CHOICE_VISIT_NEXT);
224
225 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
226 ON_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillByDefault(Return(true));
227 ret = LnnInitNetworkManagerDelay();
228 EXPECT_TRUE(ret == SOFTBUS_OK);
229 }
230
231 /*
232 * @tc.name: LNN_NETWORK_MANAGER_TEST_004
233 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
234 * @tc.type: FUNC
235 * @tc.require: I5OMIK
236 */
237 HWTEST_F(LNNNetworkManagerMockTest, LNN_NETWORK_MANAGER_TEST_004, TestSize.Level1)
238 {
239 int32_t len = 0;
240 char buf[] = "nullptr";
241 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
242 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
243 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
244 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
245 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillOnce(DoAll(SetArgPointee<1>(TYPE_GLASS_ID), Return(SOFTBUS_OK))).
246 WillRepeatedly(Return(SOFTBUS_OK));
247 bool ret = LnnIsAutoNetWorkingEnabled();
248 EXPECT_TRUE(ret == false);
249 ret = LnnIsAutoNetWorkingEnabled();
250 EXPECT_TRUE(ret == true);
251 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
252 ret = LnnIsAutoNetWorkingEnabled();
253 EXPECT_TRUE(ret == false);
254
255 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
256 int32_t res = LnnInitManagerByConfig();
257 EXPECT_TRUE(res != SOFTBUS_OK);
258
259 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
260 res = LnnInitManagerByConfig();
261 EXPECT_TRUE(res == SOFTBUS_OK);
262
263 res = ParseIfNameConfig(nullptr, len);
264 EXPECT_TRUE(res != SOFTBUS_OK);
265 res = ParseIfNameConfig(buf, sizeof("nullptr"));
266 EXPECT_TRUE(res == SOFTBUS_OK);
267
268 res = SetIfNameDefaultVal();
269 EXPECT_TRUE(res == SOFTBUS_OK);
270 }
271
272 HWTEST_F(LNNNetworkManagerMockTest, NET_USER_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
273 {
274 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
275 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
276 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
277 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
278 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
279 (void)NetUserStateEventHandler(nullptr);
280 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
281 EXPECT_TRUE(info1 != nullptr);
282 info1->basic.event = LNN_EVENT_USER_STATE_CHANGED;
283 info1->status = SOFTBUS_USER_FOREGROUND;
284 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
285 (void)NetUserStateEventHandler(info2);
286
287 info1->status = SOFTBUS_USER_BACKGROUND;
288 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
289 (void)NetUserStateEventHandler(info2);
290
291 info1->status = SOFTBUS_USER_FOREGROUND;
292 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
293 (void)NetUserStateEventHandler(info2);
294
295 info1->status = SOFTBUS_USER_UNKNOWN;
296 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
297 (void)NetUserStateEventHandler(info2);
298
299 delete info1;
300 info1 = nullptr;
301 }
302
303 HWTEST_F(LNNNetworkManagerMockTest, NET_LOCK_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
304 {
305 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
306 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
307 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
308 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
309 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
310 ;
311 LnnEventBasicInfo info;
312 (void)NetLockStateEventHandler(nullptr);
313
314 info.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
315 (void)NetLockStateEventHandler(&info);
316 }
317
318 HWTEST_F(LNNNetworkManagerMockTest, NET_OOB_STATE_EVENTHANDLER_TEST_001, TestSize.Level1)
319 {
320 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
321 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
322 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
323 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
324 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
325 (void)NetOOBEStateEventHandler(nullptr);
326 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
327 EXPECT_TRUE(info1 != nullptr);
328 info1->basic.event = LNN_EVENT_OOBE_STATE_CHANGED;
329 info1->status = SOFTBUS_OOBE_RUNNING;
330 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
331 (void)NetOOBEStateEventHandler(info2);
332
333 info1->status = SOFTBUS_OOBE_END;
334 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
335 (void)NetOOBEStateEventHandler(info2);
336
337 info1->status = SOFTBUS_OOBE_UNKNOWN;
338 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
339 (void)NetOOBEStateEventHandler(info2);
340
341 delete info1;
342 info1 = nullptr;
343 }
344
345 HWTEST_F(LNNNetworkManagerMockTest, ON_DEVICE_BOUND_TEST_001, TestSize.Level1)
346 {
347 const char *udid = nullptr;
348 const char *groupInfo = nullptr;
349 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
350 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
351 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
352 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
353 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
354 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
355 EXPECT_CALL(managerMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
356 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
357 EXPECT_CALL(managerMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_ERR));
358 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
359 EXPECT_CALL(managerMock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
360 EXPECT_NO_FATAL_FAILURE(OnDeviceBound(udid, groupInfo));
361 }
362
363 HWTEST_F(LNNNetworkManagerMockTest, CREAT_NETIFMGR_TEST_001, TestSize.Level1)
364 {
365 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
366 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
367 const char *netIfName = "Softbus";
368 LnnNetIfMgr *ret = CreateNetifMgr(netIfName);
369 EXPECT_NE(ret, nullptr);
370 if (ret != nullptr) {
371 SoftBusFree(ret);
372 }
373 ret = CreateNetifMgr(nullptr);
374 EXPECT_EQ(ret, nullptr);
375 if (ret != nullptr) {
376 SoftBusFree(ret);
377 }
378 }
379
380 HWTEST_F(LNNNetworkManagerMockTest, CREAT_NETIFMGR_TEST_002, TestSize.Level1)
381 {
382 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
383 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
384 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
385 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
386 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
387 info1->status = SOFTBUS_USER_UNLOCK;
388 const LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
389 (void)NetLockStateEventHandler(info2);
390 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
391 info1->status = SOFTBUS_SCREEN_UNLOCK;
392 const LnnEventBasicInfo *info3 = reinterpret_cast<LnnEventBasicInfo *>(info1);
393 (void)NetLockStateEventHandler(info3);
394 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
395 info1->status = SOFTBUS_SCREEN_LOCK;
396 const LnnEventBasicInfo *info4 = reinterpret_cast<LnnEventBasicInfo *>(info1);
397 (void)NetLockStateEventHandler(info4);
398 info1->basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED;
399 info1->status = SOFTBUS_SCREEN_LOCK_UNKNOWN;
400 const LnnEventBasicInfo *info5 = reinterpret_cast<LnnEventBasicInfo *>(info1);
401 (void)NetLockStateEventHandler(info5);
402 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
403 LnnNetIfMgr *ret = CreateNetifMgr(nullptr);
404 EXPECT_EQ(ret, nullptr);
405
406 delete info1;
407 info1 = nullptr;
408 }
409
410 HWTEST_F(LNNNetworkManagerMockTest, SAVE_BRNETWORK_DEVICE_TEST_001, TestSize.Level1)
411 {
412 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
413 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
414 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
415 (void)SaveBrNetworkDevices();
416 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
417 (void)SaveBrNetworkDevices();
418 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
419 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
420 (void)SaveBrNetworkDevices();
421 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
422 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
423 (void)SaveBrNetworkDevices();
424 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
425 (void)SaveBrNetworkDevices();
426 }
427
428 HWTEST_F(LNNNetworkManagerMockTest, NET_ACCOUNT_STATECHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
429 {
430 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
431 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
432 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
433 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
434 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
435 (void)NetAccountStateChangeEventHandler(nullptr);
436 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
437 EXPECT_TRUE(info1 != nullptr);
438 info1->basic.event = LNN_EVENT_ACCOUNT_CHANGED;
439 info1->status = SOFTBUS_ACCOUNT_LOG_IN;
440 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
441 (void)NetAccountStateChangeEventHandler(info2);
442
443 info1->status = SOFTBUS_ACCOUNT_LOG_OUT;
444 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
445 (void)NetAccountStateChangeEventHandler(info2);
446
447 info1->status = SOFTBUS_ACCOUNT_UNKNOWN;
448 info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
449 (void)NetAccountStateChangeEventHandler(info2);
450
451 delete info1;
452 info1 = nullptr;
453 }
454
455 HWTEST_F(LNNNetworkManagerMockTest, GET_ALL_PROTOCOLS_TEST_001, TestSize.Level1)
456 {
457 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
458 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
459 const char *groupId = "groupId";
460 int32_t groupType = AUTH_IDENTICAL_ACCOUNT_GROUP;
461 EXPECT_CALL(managerMock, LnnUpdateOhosAccount).WillRepeatedly(Return());
462 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(true));
463 EXPECT_CALL(managerMock, LnnNotifyAccountStateChangeEvent).WillRepeatedly(Return());
464 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
465 (void)OnGroupCreated(groupId, groupType);
466 groupType = AUTH_PEER_TO_PEER_GROUP;
467 EXPECT_CALL(managerMock, LnnUpdateOhosAccount).WillRepeatedly(Return());
468 EXPECT_CALL(managerMock, LnnNotifyAccountStateChangeEvent).WillRepeatedly(Return());
469 (void)OnGroupCreated(groupId, groupType);
470 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
471 void *data = nullptr;
472 VisitNextChoice ret = GetAllProtocols(nullptr, data);
473 EXPECT_TRUE(ret == CHOICE_FINISH_VISITING);
474 LnnProtocolManager manager;
475 data = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnProtocolManager)));
476 EXPECT_TRUE(data != nullptr);
477 ret = GetAllProtocols(&manager, data);
478 EXPECT_TRUE(ret == CHOICE_VISIT_NEXT);
479 SoftBusFree(data);
480 }
481
482 HWTEST_F(LNNNetworkManagerMockTest, NIGHT_MODE_CHANGE_EVENTHANDLER_TEST_001, TestSize.Level1)
483 {
484 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
485 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
486 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
487 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
488 EXPECT_CALL(managerMock, DfxRecordTriggerTime(_, _)).WillRepeatedly(Return());
489 (void)NightModeChangeEventHandler(nullptr);
490 LnnEventBasicInfo info;
491 info.event = LNN_EVENT_NIGHT_MODE_CHANGED;
492 (void)NightModeChangeEventHandler(&info);
493
494 EXPECT_CALL(managerMock, LnnRequestLeaveByAddrType).WillRepeatedly(Return(SOFTBUS_OK));
495 LnnMonitorHbStateChangedEvent *info1 = new LnnMonitorHbStateChangedEvent();
496 EXPECT_NE(info1, nullptr);
497 info1->basic.event = LNN_EVENT_NIGHT_MODE_CHANGED;
498 info1->status = SOFTBUS_NIGHT_MODE_ON;
499 LnnEventBasicInfo *info2 = reinterpret_cast<LnnEventBasicInfo *>(info1);
500 (void)NightModeChangeEventHandler(info2);
501
502 delete info1;
503 info1 = nullptr;
504 }
505
506 HWTEST_F(LNNNetworkManagerMockTest, REGIST_NETIFMGR_TEST_001, TestSize.Level1)
507 {
508 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
509 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
510
511 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
512 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
513 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
514 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
515 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
516 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
517 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL));
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_OK));
529 (void)RestartCoapDiscovery();
530
531 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
532 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
533 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
534 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
535 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
536 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
537 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL));
538 EXPECT_CALL(managerMock, LnnStopDiscovery).WillRepeatedly(Return());
539 EXPECT_CALL(managerMock, LnnStartDiscovery).WillRepeatedly(Return(SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL));
540 (void)RestartCoapDiscovery();
541
542 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
543 LnnNetIfNameType type = LNN_MAX_NUM_TYPE;
544 LnnNetIfManagerBuilder builder = nullptr;
545 int32_t ret = RegistNetIfMgr(type, builder);
546 EXPECT_TRUE(ret != SOFTBUS_OK);
547
548 type = LNN_MAX_NUM_TYPE;
549 const char *ifName = "Softbus";
550 LnnNetIfMgr *res = NetifMgrFactory(type, ifName);
551 EXPECT_TRUE(res == nullptr);
552 }
553
554 HWTEST_F(LNNNetworkManagerMockTest, CONVERT_TO_NET_IF_TYPE_001, TestSize.Level1)
555 {
556 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
557 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
558 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
559 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
560 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
561 (void)RestartCoapDiscovery();
562 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
563 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
564 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
565 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
566 (void)RestartCoapDiscovery();
567 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
568 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
569 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
570 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
571 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
572 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
573 (void)RestartCoapDiscovery();
574 EXPECT_CALL(ledgerMock, IsActiveOsAccountUnlocked).WillRepeatedly(Return(SOFTBUS_OK));
575 EXPECT_CALL(managerMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
576 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
577 EXPECT_CALL(ledgerMock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
578 EXPECT_CALL(managerMock, DiscLinkStatusChanged).WillRepeatedly(Return());
579 EXPECT_CALL(managerMock, LnnStopPublish).WillRepeatedly(Return());
580 EXPECT_CALL(managerMock, LnnStartPublish).WillRepeatedly(Return(SOFTBUS_OK));
581 (void)RestartCoapDiscovery();
582 LnnNetIfNameType type = LNN_MAX_NUM_TYPE;
583 LnnNetIfType lnnNetIfType = ConvertToNetIfType(type);
584 EXPECT_EQ(lnnNetIfType, 0);
585 type = LNN_ETH_TYPE;
586 lnnNetIfType = ConvertToNetIfType(type);
587 EXPECT_NE(lnnNetIfType, 0);
588 type = LNN_WLAN_TYPE;
589 lnnNetIfType = ConvertToNetIfType(type);
590 EXPECT_NE(lnnNetIfType, 0);
591 }
592
593 HWTEST_F(LNNNetworkManagerMockTest, LNN_REGISTER_EVENT_001, TestSize.Level1)
594 {
595 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
596 const char *groupId = "groupId";
597 int32_t groupType = AUTH_IDENTICAL_ACCOUNT_GROUP;
598 EXPECT_CALL(managerMock, LnnOnOhosAccountLogout).WillRepeatedly(Return());
599 (void)OnGroupDeleted(groupId, groupType);
600 groupType = AUTH_PEER_TO_PEER_GROUP;
601 EXPECT_CALL(managerMock, LnnOnOhosAccountLogout).WillRepeatedly(Return());
602 (void)OnGroupDeleted(groupId, groupType);
603 int32_t ret = SOFTBUS_OK;
604 EXPECT_CALL(managerMock, LnnRegisterEventHandler).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_INVALID_PARAM));
610 ret = LnnRegisterEvent();
611 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
612 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
613 .WillOnce(Return(SOFTBUS_OK))
614 .WillOnce(Return(SOFTBUS_OK))
615 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
616 ret = LnnRegisterEvent();
617 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
618 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
619 .WillOnce(Return(SOFTBUS_OK))
620 .WillOnce(Return(SOFTBUS_OK))
621 .WillOnce(Return(SOFTBUS_OK))
622 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
623 ret = LnnRegisterEvent();
624 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
625 EXPECT_CALL(managerMock, LnnRegisterEventHandler)
626 .WillOnce(Return(SOFTBUS_OK))
627 .WillOnce(Return(SOFTBUS_OK))
628 .WillOnce(Return(SOFTBUS_OK))
629 .WillOnce(Return(SOFTBUS_OK))
630 .WillOnce(Return(SOFTBUS_INVALID_PARAM));
631 ret = LnnRegisterEvent();
632 EXPECT_EQ(ret, SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR);
633 EXPECT_CALL(managerMock, LnnRegisterEventHandler).WillRepeatedly(Return(SOFTBUS_OK));
634 ret = LnnRegisterEvent();
635 EXPECT_EQ(ret, SOFTBUS_OK);
636 }
637
638 HWTEST_F(LNNNetworkManagerMockTest, NetRootDeviceLeaveLnnTest_001, TestSize.Level1)
639 {
640 int ret = 0;
641 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
642 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
643 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
644 ret = NetRootDeviceLeaveLnn();
645 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR);
646
647 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillOnce(Return(SOFTBUS_OK));
648 ret = NetRootDeviceLeaveLnn();
649 EXPECT_EQ(ret, SOFTBUS_NO_ONLINE_DEVICE);
650 }
651
652 HWTEST_F(LNNNetworkManagerMockTest, NetDeviceRootStateEventHandler_001, TestSize.Level1)
653 {
654 LnnDeviceRootStateChangeEvent *event =
655 reinterpret_cast<LnnDeviceRootStateChangeEvent*>(SoftBusCalloc(sizeof(LnnDeviceRootStateChangeEvent)));
656 event->basic.event = LNN_EVENT_TYPE_MAX;
657 event->status = SOFTBUS_DEVICE_IS_ROOT;
658
659 NiceMock<LnnNetworkManagerInterfaceMock> managerMock;
660 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
661 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
662
663 NetDeviceRootStateEventHandler(NULL);
664
665 NetDeviceRootStateEventHandler(&event->basic);
666
667 event->basic.event = LNN_EVENT_DEVICE_ROOT_STATE_CHANGED;
668 NetDeviceRootStateEventHandler(&event->basic);
669
670 event->status = SOFTBUS_DEVICE_NOT_ROOT;
671 NetDeviceRootStateEventHandler(&event->basic);
672
673 EXPECT_EQ(event->status, 0);
674 }
675 } // namespace OHOS
676