1 /*
2 * Copyright (c) 2024 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 <cstdlib>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <cstdbool>
20 #include <cstdint>
21
22 #include "anonymizer.h"
23 #include "bus_center_event.h"
24 #include "bus_center_event_deps_mock.h"
25 #include "bus_center_decision_center.h"
26 #include "bus_center_event.h"
27 #include "bus_center_manager.h"
28 #include "lnn_bus_center_ipc.h"
29 #include "lnn_distributed_net_ledger.h"
30 #include "lnn_log.h"
31 #include "lnn_network_id.h"
32 #include "lnn_p2p_info.h"
33 #include "lnn_connection_addr_utils.h"
34 #include "message_handler.h"
35 #include "softbus_adapter_crypto.h"
36 #include "softbus_adapter_mem.h"
37 #include "softbus_adapter_thread.h"
38 #include "softbus_def.h"
39 #include "softbus_common.h"
40 #include "softbus_error_code.h"
41 #include "softbus_bus_center.h"
42
43 using namespace testing;
44 using namespace testing::ext;
45 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
46
47 typedef enum {
48 NOTIFY_ONLINE_STATE_CHANGED = 0,
49 NOTIFY_NODE_BASIC_INFO_CHANGED,
50 NOTIFY_NODE_STATUS_CHANGED,
51 NOTIFY_NETWORKID_UPDATE,
52 NOTIFY_LOCAL_NETWORKID_UPDATE,
53 } NotifyType;
54
55 namespace OHOS {
56
57 class BusCenterEventTest : public testing::Test {
58 protected:
59 static void SetUpTestCase(void);
60 static void TearDownTestCase(void);
61 void SetUp();
62 void TearDown();
63 };
64
SetUpTestCase(void)65 void BusCenterEventTest::SetUpTestCase(void)
66 {
67 }
68
TearDownTestCase(void)69 void BusCenterEventTest::TearDownTestCase(void)
70 {
71 }
72
SetUp(void)73 void BusCenterEventTest::SetUp(void)
74 {
75 }
76
TearDown(void)77 void BusCenterEventTest::TearDown(void)
78 {
79 }
80
OnNetworkStateChange(const LnnEventBasicInfo * info)81 static void OnNetworkStateChange(const LnnEventBasicInfo *info)
82 {
83 if (info != nullptr) {
84 GTEST_LOG_(INFO) << "Network state changed, event is " << info->event;
85 } else {
86 GTEST_LOG_(INFO) << "Network state changed, but info is null.";
87 }
88 }
89
90 /*
91 * @tc.name: BusCenterEventTest001
92 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_INVALID_PARAM.
93 * @tc.type: FUNC
94 * @tc.require: 1
95 */
96 HWTEST_F(BusCenterEventTest, BusCenterEventTest001, TestSize.Level1)
97 {
98 bool isOnline = false;
99 NodeBasicInfo *info = nullptr;
100 LnnEventType event = LNN_EVENT_TYPE_MAX;
101 LnnEventHandler handler = nullptr;
102 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
103 EXPECT_CALL(BusCenterEventMock, SetDefaultQdisc()).WillRepeatedly(Return(SOFTBUS_OK));
104 EXPECT_CALL(BusCenterEventMock, LnnGetAllOnlineNodeNum(_)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
105 LnnNotifyOnlineState(isOnline, info);
106 LnnNotifyMigrate(isOnline, info);
107 NodeBasicInfo info2 = {
108 .networkId = "testNetworkId",
109 .deviceName = "testDeviceName",
110 .deviceTypeId = 1,
111 };
112 EXPECT_NE(&info2, nullptr);
113 EXPECT_CALL(BusCenterEventMock, LnnGetAllOnlineNodeNum(_)).WillRepeatedly(Return(SOFTBUS_OK));
114 LnnNotifyOnlineState(isOnline, &info2);
115 isOnline = true;
116 LnnNotifyOnlineState(isOnline, &info2);
117 int32_t ret = LnnRegisterEventHandler(event, handler);
118 LnnUnregisterEventHandler(event, handler);
119 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
120 }
121
122 /*
123 * @tc.name: BusCenterEventTest002
124 * @tc.desc: Verify the LnnNotifyBasicInfoChanged function return value equal SOFTBUS_INVALID_PARAM.
125 * @tc.type: FUNC
126 * @tc.require: 1
127 */
128 HWTEST_F(BusCenterEventTest, BusCenterEventTest002, TestSize.Level1)
129 {
130 NodeBasicInfo *info = nullptr;
131 NodeBasicInfoType type = TYPE_DEVICE_NAME;
132 LnnEventType event = LNN_EVENT_TYPE_MAX;
133 LnnEventHandler handler = nullptr;
134 LnnNotifyBasicInfoChanged(info, type);
135 NodeBasicInfo info2 = {
136 .networkId = "testNetworkId",
137 .deviceName = "testDeviceName",
138 .deviceTypeId = 1,
139 };
140 EXPECT_NE(&info2, nullptr);
141 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
142 EXPECT_CALL(BusCenterEventMock, AnonymizeDeviceName(_, _)).WillOnce(Return());
143 EXPECT_CALL(BusCenterEventMock, AnonymizeFree(_)).WillOnce(Return());
144 LnnNotifyBasicInfoChanged(&info2, type);
145 int32_t ret = LnnRegisterEventHandler(event, handler);
146 LnnUnregisterEventHandler(event, handler);
147 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
148 }
149
150 /*
151 * @tc.name: BusCenterEventTest003
152 * @tc.desc: Verify the LnnNotifyLeaveResult function return value equal SOFTBUS_INVALID_PARAM.
153 * @tc.type: FUNC
154 * @tc.require: 1
155 */
156 HWTEST_F(BusCenterEventTest, BusCenterEventTest003, TestSize.Level1)
157 {
158 const char *networkId = nullptr;
159 int32_t retCode = SOFTBUS_INVALID_PARAM;
160 ConnectionAddr *addr = nullptr;
161 LnnEventType event = LNN_EVENT_TYPE_MAX;
162 LnnEventHandler handler = nullptr;
163
164 LnnNotifyJoinResult(addr, networkId, retCode);
165 LnnNotifyLeaveResult(networkId, retCode);
166 int32_t ret = LnnRegisterEventHandler(event, handler);
167 LnnUnregisterEventHandler(event, handler);
168 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
169 }
170
171 /*
172 * @tc.name: BusCenterEventTest004
173 * @tc.desc: Verify the LnnNotifyTimeSyncResult function return value equal SOFTBUS_LOCK_ERR.
174 * @tc.type: FUNC
175 * @tc.require: 1
176 */
177 HWTEST_F(BusCenterEventTest, BusCenterEventTest004, TestSize.Level1)
178 {
179 const char *pkgNameTest = "testPkgName";
180 const char *pkgName = nullptr;
181 int32_t pid = 1000;
182 const TimeSyncResultInfo *info = nullptr;
183 int32_t retCode = SOFTBUS_INVALID_PARAM;
184 LnnEventType event = LNN_EVENT_NETWORK_STATE_CHANGED;
185 LnnEventHandler handler = OnNetworkStateChange;
186
187 LnnNotifyTimeSyncResult(pkgName, pid, info, retCode);
188 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
189 EXPECT_CALL(BusCenterEventMock, LnnIpcNotifyTimeSyncResult(_, _, _, _, _)).WillOnce(Return(SOFTBUS_OK));
190 TimeSyncResultInfo info2;
191 (void)memset_s(&info2, sizeof(TimeSyncResultInfo), 0, sizeof(TimeSyncResultInfo));
192 (void)strcpy_s(info2.target.targetNetworkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
193 LnnNotifyTimeSyncResult(pkgNameTest, pid, &info2, retCode);
194 int32_t ret = LnnRegisterEventHandler(event, handler);
195 LnnUnregisterEventHandler(event, handler);
196 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
197 }
198
199 /*
200 * @tc.name: BusCenterEventTest006
201 * @tc.desc: Verify the LnnNotifyScreenStateChangeEvent function return value equal SOFTBUS_INVALID_PARAM.
202 * @tc.type: FUNC
203 * @tc.require: 1
204 */
205 HWTEST_F(BusCenterEventTest, BusCenterEventTest006, TestSize.Level1)
206 {
207 LnnEventType event = LNN_EVENT_TYPE_MAX;
208 LnnEventHandler handler = nullptr;
209 SoftBusScreenState mockState = (SoftBusScreenState)(SOFTBUS_SCREEN_UNKNOWN + 1);
210
211 LnnNotifyScreenStateChangeEvent(mockState);
212 mockState = SOFTBUS_SCREEN_ON;
213 LnnNotifyScreenStateChangeEvent(mockState);
214 int32_t ret = LnnRegisterEventHandler(event, handler);
215 LnnUnregisterEventHandler(event, handler);
216 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
217 }
218
219 /*
220 * @tc.name: BusCenterEventTest008
221 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_LOCK_ERR.
222 * @tc.type: FUNC
223 * @tc.require: 1
224 */
225 HWTEST_F(BusCenterEventTest, BusCenterEventTest008, TestSize.Level1)
226 {
227 LnnEventType event = LNN_EVENT_NETWORK_STATE_CHANGED;
228 LnnEventHandler handler = OnNetworkStateChange;
229 SoftBusScreenLockState mockState = (SoftBusScreenLockState)(SOFTBUS_SCREEN_LOCK_UNKNOWN + 1);
230
231 LnnNotifyScreenLockStateChangeEvent(mockState);
232 mockState = SOFTBUS_USER_UNLOCK;
233 LnnNotifyScreenLockStateChangeEvent(mockState);
234 int32_t ret = LnnRegisterEventHandler(event, handler);
235 LnnUnregisterEventHandler(event, handler);
236 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
237 }
238
239 /*
240 * @tc.name: BusCenterEventTest009
241 * @tc.desc: Verify the LnnInitBusCenterEvent function return value equal SOFTBUS_LOOPER_ERR.
242 * @tc.type: FUNC
243 * @tc.require: 1
244 */
245 HWTEST_F(BusCenterEventTest, BusCenterEventTest009, TestSize.Level1)
246 {
247 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
248 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
249 SoftBusAccountState mockState = (SoftBusAccountState)(SOFTBUS_ACCOUNT_UNKNOWN + 1);
250
251 LnnNotifyAccountStateChangeEvent(mockState);
252 mockState = SOFTBUS_ACCOUNT_LOG_IN;
253 LnnNotifyAccountStateChangeEvent(mockState);
254 int32_t ret = LnnInitBusCenterEvent();
255 LnnDeinitBusCenterEvent();
256 EXPECT_NE(ret, SOFTBUS_OK);
257 }
258
259 /*
260 * @tc.name: BusCenterEventTest010
261 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_INVALID_PARAM.
262 * @tc.type: FUNC
263 * @tc.require: 1
264 */
265 HWTEST_F(BusCenterEventTest, BusCenterEventTest010, TestSize.Level1)
266 {
267 LnnEventType event = LNN_EVENT_TYPE_MAX;
268 LnnEventHandler handler = nullptr;
269 SoftBusUserSwitchState mockState = (SoftBusUserSwitchState)(SOFTBUS_USER_SWITCH_UNKNOWN + 1);
270
271 LnnNotifyUserSwitchEvent(mockState);
272 mockState = SOFTBUS_USER_SWITCHED;
273 LnnNotifyUserSwitchEvent(mockState);
274 int32_t ret = LnnRegisterEventHandler(event, handler);
275 LnnUnregisterEventHandler(event, handler);
276 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
277 }
278
279 /*
280 * @tc.name: BusCenterEventTest012
281 * @tc.desc: Verify the LnnNotifyUserStateChangeEvent function return value equal SOFTBUS_LOCK_ERR.
282 * @tc.type: FUNC
283 * @tc.require: 1
284 */
285 HWTEST_F(BusCenterEventTest, BusCenterEventTest012, TestSize.Level1)
286 {
287 LnnEventType event = LNN_EVENT_NETWORK_STATE_CHANGED;
288 LnnEventHandler handler = OnNetworkStateChange;
289 SoftBusUserState mockState = (SoftBusUserState)(SOFTBUS_USER_UNKNOWN + 1);
290
291 LnnNotifyUserStateChangeEvent(mockState);
292 mockState = SOFTBUS_USER_BACKGROUND;
293 LnnNotifyUserStateChangeEvent(mockState);
294 int32_t ret = LnnRegisterEventHandler(event, handler);
295 LnnUnregisterEventHandler(event, handler);
296 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
297 }
298
299 /*
300 * @tc.name: BusCenterEventTest014
301 * @tc.desc: Verify the LnnNotifyOOBEStateChangeEvent function return value equal SOFTBUS_INVALID_PARAM.
302 * @tc.type: FUNC
303 * @tc.require: 1
304 */
305 HWTEST_F(BusCenterEventTest, BusCenterEventTest014, TestSize.Level1)
306 {
307 LnnEventType event = LNN_EVENT_TYPE_MAX;
308 LnnEventHandler handler = nullptr;
309 SoftBusOOBEState mockState = (SoftBusOOBEState)(SOFTBUS_OOBE_UNKNOWN + 1);
310
311 LnnNotifyOOBEStateChangeEvent(mockState);
312 mockState = SOFTBUS_OOBE_END;
313 LnnNotifyOOBEStateChangeEvent(mockState);
314 int32_t ret = LnnRegisterEventHandler(event, handler);
315 LnnUnregisterEventHandler(event, handler);
316 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
317 }
318
319 /*
320 * @tc.name: BusCenterEventTest015
321 * @tc.desc: Verify the LnnNotifyBtAclStateChangeEvent function return value equal SOFTBUS_INVALID_PARAM.
322 * @tc.type: FUNC
323 * @tc.require: 1
324 */
325 HWTEST_F(BusCenterEventTest, BusCenterEventTest015, TestSize.Level1)
326 {
327 const char *btMac = nullptr;
328 const char *btMacTest = "testBtMac";
329 LnnEventType event = LNN_EVENT_TYPE_MAX;
330 LnnEventHandler handler = nullptr;
331 SoftBusBtAclState state = SOFTBUS_BR_ACL_CONNECTED;
332
333 LnnNotifyBtAclStateChangeEvent(btMac, state);
334 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
335 EXPECT_CALL(BusCenterEventMock, Anonymize(_, _)).WillOnce(Return());
336 EXPECT_CALL(BusCenterEventMock, AnonymizeFree(_)).WillOnce(Return());
337 LnnNotifyBtAclStateChangeEvent(btMacTest, state);
338 int32_t ret = LnnRegisterEventHandler(event, handler);
339 LnnUnregisterEventHandler(event, handler);
340 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
341 }
342
343 /*
344 * @tc.name: BusCenterEventTest016
345 * @tc.desc: Verify the LnnNotifyAddressChangedEvent function return value equal SOFTBUS_LOOPER_ERR.
346 * @tc.type: FUNC
347 * @tc.require: 1
348 */
349 HWTEST_F(BusCenterEventTest, BusCenterEventTest016, TestSize.Level1)
350 {
351 const char *ifNameTest = "testIfName";
352 const char *ifName = nullptr;
353
354 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
355 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
356 LnnNotifyAddressChangedEvent(ifName);
357 LnnNotifyAddressChangedEvent(ifNameTest);
358 int32_t ret = LnnInitBusCenterEvent();
359 LnnDeinitBusCenterEvent();
360 EXPECT_NE(ret, SOFTBUS_OK);
361 }
362
363 /*
364 * @tc.name: BusCenterEventTest017
365 * @tc.desc: Verify the LnnNotifyNodeAddressChanged function return value equal SOFTBUS_INVALID_PARAM.
366 * @tc.type: FUNC
367 * @tc.require: 1
368 */
369 HWTEST_F(BusCenterEventTest, BusCenterEventTest017, TestSize.Level1)
370 {
371 const char *addr = nullptr;
372 const char *networkId = "testNetworkId";
373 bool isLocal = false;
374 const char *addrTest = "testAddr";
375 LnnEventType event = LNN_EVENT_TYPE_MAX;
376 LnnEventHandler handler = nullptr;
377
378 LnnNotifyNodeAddressChanged(addr, networkId, isLocal);
379 LnnNotifyNodeAddressChanged(addrTest, networkId, isLocal);
380 int32_t ret = LnnRegisterEventHandler(event, handler);
381 LnnUnregisterEventHandler(event, handler);
382 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
383 }
384
385 /*
386 * @tc.name: BusCenterEventTest018
387 * @tc.desc: Verify the LnnNotifyNetworkStateChanged function return value equal SOFTBUS_LOCK_ERR.
388 * @tc.type: FUNC
389 * @tc.require: 1
390 */
391 HWTEST_F(BusCenterEventTest, BusCenterEventTest018, TestSize.Level1)
392 {
393 LnnEventType event = LNN_EVENT_NETWORK_STATE_CHANGED;
394 LnnEventHandler handler = OnNetworkStateChange;
395 SoftBusNetworkState mockState = (SoftBusNetworkState)(SOFTBUS_NETWORKD_UNKNOWN + 1);
396
397 LnnNotifyNetworkStateChanged(mockState);
398 mockState = SOFTBUS_WIFI_NETWORKD_ENABLE;
399 LnnNotifyNetworkStateChanged(mockState);
400 int32_t ret = LnnRegisterEventHandler(event, handler);
401 LnnUnregisterEventHandler(event, handler);
402 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
403 }
404
405 /*
406 * @tc.name: BusCenterEventTest019
407 * @tc.desc: Verify the LnnNotifySingleOffLineEvent function return value equal SOFTBUS_INVALID_PARAM.
408 * @tc.type: FUNC
409 * @tc.require: 1
410 */
411 HWTEST_F(BusCenterEventTest, BusCenterEventTest019, TestSize.Level1)
412 {
413 const ConnectionAddr *addr = nullptr;
414 LnnEventType event = LNN_EVENT_TYPE_MAX;
415 LnnEventHandler handler = nullptr;
416 NodeBasicInfo info = {
417 .networkId = "testNetworkId",
418 .deviceName = "testDeviceName",
419 .deviceTypeId = 1,
420 };
421
422 LnnNotifySingleOffLineEvent(addr, &info);
423 ConnectionAddr addr2;
424 (void)memset_s(&addr2, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
425 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
426 EXPECT_CALL(BusCenterEventMock, LnnGetRemoteNodeInfoById(_, _, _)).WillOnce(Return(SOFTBUS_OK));
427 EXPECT_CALL(BusCenterEventMock, LnnHasDiscoveryType(_, _)).WillOnce(Return(true));
428 EXPECT_CALL(BusCenterEventMock, LnnConvAddrTypeToDiscType(_)).WillOnce(Return(DISCOVERY_TYPE_WIFI));
429 LnnNotifySingleOffLineEvent(&addr2, &info);
430 int32_t ret = LnnRegisterEventHandler(event, handler);
431 LnnUnregisterEventHandler(event, handler);
432 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
433 }
434
435 /*
436 * @tc.name: BusCenterEventTest020
437 * @tc.desc: Verify the LnnNotifyLpReportEvent function return value equal SOFTBUS_LOOPER_ERR.
438 * @tc.type: FUNC
439 * @tc.require: 1
440 */
441 HWTEST_F(BusCenterEventTest, BusCenterEventTest020, TestSize.Level1)
442 {
443 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
444 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
445 SoftBusLpEventType type = (SoftBusLpEventType)(SOFTBUS_LP_EVENT_UNKNOWN + 1);
446 LnnNotifyLpReportEvent(type);
447 type = SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY;
448 LnnNotifyLpReportEvent(type);
449 int32_t ret = LnnInitBusCenterEvent();
450 LnnDeinitBusCenterEvent();
451 EXPECT_NE(ret, SOFTBUS_OK);
452 }
453
454 /*
455 * @tc.name: BusCenterEventTest021
456 * @tc.desc: Verify the LnnNotifyNetworkIdChangeEvent function return value equal SOFTBUS_INVALID_PARAM.
457 * @tc.type: FUNC
458 * @tc.require: 1
459 */
460 HWTEST_F(BusCenterEventTest, BusCenterEventTest021, TestSize.Level1)
461 {
462 LnnEventType event = LNN_EVENT_TYPE_MAX;
463 LnnEventHandler handler = nullptr;
464 const char *networkId = nullptr;
465 const char *networkIdTest = "testNetworkId";
466 LnnNotifyNetworkIdChangeEvent(networkId);
467 LnnNotifyNetworkIdChangeEvent(networkIdTest);
468 int32_t ret = LnnRegisterEventHandler(event, handler);
469 LnnUnregisterEventHandler(event, handler);
470 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
471 }
472
473 /*
474 * @tc.name: BusCenterEventTest022
475 * @tc.desc: Verify the LnnInitBusCenterEvent function return value equal SOFTBUS_LOOPER_ERR.
476 * @tc.type: FUNC
477 * @tc.require: 1
478 */
479 HWTEST_F(BusCenterEventTest, BusCenterEventTest022, TestSize.Level1)
480 {
481 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
482 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
483 int32_t ret = LnnInitBusCenterEvent();
484 LnnDeinitBusCenterEvent();
485 EXPECT_NE(ret, SOFTBUS_OK);
486 }
487
488 /*
489 * @tc.name: BusCenterEventTest023
490 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_LOCK_ERR.
491 * @tc.type: FUNC
492 * @tc.require: 1
493 */
494 HWTEST_F(BusCenterEventTest, BusCenterEventTest023, TestSize.Level1)
495 {
496 LnnEventType event = LNN_EVENT_TYPE_MAX;
497 LnnEventHandler handler = nullptr;
498
499 int32_t ret = LnnRegisterEventHandler(event, handler);
500 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
501 LnnEventType event2 = LNN_EVENT_NETWORK_STATE_CHANGED;
502 LnnEventHandler handler2 = OnNetworkStateChange;
503 ret = LnnRegisterEventHandler(event2, handler2);
504 LnnUnregisterEventHandler(event2, handler2);
505 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
506 }
507
508 /*
509 * @tc.name: BusCenterEventTest024
510 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_INVALID_PARAM.
511 * @tc.type: FUNC
512 * @tc.require: 1
513 */
514 HWTEST_F(BusCenterEventTest, BusCenterEventTest024, TestSize.Level1)
515 {
516 LnnEventType event = LNN_EVENT_TYPE_MAX;
517 LnnEventHandler handler = nullptr;
518
519 int32_t ret = LnnRegisterEventHandler(event, handler);
520 LnnUnregisterEventHandler(event, handler);
521 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
522 }
523
524 /*
525 * @tc.name: BusCenterEventTest005
526 * @tc.desc: Verify the LnnInitBusCenterEvent function return value equal SOFTBUS_LOOPER_ERR.
527 * @tc.type: FUNC
528 * @tc.require: 1
529 */
530 HWTEST_F(BusCenterEventTest, BusCenterEventTest005, TestSize.Level1)
531 {
532 SoftBusWifiState *mockState = nullptr;
533 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
534 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
535 LnnNotifyWlanStateChangeEvent(nullptr);
536 mockState = (SoftBusWifiState *)SoftBusCalloc(sizeof(SoftBusWifiState));
537 ASSERT_TRUE(mockState != nullptr);
538 *mockState = (SoftBusWifiState)(SOFTBUS_WIFI_UNKNOWN + 1);
539 int32_t ret = LnnInitBusCenterEvent();
540 LnnDeinitBusCenterEvent();
541 EXPECT_NE(ret, SOFTBUS_OK);
542 SoftBusFree(mockState);
543 }
544
545 /*
546 * @tc.name: BusCenterEventTest007
547 * @tc.desc: Verify the LnnRegisterEventHandler function return value equal SOFTBUS_INVALID_PARAM.
548 * @tc.type: FUNC
549 * @tc.require: 1
550 */
551 HWTEST_F(BusCenterEventTest, BusCenterEventTest007, TestSize.Level1)
552 {
553 LnnEventType event = LNN_EVENT_TYPE_MAX;
554 LnnEventHandler handler = nullptr;
555 SoftBusBtState *mockState = (SoftBusBtState *)SoftBusCalloc(sizeof(SoftBusWifiState));
556 ASSERT_TRUE(mockState != nullptr);
557 *mockState = (SoftBusBtState)(SOFTBUS_BT_UNKNOWN + 1);
558 int32_t ret = LnnRegisterEventHandler(event, handler);
559 LnnUnregisterEventHandler(event, handler);
560 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
561 SoftBusFree(mockState);
562 }
563
564 /*
565 * @tc.name: BusCenterEventTest013
566 * @tc.desc: Verify the LnnInitBusCenterEvent function return value equal SOFTBUS_LOOPER_ERR.
567 * @tc.type: FUNC
568 * @tc.require: 1
569 */
570 HWTEST_F(BusCenterEventTest, BusCenterEventTest013, TestSize.Level1)
571 {
572 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
573 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillOnce(Return(nullptr));
574 SoftBusNightModeState *mockState = (SoftBusNightModeState *)SoftBusCalloc(sizeof(SoftBusNightModeState));
575 ASSERT_TRUE(mockState != nullptr);
576 *mockState = (SoftBusNightModeState)(SOFTBUS_NIGHT_MODE_UNKNOWN + 1);
577 int32_t ret = LnnInitBusCenterEvent();
578 LnnDeinitBusCenterEvent();
579 EXPECT_NE(ret, SOFTBUS_OK);
580 SoftBusFree(mockState);
581 }
582
583 /*
584 * @tc.name: BusCenterEventTest011
585 * @tc.desc: Authenticate the LnnRegisterEventHandler function return value equal SOFTBUS_INVALID_PARAM.
586 * @tc.type: FUNC
587 * @tc.require: 1
588 */
589 HWTEST_F(BusCenterEventTest, BusCenterEventTest011, TestSize.Level1)
590 {
591 LnnEventType event = LNN_EVENT_TYPE_MAX;
592 LnnEventHandler handler = nullptr;
593 SoftBusDifferentAccountState *mockState =
594 (SoftBusDifferentAccountState *)SoftBusCalloc(sizeof(SoftBusDifferentAccountState));
595 ASSERT_TRUE(mockState != nullptr);
596 *mockState = (SoftBusDifferentAccountState)(SOFTBUS_DIF_ACCOUNT_UNKNOWN + 1);
597 int32_t ret = LnnRegisterEventHandler(event, handler);
598 LnnUnregisterEventHandler(event, handler);
599 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
600 SoftBusFree(mockState);
601 }
602
603 /*
604 * @tc.name: BusCenterEventTest25
605 * @tc.desc: Handle Notify Message Test.
606 * @tc.type: FUNC
607 * @tc.require: 1
608 */
609 HWTEST_F(BusCenterEventTest, BusCenterEventTest25, TestSize.Level1)
610 {
611 EXPECT_NO_FATAL_FAILURE(LnnNotifyNodeStatusChanged(nullptr, TYPE_AUTH_STATUS));
612 }
613
614 /*
615 * @tc.name: BusCenterEventTest26
616 * @tc.desc: Test the LnnRegisterEventHandler function.
617 * @tc.type: FUNC
618 * @tc.require: 1
619 */
620 HWTEST_F(BusCenterEventTest, BusCenterEventTest26, TestSize.Level1)
621 {
622 NodeStatus info = {};
623 EXPECT_NO_FATAL_FAILURE(LnnNotifyNodeStatusChanged(&info, TYPE_AUTH_STATUS));
624 }
625
626 /*
627 * @tc.name: BusCenterEventTest27
628 * @tc.desc: Test the LnnNotifyDeviceTrustedChange function.
629 * @tc.type: FUNC
630 * @tc.require: 1
631 */
632 HWTEST_F(BusCenterEventTest, BusCenterEventTest027, TestSize.Level1)
633 {
634 char *msg = nullptr;
635 EXPECT_NO_FATAL_FAILURE(LnnNotifyDeviceTrustedChange(DEVICE_NOT_TRUSTED, msg, 1));
636 }
637
638 /*
639 * @tc.name:BusCenterEventTest28
640 * @tc.desc: Test the LnnNotifyDeviceTrustedChange function.
641 * @tc.type: FUNC
642 * @tc.require: 1
643 */
644 HWTEST_F(BusCenterEventTest, BusCenterEventTest028, TestSize.Level1)
645 {
646 const char *msg = "msg";
647 uint32_t msgLen = 0;
648 EXPECT_NO_FATAL_FAILURE(LnnNotifyDeviceTrustedChange(DEVICE_NOT_TRUSTED, msg, msgLen));
649 }
650
651 /*
652 * @tc.name: BusCenterEventTest29
653 * @tc.desc: Test the LnnNotifyDeviceTrustedChange function.
654 * @tc.type: FUNC
655 * @tc.require: 1
656 */
657 HWTEST_F(BusCenterEventTest, BusCenterEventTest029, TestSize.Level1)
658 {
659 char *msg = nullptr;
660 uint32_t msgLen = 0;
661 EXPECT_NO_FATAL_FAILURE(LnnNotifyDeviceTrustedChange(DEVICE_NOT_TRUSTED, msg, msgLen));
662 }
663
664 /*
665 * @tc.name: BusCenterEventTest30
666 * @tc.desc: Test the LnnNotifyDataShareStateChangeEvent function.
667 * @tc.type: FUNC
668 * @tc.require: 1
669 */
670 HWTEST_F(BusCenterEventTest, BusCenterEventTest030, TestSize.Level1)
671 {
672 SoftBusDataShareState state = SOFTBUS_DATA_SHARE_UNKNOWN;
673 EXPECT_NO_FATAL_FAILURE(LnnNotifyDataShareStateChangeEvent(state));
674 }
675
676 /*
677 * @tc.name: BusCenterEventTest31
678 * @tc.desc: Test the LnnNotifyDifferentAccountChangeEvent function.
679 * @tc.require: 1
680 */
681 HWTEST_F(BusCenterEventTest, BusCenterEventTest031, TestSize.Level1)
682 {
683 SoftBusDifferentAccountState *difAccountState =
684 (SoftBusDifferentAccountState *)SoftBusMalloc(sizeof(SoftBusDifferentAccountState));
685 ASSERT_TRUE(difAccountState != nullptr);
686 *difAccountState = SOFTBUS_DIF_ACCOUNT_DEV_CHANGE;
687 EXPECT_NO_FATAL_FAILURE(LnnNotifyDifferentAccountChangeEvent((void *)difAccountState));
688 }
689
690 /* @tc.name: BusCenterEventTest032
691 * @tc.desc: Test the LnnNotifyDifferentAccountChangeEvent function.
692 * @tc.type: FUNC
693 * @tc.require: 1
694 */
695 HWTEST_F(BusCenterEventTest, BusCenterEventTest032, TestSize.Level1)
696 {
697 SoftBusDifferentAccountState *difAccountState =
698 (SoftBusDifferentAccountState *)SoftBusMalloc(sizeof(SoftBusDifferentAccountState));
699 ASSERT_TRUE(difAccountState != nullptr);
700 *difAccountState = SOFTBUS_DIF_ACCOUNT_UNKNOWN;
701 EXPECT_NO_FATAL_FAILURE(LnnNotifyDifferentAccountChangeEvent((void *)difAccountState));
702 }
703
704 /*
705 * @tc.name: BusCenterEventTest33
706 * @tc.desc: Test the LnnNotifyNightModeStateChangeEvent function.
707 * @tc.type: FUNC
708 * @tc.require: 1
709 */
710 HWTEST_F(BusCenterEventTest, BusCenterEventTest033, TestSize.Level1)
711 {
712 SoftBusNightModeState *nightModeState = (SoftBusNightModeState *)SoftBusMalloc(sizeof(SoftBusNightModeState));
713 ASSERT_TRUE(nightModeState != nullptr);
714 *nightModeState = SOFTBUS_NIGHT_MODE_ON;
715 EXPECT_NO_FATAL_FAILURE(LnnNotifyNightModeStateChangeEvent((void *)nightModeState));
716 }
717 /*
718 * @tc.name: BusCenterEventTest34
719 * @tc.desc: Test the LnnNotifyNightModeStateChangeEvent function.
720 * @tc.type: FUNC
721 * @tc.require: 1
722 */
723 HWTEST_F(BusCenterEventTest, BusCenterEventTest034, TestSize.Level1)
724 {
725 SoftBusNightModeState *nightModeState = (SoftBusNightModeState *)SoftBusMalloc(sizeof(SoftBusNightModeState));
726 ASSERT_TRUE(nightModeState != nullptr);
727 *nightModeState = SOFTBUS_NIGHT_MODE_UNKNOWN;
728 EXPECT_NO_FATAL_FAILURE(LnnNotifyNightModeStateChangeEvent((void *)nightModeState));
729 }
730
731 /*
732 * @tc.name: BusCenterEventTest35
733 * @tc.desc: Test the LnnRegisterEventHandler function.
734 * @tc.type: FUNC
735 * @tc.require: 1
736 */
737 HWTEST_F(BusCenterEventTest, BusCenterEventTest035, TestSize.Level1)
738 {
739 LnnEventType event = LNN_EVENT_NETWORK_STATE_CHANGED;
740 LnnEventHandler handler = OnNetworkStateChange;
741 SoftBusLooper loop = {};
742 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
743 EXPECT_CALL(BusCenterEventMock, CreateNewLooper(_)).WillRepeatedly(Return(&loop));
744 int32_t rdt = LnnInitBusCenterEvent();
745 EXPECT_EQ(rdt, SOFTBUS_OK);
746 int32_t ret = LnnRegisterEventHandler(event, handler);
747 EXPECT_EQ(ret, SOFTBUS_OK);
748 ret = LnnRegisterEventHandler(event, handler);
749 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
750 EXPECT_NO_FATAL_FAILURE(LnnUnregisterEventHandler(event, handler));
751 EXPECT_EQ(rdt, SOFTBUS_OK);
752 }
753
754 /*
755 * @tc.name: BusCenterEventTest36
756 * @tc.desc: Test the LnnNotifyOnlineState function.
757 * @tc.type: FUNC
758 * @tc.require: 1
759 */
760 HWTEST_F(BusCenterEventTest, BusCenterEventTest036, TestSize.Level1)
761 {
762 bool isOnline = false;
763 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
764 NodeBasicInfo info = {
765 .networkId = "testNetworkId",
766 .deviceName = "testDeviceName",
767 .deviceTypeId = 1,
768 };
769 EXPECT_CALL(BusCenterEventMock, LnnGetAllOnlineNodeNum(_)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
770 EXPECT_NO_FATAL_FAILURE(LnnNotifyOnlineState(isOnline, &info));
771 }
772
773 /*
774 * @tc.name: BusCenterEventTest37
775 * @tc.desc: Test the LnnNotifyOnlineState function.
776 * @tc.type: FUNC
777 * @tc.require: 1
778 */
779 HWTEST_F(BusCenterEventTest, BusCenterEventTest037, TestSize.Level1)
780 {
781 bool isOnline = false;
782 NiceMock<BusCenterEventDepsInterfaceMock> BusCenterEventMock;
783 NodeBasicInfo info = {
784 .networkId = "testNetworkId",
785 .deviceName = "testDeviceName",
786 .deviceTypeId = 1,
787 };
788 EXPECT_CALL(BusCenterEventMock, LnnGetAllOnlineNodeNum(_))
789 .WillRepeatedly(DoAll(SetArgPointee<0>(0), Return(SOFTBUS_OK)));
790 EXPECT_NO_FATAL_FAILURE(LnnNotifyOnlineState(isOnline, &info));
791 }
792
793 }
794