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