1 /*
2  * Copyright (c) 2022-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 #include "UTTest_softbus_listener.h"
16 
17 #include <securec.h>
18 #include <unistd.h>
19 #include <cstdlib>
20 #include <thread>
21 
22 #include "device_manager_impl.h"
23 #include "dm_anonymous.h"
24 #include "dm_constants.h"
25 #include "dm_device_info.h"
26 #include "dm_log.h"
27 #include "parameter.h"
28 #include "nlohmann/json.hpp"
29 #include "system_ability_definition.h"
30 #include "softbus_listener.cpp"
31 #include "softbus_error_code.h"
32 
33 namespace OHOS {
34 namespace DistributedHardware {
SetUp()35 void SoftbusListenerTest::SetUp()
36 {
37 }
TearDown()38 void SoftbusListenerTest::TearDown()
39 {
40 }
SetUpTestCase()41 void SoftbusListenerTest::SetUpTestCase()
42 {
43 }
TearDownTestCase()44 void SoftbusListenerTest::TearDownTestCase()
45 {
46 }
47 
48 namespace {
49     std::shared_ptr<SoftbusListener> softbusListener = std::make_shared<SoftbusListener>();
50 
CheckSoftbusRes(int32_t ret)51 bool CheckSoftbusRes(int32_t ret)
52 {
53     return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR
54         || SOFTBUS_IPC_ERR;
55 }
56 
57 /**
58  * @tc.name: ConvertNodeBasicInfoToDmDevice_001
59  * @tc.desc: go to the correct case and return DM_OK
60  * @tc.type: FUNC
61  * @tc.require: AR000GHSJK
62  */
63 HWTEST_F(SoftbusListenerTest, ConvertNodeBasicInfoToDmDevice_001, testing::ext::TestSize.Level0)
64 {
65     NodeBasicInfo nodeBasicInfo;
66     DmDeviceInfo dmDeviceInfo;
67     if (softbusListener == nullptr) {
68         softbusListener = std::make_shared<SoftbusListener>();
69     }
70     int32_t ret = softbusListener->ConvertNodeBasicInfoToDmDevice(nodeBasicInfo, dmDeviceInfo);
71     EXPECT_EQ(ret, DM_OK);
72 }
73 
74 /**
75  * @tc.name: ConvertNodeBasicInfoToDmDevice_002
76  * @tc.desc: return DM_OK
77  * @tc.type: FUNC
78  */
79 HWTEST_F(SoftbusListenerTest, ConvertNodeBasicInfoToDmDevice_002, testing::ext::TestSize.Level0)
80 {
81     NodeBasicInfo nodeBasicInfo;
82     DmDeviceBasicInfo dmDevicdeviceNameeInfo;
83     if (softbusListener == nullptr) {
84         softbusListener = std::make_shared<SoftbusListener>();
85     }
86     int32_t ret = softbusListener->ConvertNodeBasicInfoToDmDevice(nodeBasicInfo, dmDevicdeviceNameeInfo);
87     EXPECT_EQ(ret, DM_OK);
88 }
89 
90 /**
91  * @tc.name: OnSoftbusDeviceOnline_001
92  * @tc.desc: return true
93  * @tc.type: FUNC
94  * @tc.require: AR000GHSJK
95  */
96 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceOnline_001, testing::ext::TestSize.Level0)
97 {
98     NodeBasicInfo info = {
99             .networkId = "123456",
100             .deviceName = "123456",
101             .deviceTypeId = 1
102         };
103     if (softbusListener == nullptr) {
104         softbusListener = std::make_shared<SoftbusListener>();
105     }
106     softbusListener->OnSoftbusDeviceOnline(&info);
107     softbusListener->OnSoftbusDeviceOffline(&info);
108     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
109 }
110 
111 /**
112  * @tc.name: ShiftLNNGear_001
113  * @tc.desc: return DM_OK
114  * @tc.type: FUNC
115  */
116 HWTEST_F(SoftbusListenerTest, ShiftLNNGear_001, testing::ext::TestSize.Level0)
117 {
118     if (softbusListener == nullptr) {
119         softbusListener = std::make_shared<SoftbusListener>();
120     }
121     std::string callerId = "callerId";
122     EXPECT_NE(softbusListener->ShiftLNNGear(false, callerId), DM_OK);
123 }
124 
125 HWTEST_F(SoftbusListenerTest, DeviceOnLine_001, testing::ext::TestSize.Level0)
126 {
127     DmDeviceInfo deviceInf = {
128         .deviceId = "123456",
129         .deviceName = "name",
130         .deviceTypeId = 1,
131         .networkId = "123456",
132     };
133     if (softbusListener == nullptr) {
134         softbusListener = std::make_shared<SoftbusListener>();
135     }
136     softbusListener->DeviceOnLine(deviceInf);
137     softbusListener->DeviceNameChange(deviceInf);
138     softbusListener->DeviceOffLine(deviceInf);
139     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
140 }
141 
142 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_001, testing::ext::TestSize.Level0)
143 {
144     NodeBasicInfoType type = NodeBasicInfoType::TYPE_DEVICE_NAME;
145     NodeBasicInfo *info = nullptr;
146     if (softbusListener == nullptr) {
147         softbusListener = std::make_shared<SoftbusListener>();
148     }
149     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
150     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
151 }
152 
153 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_002, testing::ext::TestSize.Level0)
154 {
155     NodeBasicInfoType type = NodeBasicInfoType::TYPE_DEVICE_NAME;
156     NodeBasicInfo nodeBasic;
157     NodeBasicInfo *info = &nodeBasic;
158     if (softbusListener == nullptr) {
159         softbusListener = std::make_shared<SoftbusListener>();
160     }
161     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
162     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
163 }
164 
165 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceInfoChanged_003, testing::ext::TestSize.Level0)
166 {
167     NodeBasicInfoType type = NodeBasicInfoType::TYPE_NETWORK_INFO;
168     NodeBasicInfo nodeBasic;
169     NodeBasicInfo *info = &nodeBasic;
170     if (softbusListener == nullptr) {
171         softbusListener = std::make_shared<SoftbusListener>();
172     }
173     softbusListener->OnSoftbusDeviceInfoChanged(type, info);
174     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
175 }
176 
177 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceFound_001, testing::ext::TestSize.Level0)
178 {
179     DeviceInfo *device = nullptr;
180     if (softbusListener == nullptr) {
181         softbusListener = std::make_shared<SoftbusListener>();
182     }
183     softbusListener->OnSoftbusDeviceFound(device);
184     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
185 }
186 
187 HWTEST_F(SoftbusListenerTest, OnSoftbusDeviceFound_002, testing::ext::TestSize.Level0)
188 {
189     DeviceInfo info;
190     DeviceInfo *device = &info;
191     if (softbusListener == nullptr) {
192         softbusListener = std::make_shared<SoftbusListener>();
193     }
194     softbusListener->OnSoftbusDeviceFound(device);
195     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
196 }
197 
198 HWTEST_F(SoftbusListenerTest, OnSoftbusDiscoveryResult_001, testing::ext::TestSize.Level0)
199 {
200     int subscribeId = 1;
201     RefreshResult result = RefreshResult::REFRESH_LNN_SUCCESS;
202     if (softbusListener == nullptr) {
203         softbusListener = std::make_shared<SoftbusListener>();
204     }
205     softbusListener->OnSoftbusDiscoveryResult(subscribeId, result);
206     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
207 }
208 
209 HWTEST_F(SoftbusListenerTest, OnSoftbusPublishResult_001, testing::ext::TestSize.Level0)
210 {
211     int subscribeId = 1;
212     PublishResult result = PublishResult::PUBLISH_LNN_SUCCESS;
213     if (softbusListener == nullptr) {
214         softbusListener = std::make_shared<SoftbusListener>();
215     }
216     softbusListener->OnSoftbusPublishResult(subscribeId, result);
217     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
218 }
219 
220 HWTEST_F(SoftbusListenerTest, PublishSoftbusLNN_001, testing::ext::TestSize.Level0)
221 {
222     DmPublishInfo dmPubInfo;
223     std::string capability;
224     std::string customData;
225     if (softbusListener == nullptr) {
226         softbusListener = std::make_shared<SoftbusListener>();
227     }
228     int32_t ret = softbusListener->PublishSoftbusLNN(dmPubInfo, capability, customData);
229     EXPECT_EQ(true, CheckSoftbusRes(ret));
230 }
231 
232 HWTEST_F(SoftbusListenerTest, StopPublishSoftbusLNN_001, testing::ext::TestSize.Level0)
233 {
234     int32_t publishId = 1;
235     if (softbusListener == nullptr) {
236         softbusListener = std::make_shared<SoftbusListener>();
237     }
238     int32_t ret = softbusListener->StopPublishSoftbusLNN(publishId);
239     EXPECT_EQ(true, CheckSoftbusRes(ret));
240 }
241 
242 HWTEST_F(SoftbusListenerTest, RegisterSoftbusLnnOpsCbk_001, testing::ext::TestSize.Level0)
243 {
244     std::string pkgName;
245     std::shared_ptr<ISoftbusDiscoveringCallback> callback = nullptr;
246     if (softbusListener == nullptr) {
247         softbusListener = std::make_shared<SoftbusListener>();
248     }
249     int32_t ret = softbusListener->RegisterSoftbusLnnOpsCbk(pkgName, callback);
250     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
251 }
252 
253 HWTEST_F(SoftbusListenerTest, RegisterSoftbusLnnOpsCbk_002, testing::ext::TestSize.Level0)
254 {
255     std::string pkgName;
256     std::shared_ptr<ISoftbusDiscoveringCallback> callback = std::make_shared<ISoftbusDiscoveringCallbackTest>();
257     if (softbusListener == nullptr) {
258         softbusListener = std::make_shared<SoftbusListener>();
259     }
260     int32_t ret = softbusListener->RegisterSoftbusLnnOpsCbk(pkgName, callback);
261     EXPECT_EQ(ret, DM_OK);
262 }
263 
264 HWTEST_F(SoftbusListenerTest, UnRegisterSoftbusLnnOpsCbk_001, testing::ext::TestSize.Level0)
265 {
266     std::string pkgName;
267     if (softbusListener == nullptr) {
268         softbusListener = std::make_shared<SoftbusListener>();
269     }
270     int32_t ret = softbusListener->UnRegisterSoftbusLnnOpsCbk(pkgName);
271     EXPECT_EQ(ret, DM_OK);
272 }
273 
274 HWTEST_F(SoftbusListenerTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
275 {
276     std::string networkId = "networkId";
277     std::string udid = "udid";
278     if (softbusListener == nullptr) {
279         softbusListener = std::make_shared<SoftbusListener>();
280     }
281     int32_t ret = softbusListener->GetUdidByNetworkId(networkId.c_str(), udid);
282     EXPECT_EQ(true, CheckSoftbusRes(ret));
283 }
284 
285 HWTEST_F(SoftbusListenerTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
286 {
287     std::string networkId = "networkId";
288     std::string udid;
289     if (softbusListener == nullptr) {
290         softbusListener = std::make_shared<SoftbusListener>();
291     }
292     int32_t ret = softbusListener->GetUuidByNetworkId(networkId.c_str(), udid);
293     EXPECT_EQ(true, CheckSoftbusRes(ret));
294 }
295 
296 HWTEST_F(SoftbusListenerTest, ConvertDeviceInfoToDmDevice_001, testing::ext::TestSize.Level0)
297 {
298     DeviceInfo device;
299     DmDeviceInfo dmDevice;
300     if (softbusListener == nullptr) {
301         softbusListener = std::make_shared<SoftbusListener>();
302     }
303     softbusListener->ConvertDeviceInfoToDmDevice(device, dmDevice);
304     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
305 }
306 
307 HWTEST_F(SoftbusListenerTest, ConvertDeviceInfoToDmDevice_002, testing::ext::TestSize.Level0)
308 {
309     DmDeviceInfo dmDevice;
310     DeviceInfo deviceInfo = {
311         .devId = "deviceId",
312         .devType = (DeviceType)1,
313         .devName = "11111",
314         .addrNum = 1,
315         .addr[0] = {
316             .type = ConnectionAddrType::CONNECTION_ADDR_ETH,
317             .info {
318                 .ip {
319                     .ip = "172.0.0.1",
320                     .port = 0,
321                 }
322             }
323         }
324     };
325     if (softbusListener == nullptr) {
326         softbusListener = std::make_shared<SoftbusListener>();
327     }
328     softbusListener->ConvertDeviceInfoToDmDevice(deviceInfo, dmDevice);
329     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
330 }
331 
332 HWTEST_F(SoftbusListenerTest, ConvertDeviceInfoToDmDevice_003, testing::ext::TestSize.Level0)
333 {
334     DmDeviceInfo dmDevice;
335     DeviceInfo deviceInfo = {
336         .devId = "deviceId",
337         .devType = (DeviceType)1,
338         .devName = "11111",
339         .addrNum = 1,
340         .addr[0] = {
341             .type = ConnectionAddrType::CONNECTION_ADDR_BR,
342             .info {
343                 .ip {
344                     .ip = "172.0.0.1",
345                     .port = 0,
346                 }
347             }
348         }
349     };
350     if (softbusListener == nullptr) {
351         softbusListener = std::make_shared<SoftbusListener>();
352     }
353     softbusListener->ConvertDeviceInfoToDmDevice(deviceInfo, dmDevice);
354     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
355 }
356 
357 HWTEST_F(SoftbusListenerTest, ConvertDeviceInfoToDmDevice_004, testing::ext::TestSize.Level0)
358 {
359     DmDeviceInfo dmDevice;
360     DeviceInfo deviceInfo = {
361         .devId = "deviceId",
362         .devType = (DeviceType)1,
363         .devName = "11111",
364         .addrNum = 1,
365         .addr[0] = {
366             .type = ConnectionAddrType::CONNECTION_ADDR_MAX,
367             .info {
368                 .ip {
369                     .ip = "172.0.0.1",
370                     .port = 0,
371                 }
372             }
373         }
374     };
375     if (softbusListener == nullptr) {
376         softbusListener = std::make_shared<SoftbusListener>();
377     }
378     softbusListener->ConvertDeviceInfoToDmDevice(deviceInfo, dmDevice);
379     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
380 }
381 
382 HWTEST_F(SoftbusListenerTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0)
383 {
384     char *networkId;
385     int32_t networkType = -1;
386     if (softbusListener == nullptr) {
387         softbusListener = std::make_shared<SoftbusListener>();
388     }
389     int32_t ret = softbusListener->GetNetworkTypeByNetworkId(networkId, networkType);
390     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
391 }
392 
393 HWTEST_F(SoftbusListenerTest, CacheDiscoveredDevice_001, testing::ext::TestSize.Level0)
394 {
395     DeviceInfo *device;
396     if (softbusListener == nullptr) {
397         softbusListener = std::make_shared<SoftbusListener>();
398     }
399     softbusListener->CacheDiscoveredDevice(device);
400     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
401 }
402 
403 HWTEST_F(SoftbusListenerTest, GetTargetInfoFromCache_001, testing::ext::TestSize.Level0)
404 {
405     std::string deviceId = "deviceId";
406     DeviceInfo deviceInfo = {
407         .devId = "deviceId",
408         .devType = (DeviceType)1,
409         .devName = "11111",
410         .addrNum = 1,
411         .addr[0] = {
412             .type = ConnectionAddrType::CONNECTION_ADDR_WLAN,
413             .info {
414                 .ip {
415                     .ip = "172.0.0.1",
416                     .port = 0,
417                 }
418             }
419         }
420     };
421     PeerTargetId targetId;
422     ConnectionAddrType addrType;
423     if (softbusListener == nullptr) {
424         softbusListener = std::make_shared<SoftbusListener>();
425     }
426     softbusListener->CacheDiscoveredDevice(&deviceInfo);
427     int32_t ret = softbusListener->GetTargetInfoFromCache(deviceId, targetId, addrType);
428     EXPECT_EQ(ret, DM_OK);
429 }
430 
431 HWTEST_F(SoftbusListenerTest, ClearDiscoveredDevice_001, testing::ext::TestSize.Level0)
432 {
433     if (softbusListener == nullptr) {
434         softbusListener = std::make_shared<SoftbusListener>();
435     }
436     softbusListener->ClearDiscoveredDevice();
437     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
438 }
439 
440 HWTEST_F(SoftbusListenerTest, IsDmRadarHelperReady_001, testing::ext::TestSize.Level0)
441 {
442     if (softbusListener == nullptr) {
443         softbusListener = std::make_shared<SoftbusListener>();
444     }
445     bool ret = softbusListener->IsDmRadarHelperReady();
446     EXPECT_EQ(ret, true);
447 }
448 
449 HWTEST_F(SoftbusListenerTest, CloseDmRadarHelperObj_001, testing::ext::TestSize.Level0)
450 {
451     std::string name;
452     if (softbusListener == nullptr) {
453         softbusListener = std::make_shared<SoftbusListener>();
454     }
455     bool ret = softbusListener->CloseDmRadarHelperObj(name);
456     EXPECT_EQ(ret, true);
457 }
458 
459 HWTEST_F(SoftbusListenerTest, OnSessionOpened_001, testing::ext::TestSize.Level0)
460 {
461     int sessionId = 0;
462     int result = 1;
463     if (softbusListener == nullptr) {
464         softbusListener = std::make_shared<SoftbusListener>();
465     }
466     EXPECT_EQ(OnSessionOpened(sessionId, result), DM_OK);
467 }
468 
469 HWTEST_F(SoftbusListenerTest, OnSessionClosed_001, testing::ext::TestSize.Level0)
470 {
471     int sessionId = 0;
472     OnSessionClosed(sessionId);
473     if (softbusListener == nullptr) {
474         softbusListener = std::make_shared<SoftbusListener>();
475     }
476     EXPECT_EQ(softbusListener->isRadarSoLoad_, false);
477 }
478 
479 HWTEST_F(SoftbusListenerTest, OnBytesReceived_001, testing::ext::TestSize.Level0)
480 {
481     int sessionId = 0;
482     std::string str = "1234513135215123";
483     OnBytesReceived(sessionId, str.c_str(), str.size());
484     if (softbusListener == nullptr) {
485         softbusListener = std::make_shared<SoftbusListener>();
486     }
487     EXPECT_EQ(softbusListener->isRadarSoLoad_, false);
488 }
489 
490 HWTEST_F(SoftbusListenerTest, OnPinHolderSessionOpened_001, testing::ext::TestSize.Level0)
491 {
492     int sessionId = 0;
493     int result = 1;
494     if (softbusListener == nullptr) {
495         softbusListener = std::make_shared<SoftbusListener>();
496     }
497     EXPECT_EQ(OnPinHolderSessionOpened(sessionId, result), ERR_DM_FAILED);
498 }
499 
500 HWTEST_F(SoftbusListenerTest, OnPinHolderSessionClosed_001, testing::ext::TestSize.Level0)
501 {
502     int sessionId = 0;
503     OnPinHolderSessionClosed(sessionId);
504     if (softbusListener == nullptr) {
505         softbusListener = std::make_shared<SoftbusListener>();
506     }
507     EXPECT_EQ(softbusListener->isRadarSoLoad_, false);
508 }
509 
510 HWTEST_F(SoftbusListenerTest, OnPinHolderBytesReceived_001, testing::ext::TestSize.Level0)
511 {
512     int sessionId = 0;
513     std::string str = "1234513135215123";
514     OnPinHolderBytesReceived(sessionId, str.c_str(), str.size());
515     if (softbusListener == nullptr) {
516         softbusListener = std::make_shared<SoftbusListener>();
517     }
518     EXPECT_EQ(softbusListener->isRadarSoLoad_, false);
519 }
520 
521 HWTEST_F(SoftbusListenerTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
522 {
523     std::vector<DmDeviceInfo> deviceInfoList;
524     if (softbusListener == nullptr) {
525         softbusListener = std::make_shared<SoftbusListener>();
526     }
527     int32_t ret = softbusListener->GetTrustedDeviceList(deviceInfoList);
528     EXPECT_EQ(ret, DM_OK);
529 }
530 
531 HWTEST_F(SoftbusListenerTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
532 {
533     std::vector<DmDeviceInfo> deviceInfoList;
534     DmDeviceInfo deviceInfo;
535     deviceInfoList.push_back(deviceInfo);
536     if (softbusListener == nullptr) {
537         softbusListener = std::make_shared<SoftbusListener>();
538     }
539     int32_t ret = softbusListener->GetTrustedDeviceList(deviceInfoList);
540     EXPECT_EQ(ret, DM_OK);
541 }
542 
543 HWTEST_F(SoftbusListenerTest, GetDeviceInfo_001, testing::ext::TestSize.Level0)
544 {
545     std::string networkId = "networkId";
546     DmDeviceInfo info;
547     if (softbusListener == nullptr) {
548         softbusListener = std::make_shared<SoftbusListener>();
549     }
550     int32_t ret = softbusListener->GetDeviceInfo(networkId, info);
551     EXPECT_EQ(true, CheckSoftbusRes(ret));
552 }
553 
554 HWTEST_F(SoftbusListenerTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
555 {
556     DmDeviceInfo info;
557     if (softbusListener == nullptr) {
558         softbusListener = std::make_shared<SoftbusListener>();
559     }
560     int32_t ret = softbusListener->GetLocalDeviceInfo(info);
561     EXPECT_EQ(true, CheckSoftbusRes(ret));
562 }
563 
564 HWTEST_F(SoftbusListenerTest, ConvertBytesToUpperCaseHexString_001, testing::ext::TestSize.Level0)
565 {
566     uint8_t arr[7] = {1, 2, 3, 4, 5, 6, 7};
567     size_t size = 7;
568     if (softbusListener == nullptr) {
569         softbusListener = std::make_shared<SoftbusListener>();
570     }
571     auto ret = softbusListener->ConvertBytesToUpperCaseHexString(arr, size);
572     EXPECT_EQ(ret.empty(), false);
573 }
574 
575 HWTEST_F(SoftbusListenerTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0)
576 {
577     std::string networkId = "networkId";
578     int32_t securityLevel = -1;
579     if (softbusListener == nullptr) {
580         softbusListener = std::make_shared<SoftbusListener>();
581     }
582     int32_t ret = softbusListener->GetDeviceSecurityLevel(networkId.c_str(), securityLevel);
583     EXPECT_EQ(ret, ERR_DM_FAILED);
584 }
585 
586 HWTEST_F(SoftbusListenerTest, GetDmRadarHelperObj_001, testing::ext::TestSize.Level0)
587 {
588     if (softbusListener == nullptr) {
589         softbusListener = std::make_shared<SoftbusListener>();
590     }
591     auto ret = softbusListener->GetDmRadarHelperObj();
592     EXPECT_NE(ret, nullptr);
593 }
594 
595 HWTEST_F(SoftbusListenerTest, SetHostPkgName_001, testing::ext::TestSize.Level0)
596 {
597     std::string hostName = "hostName";
598     if (softbusListener == nullptr) {
599         softbusListener = std::make_shared<SoftbusListener>();
600     }
601     softbusListener->SetHostPkgName(hostName);
602     EXPECT_EQ(softbusListener->hostName_, hostName);
603 }
604 
605 HWTEST_F(SoftbusListenerTest, GetHostPkgName_001, testing::ext::TestSize.Level0)
606 {
607     if (softbusListener == nullptr) {
608         softbusListener = std::make_shared<SoftbusListener>();
609     }
610     auto ret = softbusListener->GetHostPkgName();
611     EXPECT_EQ(ret.empty(), false);
612 }
613 
614 HWTEST_F(SoftbusListenerTest, CacheDeviceInfo_001, testing::ext::TestSize.Level0)
615 {
616     std::string deviceId;
617     std::shared_ptr<DeviceInfo> infoPtr = nullptr;
618     if (softbusListener == nullptr) {
619         softbusListener = std::make_shared<SoftbusListener>();
620     }
621     softbusListener->CacheDeviceInfo(deviceId, infoPtr);
622     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
623 }
624 
625 HWTEST_F(SoftbusListenerTest, CacheDeviceInfo_002, testing::ext::TestSize.Level0)
626 {
627     std::string deviceId = "deviceId";
628     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
629     infoPtr->addrNum = 0;
630     if (softbusListener == nullptr) {
631         softbusListener = std::make_shared<SoftbusListener>();
632     }
633     softbusListener->CacheDeviceInfo(deviceId, infoPtr);
634     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
635 }
636 
637 HWTEST_F(SoftbusListenerTest, CacheDeviceInfo_003, testing::ext::TestSize.Level0)
638 {
639     std::string deviceId = "deviceId";
640     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
641     infoPtr->addrNum = 1;
642     if (softbusListener == nullptr) {
643         softbusListener = std::make_shared<SoftbusListener>();
644     }
645     softbusListener->CacheDeviceInfo(deviceId, infoPtr);
646     EXPECT_EQ(softbusListener->isRadarSoLoad_, true);
647 }
648 
649 HWTEST_F(SoftbusListenerTest, GetIPAddrTypeFromCache_001, testing::ext::TestSize.Level0)
650 {
651     std::string deviceId = "deviceId";
652     std::string ip = "10.11.12.13.14";
653     ConnectionAddrType addrType;
654     if (softbusListener == nullptr) {
655         softbusListener = std::make_shared<SoftbusListener>();
656     }
657     int32_t ret = softbusListener->GetIPAddrTypeFromCache(deviceId, ip, addrType);
658     EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID);
659 }
660 
661 HWTEST_F(SoftbusListenerTest, GetIPAddrTypeFromCache_002, testing::ext::TestSize.Level0)
662 {
663     std::string deviceId = "deviceId";
664     std::string ip = "10.11.12.13.14";
665     ConnectionAddrType addrType;
666     std::vector<std::pair<ConnectionAddrType, std::shared_ptr<DeviceInfo>>> deviceVec;
667     discoveredDeviceMap.insert(std::pair<std::string,
668         std::vector<std::pair<ConnectionAddrType, std::shared_ptr<DeviceInfo>>>>(deviceId, deviceVec));
669     if (softbusListener == nullptr) {
670         softbusListener = std::make_shared<SoftbusListener>();
671     }
672     int32_t ret = softbusListener->GetIPAddrTypeFromCache(deviceId, ip, addrType);
673     EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID);
674 }
675 
676 HWTEST_F(SoftbusListenerTest, GetIPAddrTypeFromCache_003, testing::ext::TestSize.Level0)
677 {
678     std::string deviceId = "deviceId";
679     std::string ip = "10.11.12.13.14";
680     ConnectionAddrType addrType;
681     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
682     std::vector<std::pair<ConnectionAddrType, std::shared_ptr<DeviceInfo>>> deviceVec;
683     deviceVec.push_back(std::pair<ConnectionAddrType, std::shared_ptr<DeviceInfo>>(addrType, infoPtr));
684     discoveredDeviceMap.insert(std::pair<std::string,
685         std::vector<std::pair<ConnectionAddrType, std::shared_ptr<DeviceInfo>>>>(deviceId, deviceVec));
686     if (softbusListener == nullptr) {
687         softbusListener = std::make_shared<SoftbusListener>();
688     }
689     int32_t ret = softbusListener->GetIPAddrTypeFromCache(deviceId, ip, addrType);
690     EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID);
691 }
692 
693 HWTEST_F(SoftbusListenerTest, InitSoftbusListener_001, testing::ext::TestSize.Level0)
694 {
695     SoftbusListener::GetSoftbusRefreshCb();
696     if (softbusListener == nullptr) {
697         softbusListener = std::make_shared<SoftbusListener>();
698     }
699     int32_t ret = softbusListener->InitSoftbusListener();
700     EXPECT_EQ(ret, DM_OK);
701 }
702 
703 HWTEST_F(SoftbusListenerTest, RefreshSoftbusLNN_001, testing::ext::TestSize.Level0)
704 {
705     std::string pkgName = "pkgName";
706     DmSubscribeInfo dmSubInfo;
707     std::string customData = "customData";
708     if (softbusListener == nullptr) {
709         softbusListener = std::make_shared<SoftbusListener>();
710     }
711     int32_t ret = softbusListener->RefreshSoftbusLNN(pkgName.c_str(), dmSubInfo, customData);
712     EXPECT_EQ(true, CheckSoftbusRes(ret));
713 }
714 
715 HWTEST_F(SoftbusListenerTest, StopRefreshSoftbusLNN_001, testing::ext::TestSize.Level0)
716 {
717     uint16_t subscribeId = 1345;
718     if (softbusListener == nullptr) {
719         softbusListener = std::make_shared<SoftbusListener>();
720     }
721     int32_t ret = softbusListener->StopRefreshSoftbusLNN(subscribeId);
722     softbusListener->OnLocalDevInfoChange();
723     std::string msg = "123";
724     softbusListener->DeviceNotTrust(msg);
725     NodeBasicInfo *info = nullptr;
726     softbusListener->OnSoftbusDeviceOffline(info);
727     const uint32_t msgLen = 100;
728     char proofInfo[msgLen] = {0};
729     uint16_t deviceTypeId = 0;
730     int32_t errcode = -1;
731     softbusListener->OnCredentialAuthStatus(proofInfo, msgLen, deviceTypeId, errcode);
732     std::string proofInfo2;
733     deviceTypeId = 0xA2F;
734     softbusListener->CredentialAuthStatusProcess(proofInfo2, deviceTypeId, errcode);
735     EXPECT_EQ(true, CheckSoftbusRes(ret));
736 }
737 
738 HWTEST_F(SoftbusListenerTest, OnLocalDevInfoChange_001, testing::ext::TestSize.Level0)
739 {
740     char *msg = nullptr;
741     if (softbusListener == nullptr) {
742         softbusListener = std::make_shared<SoftbusListener>();
743     }
744     softbusListener->OnLocalDevInfoChange();
745     EXPECT_EQ(msg, nullptr);
746 }
747 
748 HWTEST_F(SoftbusListenerTest, OnDeviceNotTrusted_001, testing::ext::TestSize.Level0)
749 {
750     char *msg = nullptr;
751     if (softbusListener == nullptr) {
752         softbusListener = std::make_shared<SoftbusListener>();
753     }
754     softbusListener->OnDeviceNotTrusted(nullptr);
755     EXPECT_EQ(msg, nullptr);
756 }
757 
758 HWTEST_F(SoftbusListenerTest, OnDeviceNotTrusted_002, testing::ext::TestSize.Level0)
759 {
760     char msg[MAX_SOFTBUS_MSG_LEN + 1] = "This is a long message";
761     if (softbusListener == nullptr) {
762         softbusListener = std::make_shared<SoftbusListener>();
763     }
764     softbusListener->OnDeviceNotTrusted(msg);
765     EXPECT_NE(msg, nullptr);
766 }
767 
768 HWTEST_F(SoftbusListenerTest, OnDeviceNotTrusted_003, testing::ext::TestSize.Level0)
769 {
770     char msg[MAX_SOFTBUS_MSG_LEN - 1] = "Valid message";
771     if (softbusListener == nullptr) {
772         softbusListener = std::make_shared<SoftbusListener>();
773     }
774     softbusListener->OnDeviceNotTrusted(msg);
775     EXPECT_NE(msg, nullptr);
776 }
777 
778 
779 } // namespace
780 } // namespace DistributedHardware
781 } // namespace OHOS