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 #include <gmock/gmock.h>
16 #include <gtest/gtest.h>
17 #include "securec.h"
18 
19 #include "disc_log.h"
20 #include "message_handler.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_ble_mock.h"
23 #include "softbus_broadcast_utils.h"
24 #include "softbus_error_code.h"
25 
26 using namespace testing::ext;
27 using ::testing::Return;
28 
29 #define BC_ADV_FLAG                  0x2
30 #define BC_ADV_TX_POWER_DEFAULT      (-6)
31 #define BC_CHANNLE_MAP               0x0
32 #define BC_INTERNAL                  48
33 #define MANUFACTURE_COMPANY_ID       0x027D
34 #define SERVICE_UUID                 0xFDEE
35 #define SRV_TYPE_INVALID             (-1)
36 
37 namespace OHOS {
38 class SoftbusBroadcastMgrTest : public testing::Test {
39 public:
SetUpTestCase()40     static void SetUpTestCase()
41     {
42         LooperInit();
43     }
44 
TearDownTestCase()45     static void TearDownTestCase()
46     {
47         LooperDeinit();
48     }
49 
SetUp()50     void SetUp() override {}
TearDown()51     void TearDown() override {}
52 
53     static inline uint8_t BC_DATA_PAYLOAD[] = {0x04, 0x05, 0x90, 0x00, 0x00, 0x10, 0x00, 0x18, 0xB9, 0x13, 0x3D, 0x28,
54         0xFC, 0x0D, 0x7F, 0xAB, 0x21, 0x00, 0x30, 0x4F, 0x70, 0x65, 0x6E, 0x48};
55     static inline uint8_t RSP_DATA_PAYLOAD[] = {0x61, 0x72, 0x6D, 0x6F, 0x6E, 0x79, 0x20, 0x33, 0x2E, 0x32, 0x00};
56 };
57 
ActionOfSoftbusBleAdapterInitNull()58 static void ActionOfSoftbusBleAdapterInitNull()
59 {
60     DISC_LOGI(DISC_TEST, "enter");
61     static SoftbusBroadcastMediumInterface interface = {};
62     if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
63         DISC_LOGE(DISC_TEST, "Register gatt interface failed.");
64     }
65 }
66 
BuildBroadcastParam(BroadcastParam * bcParam)67 static void BuildBroadcastParam(BroadcastParam *bcParam)
68 {
69     bcParam->minInterval = BC_INTERNAL;
70     bcParam->maxInterval = BC_INTERNAL;
71     bcParam->advType = SOFTBUS_BC_ADV_IND;
72     bcParam->ownAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
73     bcParam->peerAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
74     bcParam->channelMap = BC_CHANNLE_MAP;
75     bcParam->txPower = BC_ADV_TX_POWER_DEFAULT;
76 }
77 
BuildBroadcastPacketExceptPayload(BroadcastPacket * packet)78 static void BuildBroadcastPacketExceptPayload(BroadcastPacket *packet)
79 {
80     packet->bcData.type = BC_DATA_TYPE_SERVICE;
81     packet->bcData.id = SERVICE_UUID;
82     packet->rspData.type = BC_DATA_TYPE_MANUFACTURER;
83     packet->rspData.id = MANUFACTURE_COMPANY_ID;
84     packet->isSupportFlag = true;
85     packet->flag = BC_ADV_FLAG;
86 }
87 
BuildScanParam(BcScanParams * scanParam)88 static void BuildScanParam(BcScanParams *scanParam)
89 {
90     scanParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
91     scanParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
92     scanParam->scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE;
93     scanParam->scanPhy = SOFTBUS_BC_SCAN_PHY_1M;
94     scanParam->scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL;
95 }
96 
97 // filter is released in UnRegisterScanListener
GetBcScanFilter(void)98 static BcScanFilter *GetBcScanFilter(void)
99 {
100     unsigned char serviceData[] = {0x04, 0x05, 0x90};
101     unsigned char serviceDataMask[] = {0xFF, 0xFF, 0xFF};
102     int serviceDataLength = sizeof(serviceData);
103 
104     BcScanFilter *filter = static_cast<BcScanFilter *>(SoftBusCalloc(sizeof(BcScanFilter)));
105     DISC_CHECK_AND_RETURN_RET_LOGW(filter != nullptr, nullptr, DISC_TEST, "malloc filter failed");
106 
107     unsigned char *data = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
108     unsigned char *mask = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
109     if (data == nullptr || mask == nullptr) {
110         goto EXIT;
111     }
112     if (memcpy_s(data, serviceDataLength, serviceData, serviceDataLength) != EOK) {
113         goto EXIT;
114     }
115     if (memcpy_s(mask, serviceDataLength, serviceDataMask, serviceDataLength) != EOK) {
116         goto EXIT;
117     }
118 
119     filter->serviceUuid = SERVICE_UUID;
120     filter->serviceData = data;
121     filter->serviceDataMask = mask;
122     filter->serviceDataLength = serviceDataLength;
123     return filter;
124 EXIT:
125     SoftBusFree(filter);
126     SoftBusFree(data);
127     SoftBusFree(mask);
128     return nullptr;
129 }
130 
BleBcEnableCallback(int channel,int status)131 static void BleBcEnableCallback(int channel, int status)
132 {
133     DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
134 }
135 
BleBcDisableCallback(int channel,int status)136 static void BleBcDisableCallback(int channel, int status)
137 {
138     DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
139 }
140 
BleBcUpdateCallback(int channel,int status)141 static void BleBcUpdateCallback(int channel, int status)
142 {
143     DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
144 }
145 
BleBcDataCallback(int channel,int status)146 static void BleBcDataCallback(int channel, int status)
147 {
148     DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
149 }
150 
BleOnScanStart(int listenerId,int status)151 static void BleOnScanStart(int listenerId, int status)
152 {
153     (void)listenerId;
154     (void)status;
155     DISC_LOGI(DISC_TEST, "BleOnScanStart");
156 }
157 
BleOnScanStop(int listenerId,int status)158 static void BleOnScanStop(int listenerId, int status)
159 {
160     (void)listenerId;
161     (void)status;
162     DISC_LOGI(DISC_TEST, "BleOnScanStop");
163 }
164 
BleScanResultCallback(int listenerId,const BroadcastReportInfo * reportInfo)165 static void BleScanResultCallback(int listenerId, const BroadcastReportInfo *reportInfo)
166 {
167     (void)listenerId;
168 }
169 
GetBroadcastCallback()170 static BroadcastCallback *GetBroadcastCallback()
171 {
172     static BroadcastCallback g_bcCallback = {
173         .OnStartBroadcastingCallback = BleBcEnableCallback,
174         .OnStopBroadcastingCallback = BleBcDisableCallback,
175         .OnUpdateBroadcastingCallback = BleBcUpdateCallback,
176         .OnSetBroadcastingCallback = BleBcDataCallback,
177     };
178     return &g_bcCallback;
179 }
180 
GetScanCallback()181 static ScanCallback *GetScanCallback()
182 {
183     static ScanCallback g_scanListener = {
184         .OnStartScanCallback = BleOnScanStart,
185         .OnStopScanCallback = BleOnScanStop,
186         .OnReportScanDataCallback = BleScanResultCallback,
187     };
188     return &g_scanListener;
189 }
190 
191 /*
192  * @tc.name: SoftbusBroadcastMgrInit001
193  * @tc.desc: Init successful.
194  * @tc.type: FUNC
195  * @tc.require:
196  */
197 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit001, TestSize.Level1)
198 {
199     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 begin ----");
200     ManagerMock managerMock;
201 
202     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
203     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
204 
205     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 end ----");
206 }
207 
208 /*
209  * @tc.name: SoftbusBroadcastMgrInit002
210  * @tc.desc: Repeated initializations successful.
211  * @tc.type: FUNC
212  * @tc.require:
213  */
214 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit002, TestSize.Level1)
215 {
216     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 begin ----");
217     ManagerMock managerMock;
218 
219     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
220     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
221     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
222 
223     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 end ----");
224 }
225 
226 /*
227  * @tc.name: SoftbusBroadcastMgrDeInit001
228  * @tc.desc: Repeated deinitializations successful.
229  * @tc.type: FUNC
230  * @tc.require:
231  */
232 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit001, TestSize.Level1)
233 {
234     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 begin ----");
235     ManagerMock managerMock;
236 
237     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
238     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
239     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
240 
241     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 end ----");
242 }
243 
244 /*
245  * @tc.name: SoftbusBroadcastMgrDeInit002
246  * @tc.desc: Deinit without initialization.
247  * @tc.type: FUNC
248  * @tc.require:
249  */
250 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit002, TestSize.Level1)
251 {
252     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 begin ----");
253     ManagerMock managerMock;
254 
255     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
256 
257     DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 end ----");
258 }
259 
260 /*
261  * @tc.name: SoftbusBroadcastInterface001
262  * @tc.desc: Calls the interfaces without initialization.
263  * @tc.type: FUNC
264  * @tc.require:
265  */
266 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface001, TestSize.Level1)
267 {
268     DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 begin ----");
269     ManagerMock managerMock;
270 
271     int32_t bcId = -1;
272     int32_t listenerId = -1;
273     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
274     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, UnRegisterBroadcaster(bcId));
275     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
276     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, UnRegisterScanListener(listenerId));
277 
278     BroadcastParam bcParam = {};
279     BroadcastPacket packet = {};
280     BuildBroadcastParam(&bcParam);
281     BuildBroadcastPacketExceptPayload(&packet);
282 
283     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
284     packet.bcData.payload = BC_DATA_PAYLOAD;
285     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
286     packet.rspData.payload = RSP_DATA_PAYLOAD;
287 
288     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StartBroadcasting(bcId, &bcParam, &packet));
289     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, SetBroadcastingData(bcId, &packet));
290     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StopBroadcasting(bcId));
291 
292     BcScanParams scanParam = {};
293     BuildScanParam(&scanParam);
294 
295     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StartScan(listenerId, &scanParam));
296     EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StopScan(listenerId));
297     EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
298 
299     DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 end ----");
300 }
301 
302 /*
303  * @tc.name: SoftbusBroadcastInterface002
304  * @tc.desc: Calls the interface when the function registered is null.
305  * @tc.type: FUNC
306  * @tc.require:
307  */
308 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface002, TestSize.Level1)
309 {
310     DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 begin ----");
311     ManagerMock managerMock;
312     EXPECT_CALL(managerMock, SoftbusBleAdapterInit).WillRepeatedly(ActionOfSoftbusBleAdapterInitNull);
313 
314     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, InitBroadcastMgr());
315     int32_t bcId = -1;
316     int32_t listenerId = -1;
317     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
318     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, UnRegisterBroadcaster(bcId));
319     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
320     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, UnRegisterScanListener(listenerId));
321 
322     BroadcastParam bcParam = {};
323     BroadcastPacket packet = {};
324     BuildBroadcastParam(&bcParam);
325     BuildBroadcastPacketExceptPayload(&packet);
326 
327     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
328     packet.bcData.payload = BC_DATA_PAYLOAD;
329     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
330     packet.rspData.payload = RSP_DATA_PAYLOAD;
331 
332     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartBroadcasting(bcId, &bcParam, &packet));
333     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, SetBroadcastingData(bcId, &packet));
334     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StopBroadcasting(bcId));
335 
336     BcScanParams scanParam = {};
337     BuildScanParam(&scanParam);
338 
339     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartScan(listenerId, &scanParam));
340     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StopScan(listenerId));
341     EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
342 
343     EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, DeInitBroadcastMgr());
344 
345     DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 end ----");
346 }
347 
348 /*
349  * @tc.name: SoftbusBroadcastRegisterBroadcaster001
350  * @tc.desc: Invalid parameter, register broadcaster fail.
351  * @tc.type: FUNC
352  * @tc.require:
353  */
354 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster001, TestSize.Level1)
355 {
356     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 begin ----");
357     ManagerMock managerMock;
358 
359     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
360     int32_t bcId = -1;
361     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV, RegisterBroadcaster(static_cast<BaseServiceType>(SRV_TYPE_INVALID), &bcId,
362         GetBroadcastCallback()));
363     EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, nullptr, GetBroadcastCallback()));
364     EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, nullptr));
365 
366     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
367 
368     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 end ----");
369 }
370 
371 /*
372  * @tc.name: SoftbusBroadcastRegisterBroadcaster002
373  * @tc.desc: Register broadcaster and unregister broadcaster success.
374  * @tc.type: FUNC
375  * @tc.require:
376  */
377 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster002, TestSize.Level1)
378 {
379     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 begin ----");
380     ManagerMock managerMock;
381 
382     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
383     int32_t bcId = -1;
384     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
385     EXPECT_TRUE(bcId >= 0);
386 
387     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
388     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
389 
390     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 end ----");
391 }
392 
393 /*
394  * @tc.name: SoftbusBroadcastRegisterBroadcaster003
395  * @tc.desc: Duplicate registration.
396  * @tc.type: FUNC
397  * @tc.require:
398  */
399 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster003, TestSize.Level1)
400 {
401     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 begin ----");
402     ManagerMock managerMock;
403 
404     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
405     int32_t bcId[BC_NUM_MAX + 1] = {-1};
406     for (int32_t i = 0; i < BC_NUM_MAX; i++) {
407         EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId[i], GetBroadcastCallback()));
408         EXPECT_TRUE(bcId[i] >= 0);
409     }
410 
411     EXPECT_EQ(SOFTBUS_BC_MGR_REG_NO_AVAILABLE_BC_ID, RegisterBroadcaster(SRV_TYPE_DIS, &bcId[BC_NUM_MAX],
412         GetBroadcastCallback()));
413 
414     for (int32_t i = 0; i < BC_NUM_MAX; i++) {
415         EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId[i]));
416     }
417 
418     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
419 
420     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 end ----");
421 }
422 
423 /*
424  * @tc.name: SoftbusBroadcastUnRegisterBroadcaster001
425  * @tc.desc: Unregister without registration.
426  * @tc.type: FUNC
427  * @tc.require:
428  */
429 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster001, TestSize.Level1)
430 {
431     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 begin ----");
432     ManagerMock managerMock;
433 
434     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
435 
436     int32_t invalidId = -1;
437     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
438     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(BC_NUM_MAX));
439     invalidId = 1;
440     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
441 
442     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
443 
444     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 end ----");
445 }
446 
447 /*
448  * @tc.name: SoftbusBroadcastUnRegisterBroadcaster002
449  * @tc.desc: Unregister when broadcasting.
450  * @tc.type: FUNC
451  * @tc.require:
452  */
453 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster002, TestSize.Level1)
454 {
455     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 begin ----");
456     ManagerMock managerMock;
457 
458     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
459 
460     int32_t bcId = -1;
461     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
462     EXPECT_TRUE(bcId >= 0);
463 
464     BroadcastParam bcParam = {};
465     BroadcastPacket packet = {};
466     BuildBroadcastParam(&bcParam);
467     BuildBroadcastPacketExceptPayload(&packet);
468 
469     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
470     packet.bcData.payload = BC_DATA_PAYLOAD;
471     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
472     packet.rspData.payload = RSP_DATA_PAYLOAD;
473     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
474     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
475 
476     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
477 
478     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 end ----");
479 }
480 
481 /*
482  * @tc.name: SoftbusBroadcastRegisterScanListener001
483  * @tc.desc: Invalid parameter, register listener fail.
484  * @tc.type: FUNC
485  * @tc.require:
486  */
487 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener001, TestSize.Level1)
488 {
489     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 begin ----");
490     ManagerMock managerMock;
491 
492     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
493     int32_t listenerId = -1;
494     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV, RegisterScanListener(static_cast<BaseServiceType>(SRV_TYPE_INVALID),
495         &listenerId, GetScanCallback()));
496     EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, nullptr, GetScanCallback()));
497     EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, &listenerId, nullptr));
498 
499     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
500 
501     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 end ----");
502 }
503 
504 /*
505  * @tc.name: SoftbusBroadcastRegisterScanListener002
506  * @tc.desc: Register listener and unregister listener success.
507  * @tc.type: FUNC
508  * @tc.require:
509  */
510 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener002, TestSize.Level1)
511 {
512     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 begin ----");
513     ManagerMock managerMock;
514 
515     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
516     int32_t listenerId = -1;
517     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
518     EXPECT_TRUE(listenerId >= 0);
519 
520     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
521     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
522 
523     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 end ----");
524 }
525 
526 /*
527  * @tc.name: SoftbusBroadcastRegisterScanListener003
528  * @tc.desc: Duplicate registration.
529  * @tc.type: FUNC
530  * @tc.require:
531  */
532 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener003, TestSize.Level1)
533 {
534     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 begin ----");
535     ManagerMock managerMock;
536 
537     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
538     int32_t listenerId = -1;
539     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
540     EXPECT_TRUE(listenerId >= 0);
541     EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
542     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
543 
544     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
545     EXPECT_TRUE(listenerId >= 0);
546     EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
547     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
548 
549     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
550 
551     DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 end ----");
552 }
553 
554 /*
555  * @tc.name: SoftbusBroadcastUnRegisterScanListener001
556  * @tc.desc: Unregister without registration.
557  * @tc.type: FUNC
558  * @tc.require:
559  */
560 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener001, TestSize.Level1)
561 {
562     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 begin ----");
563     ManagerMock managerMock;
564 
565     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
566 
567     int32_t invalidId = -1;
568     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
569     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(SCAN_NUM_MAX));
570     invalidId = 0;
571     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
572 
573     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
574 
575     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 end ----");
576 }
577 
578 /*
579  * @tc.name: SoftbusBroadcastUnRegisterScanListener002
580  * @tc.desc: Unregister when scanning.
581  * @tc.type: FUNC
582  * @tc.require:
583  */
584 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener002, TestSize.Level1)
585 {
586     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 begin ----");
587     ManagerMock managerMock;
588 
589     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
590     int32_t listenerId = -1;
591     uint8_t filterNum = 1;
592     BcScanFilter *filter = GetBcScanFilter();
593     BcScanParams scanParam = {};
594     BuildScanParam(&scanParam);
595 
596     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
597     EXPECT_TRUE(listenerId >= 0);
598 
599     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
600     EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
601 
602     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
603     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
604 
605     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 end ----");
606 }
607 
608 /*
609  * @tc.name: SoftbusBroadcastStartBroadcasting001
610  * @tc.desc: Invalid parameter, start broadcasting fail.
611  * @tc.type: FUNC
612  * @tc.require:
613  */
614 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting001, TestSize.Level1)
615 {
616     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 begin ----");
617     ManagerMock managerMock;
618 
619     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
620 
621     int32_t bcId = -1;
622     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
623     EXPECT_TRUE(bcId >= 0);
624 
625     BroadcastParam bcParam = {};
626     BroadcastPacket packet = {};
627     BuildBroadcastParam(&bcParam);
628     BuildBroadcastPacketExceptPayload(&packet);
629 
630     EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, nullptr, &packet));
631     EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, nullptr));
632     EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, &packet));
633 
634     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
635     packet.bcData.payload = BC_DATA_PAYLOAD;
636     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
637     packet.rspData.payload = RSP_DATA_PAYLOAD;
638     int32_t invalidBcId = -1;
639     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StartBroadcasting(invalidBcId, &bcParam, &packet));
640 
641     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
642 
643     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
644 
645     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 end ----");
646 }
647 
648 /*
649  * @tc.name: SoftbusBroadcastStartBroadcasting002
650  * @tc.desc: Start broadcasting and stop broadcasting success.
651  * @tc.type: FUNC
652  * @tc.require:
653  */
654 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting002, TestSize.Level1)
655 {
656     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 begin ----");
657     ManagerMock managerMock;
658 
659     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
660 
661     int32_t bcId = -1;
662     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
663     EXPECT_TRUE(bcId >= 0);
664 
665     BroadcastParam bcParam = {};
666     BroadcastPacket packet = {};
667     BuildBroadcastParam(&bcParam);
668     BuildBroadcastPacketExceptPayload(&packet);
669 
670     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
671     packet.bcData.payload = BC_DATA_PAYLOAD;
672     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
673     packet.rspData.payload = RSP_DATA_PAYLOAD;
674 
675     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
676     EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
677 
678     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
679     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
680 
681     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 end ----");
682 }
683 
684 /*
685  * @tc.name: SoftbusBroadcastStartBroadcasting003
686  * @tc.desc: Duplicate start broadcasting.
687  * @tc.type: FUNC
688  * @tc.require:
689  */
690 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting003, TestSize.Level1)
691 {
692     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 begin ----");
693     ManagerMock managerMock;
694 
695     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
696 
697     int32_t bcId = -1;
698     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
699     EXPECT_TRUE(bcId >= 0);
700 
701     BroadcastParam bcParam = {};
702     BroadcastPacket packet = {};
703     BuildBroadcastParam(&bcParam);
704     BuildBroadcastPacketExceptPayload(&packet);
705 
706     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
707     packet.bcData.payload = BC_DATA_PAYLOAD;
708     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
709     packet.rspData.payload = RSP_DATA_PAYLOAD;
710 
711     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
712     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
713     EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
714 
715     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
716     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
717 
718     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 end ----");
719 }
720 
721 /*
722  * @tc.name: SoftbusBroadcastUpdateBroadcasting001
723  * @tc.desc: Invalid parameter, update broadcasting fail.
724  * @tc.type: FUNC
725  * @tc.require:
726  */
727 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting001, TestSize.Level1)
728 {
729     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 begin ----");
730     ManagerMock managerMock;
731 
732     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
733 
734     int32_t bcId = -1;
735     BroadcastParam bcParam = {};
736     BroadcastPacket packet = {};
737     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, nullptr, &packet));
738     EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, &bcParam, nullptr));
739 
740     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
741 
742     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 end ----");
743 }
744 
745 /*
746  * @tc.name: SoftbusBroadcastUpdateBroadcasting002
747  * @tc.desc: Update broadcasting success.
748  * @tc.type: FUNC
749  * @tc.require:
750  */
751 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting002, TestSize.Level1)
752 {
753     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 begin ----");
754         ManagerMock managerMock;
755 
756     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
757 
758     int32_t bcId = -1;
759     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
760     EXPECT_TRUE(bcId >= 0);
761 
762     BroadcastParam bcParam = {};
763     BroadcastPacket packet = {};
764     BuildBroadcastParam(&bcParam);
765     BuildBroadcastPacketExceptPayload(&packet);
766 
767     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
768     packet.bcData.payload = BC_DATA_PAYLOAD;
769     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
770     packet.rspData.payload = RSP_DATA_PAYLOAD;
771 
772     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
773     EXPECT_EQ(SOFTBUS_OK, UpdateBroadcasting(bcId, &bcParam, &packet));
774 
775     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
776     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
777 
778     DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 end ----");
779 }
780 
781 /*
782  * @tc.name: SoftbusBroadcastSetBroadcastingData001
783  * @tc.desc: Invalid parameter, set broadcasting data fail.
784  * @tc.type: FUNC
785  * @tc.require:
786  */
787 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData001, TestSize.Level1)
788 {
789     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 begin ----");
790     ManagerMock managerMock;
791 
792     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
793 
794     int32_t invalidId = -1;
795     BroadcastPacket packet = {};
796     EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingData(invalidId, nullptr));
797     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
798     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(BC_NUM_MAX, &packet));
799     invalidId = 0;
800     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
801 
802     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
803 
804     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 end ----");
805 }
806 
807 /*
808  * @tc.name: SoftbusBroadcastSetBroadcastingData002
809  * @tc.desc: Set broadcasting data without start.
810  * @tc.type: FUNC
811  * @tc.require:
812  */
813 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData002, TestSize.Level1)
814 {
815     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 begin ----");
816     ManagerMock managerMock;
817 
818     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
819 
820     int32_t bcId = -1;
821     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
822     EXPECT_TRUE(bcId >= 0);
823 
824     BroadcastPacket packet = {};
825     EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, SetBroadcastingData(bcId, &packet));
826 
827     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
828     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
829 
830     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 end ----");
831 }
832 
833 /*
834  * @tc.name: SoftbusBroadcastSetBroadcastingData003
835  * @tc.desc: Set broadcasting data success.
836  * @tc.type: FUNC
837  * @tc.require:
838  */
839 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData003, TestSize.Level1)
840 {
841     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 begin ----");
842     ManagerMock managerMock;
843 
844     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
845 
846     int32_t bcId = -1;
847     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
848     EXPECT_TRUE(bcId >= 0);
849 
850     BroadcastParam bcParam = {};
851     BroadcastPacket packet = {};
852     BuildBroadcastParam(&bcParam);
853     BuildBroadcastPacketExceptPayload(&packet);
854 
855     packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
856     packet.bcData.payload = BC_DATA_PAYLOAD;
857     packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
858     packet.rspData.payload = RSP_DATA_PAYLOAD;
859 
860     EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
861     EXPECT_EQ(SOFTBUS_OK, SetBroadcastingData(bcId, &packet));
862     EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
863 
864     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
865     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
866 
867     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 end ----");
868 }
869 
870 /*
871  * @tc.name: SoftbusBroadcastStopBroadcasting001
872  * @tc.desc: Invalid parameter, stop broadcasting fail.
873  * @tc.type: FUNC
874  * @tc.require:
875  */
876 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting001, TestSize.Level1)
877 {
878     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 begin ----");
879     ManagerMock managerMock;
880 
881     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
882 
883     int32_t invalidId = -1;
884     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
885     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(BC_NUM_MAX));
886     invalidId = 0;
887     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
888 
889     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
890 
891     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 end ----");
892 }
893 
894 /*
895  * @tc.name: SoftbusBroadcastStopBroadcasting002
896  * @tc.desc: Stop broadcasting without start.
897  * @tc.type: FUNC
898  * @tc.require:
899  */
900 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting002, TestSize.Level1)
901 {
902     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 begin ----");
903     ManagerMock managerMock;
904 
905     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
906     int32_t bcId = -1;
907     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
908     EXPECT_TRUE(bcId >= 0);
909 
910     EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
911 
912     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
913     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
914 
915     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 end ----");
916 }
917 
918 /*
919  * @tc.name: SoftbusBroadcastSetScanFilter001
920  * @tc.desc: Invalid parameter, set filter fail.
921  * @tc.type: FUNC
922  * @tc.require:
923  */
924 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter001, TestSize.Level1)
925 {
926     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 begin ----");
927     ManagerMock managerMock;
928 
929     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
930     int32_t listenerId = -1;
931     uint8_t filterNum = 0;
932     BcScanFilter filter = {};
933     EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, &filter, filterNum));
934 
935     filterNum = 1;
936     EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, nullptr, filterNum));
937     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
938     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(SCAN_NUM_MAX, &filter, filterNum));
939     listenerId = 0;
940     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
941 
942     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
943 
944     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 end ----");
945 }
946 
947 /*
948  * @tc.name: SoftbusBroadcastSetScanFilter002
949  * @tc.desc: Set filter success.
950  * @tc.type: FUNC
951  * @tc.require:
952  */
953 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter002, TestSize.Level1)
954 {
955     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 begin ----");
956     ManagerMock managerMock;
957 
958     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
959     int32_t listenerId = -1;
960     uint8_t filterNum = 1;
961     BcScanFilter *filter = GetBcScanFilter();
962 
963     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
964     EXPECT_TRUE(listenerId >= 0);
965 
966     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
967 
968     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
969     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
970 
971     DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 end ----");
972 }
973 
974 /*
975  * @tc.name: SoftbusBroadcastStartScan001
976  * @tc.desc: Invalid parameter, start scan fail.
977  * @tc.type: FUNC
978  * @tc.require:
979  */
980 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan001, TestSize.Level1)
981 {
982     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 begin ----");
983     ManagerMock managerMock;
984 
985     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
986     int32_t listenerId = -1;
987     BcScanParams scanParam = {};
988     BuildScanParam(&scanParam);
989     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
990 
991     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
992     EXPECT_TRUE(listenerId >= 0);
993     EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartScan(listenerId, nullptr));
994 
995     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
996     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
997 
998     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 end ----");
999 }
1000 
1001 /*
1002  * @tc.name: SoftbusBroadcastStartScan002
1003  * @tc.desc: Start scan without filter.
1004  * @tc.type: FUNC
1005  * @tc.require:
1006  */
1007 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan002, TestSize.Level1)
1008 {
1009     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 begin ----");
1010     ManagerMock managerMock;
1011 
1012     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1013     int32_t listenerId = -1;
1014     BcScanParams scanParam = {};
1015     BuildScanParam(&scanParam);
1016 
1017     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1018     EXPECT_TRUE(listenerId >= 0);
1019     EXPECT_EQ(SOFTBUS_BC_MGR_START_SCAN_NO_FILTER, StartScan(listenerId, &scanParam));
1020 
1021     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1022     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1023 
1024     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 end ----");
1025 }
1026 
1027 /*
1028  * @tc.name: SoftbusBroadcastStartScan003
1029  * @tc.desc: Start scan and stop scan success.
1030  * @tc.type: FUNC
1031  * @tc.require:
1032  */
1033 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan003, TestSize.Level1)
1034 {
1035     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 begin ----");
1036     ManagerMock managerMock;
1037 
1038     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1039     int32_t listenerId = -1;
1040     uint8_t filterNum = 1;
1041     BcScanFilter *filter = GetBcScanFilter();
1042     BcScanParams scanParam = {};
1043     BuildScanParam(&scanParam);
1044 
1045     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1046     EXPECT_TRUE(listenerId >= 0);
1047 
1048     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1049     EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1050     EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1051 
1052     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1053     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1054 
1055     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 end ----");
1056 }
1057 
1058 /*
1059  * @tc.name: SoftbusBroadcastStartScan004
1060  * @tc.desc: Duplicate start scan.
1061  * @tc.type: FUNC
1062  * @tc.require:
1063  */
1064 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan004, TestSize.Level1)
1065 {
1066     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 begin ----");
1067     ManagerMock managerMock;
1068 
1069     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1070     int32_t listenerId = -1;
1071     uint8_t filterNum = 1;
1072     BcScanFilter *filter = GetBcScanFilter();
1073     BcScanParams scanParam = {};
1074     BuildScanParam(&scanParam);
1075 
1076     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1077     EXPECT_TRUE(listenerId >= 0);
1078 
1079     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1080     EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1081     EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1082     EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1083 
1084     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1085     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1086 
1087     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 end ----");
1088 }
1089 
1090 /*
1091  * @tc.name: SoftbusBroadcastStopScan001
1092  * @tc.desc: Invalid parameter, stop scan fail.
1093  * @tc.type: FUNC
1094  * @tc.require:
1095  */
1096 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan001, TestSize.Level1)
1097 {
1098     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 begin ----");
1099     ManagerMock managerMock;
1100 
1101     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1102     int32_t invalidId = -1;
1103     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1104     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(SCAN_NUM_MAX));
1105     invalidId = 0;
1106     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1107 
1108     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1109 
1110     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 end ----");
1111 }
1112 
1113 /*
1114  * @tc.name: SoftbusBroadcastStopScan002
1115  * @tc.desc: Stop scan without start.
1116  * @tc.type: FUNC
1117  * @tc.require:
1118  */
1119 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan002, TestSize.Level1)
1120 {
1121     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 begin ----");
1122     ManagerMock managerMock;
1123 
1124     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1125     int32_t listenerId = -1;
1126     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1127     EXPECT_TRUE(listenerId >= 0);
1128     EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1129 
1130     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1131     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1132 
1133     DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 end ----");
1134 }
1135 
1136 /*
1137  * @tc.name: SoftbusBroadcastScannerTest001
1138  * @tc.desc: Scanner start scan success when new listenerId is added.
1139  * @tc.type: FUNC
1140  * @tc.require:
1141  */
1142 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest001, TestSize.Level1)
1143 {
1144     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 begin ----");
1145     ManagerMock managerMock;
1146 
1147     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1148     int32_t discListenerId = -1;
1149     int32_t connListenerId = -1;
1150     int32_t lpListenerId = -1;
1151     uint8_t filterNum = 1;
1152     BcScanFilter *discFilter = GetBcScanFilter();
1153     BcScanFilter *connFilter = GetBcScanFilter();
1154     BcScanFilter *lpFilter = GetBcScanFilter();
1155     BcScanParams scanParam = {};
1156     BuildScanParam(&scanParam);
1157 
1158     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1159     EXPECT_TRUE(discListenerId >= 0);
1160     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1161     EXPECT_TRUE(connListenerId >= 0);
1162     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1163     EXPECT_TRUE(lpListenerId  >= 0);
1164 
1165     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1166     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1167     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1168 
1169     // First call, start scan.
1170     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1171     // Scanning, new listenerId is added, stop and start.
1172     EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1173     // Another scanner, start scan.
1174     EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1175 
1176     // Another listenerId is scanning, stop and start.
1177     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1178     // Stop scan.
1179     EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1180     // Another scanner, stop scan.
1181     EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1182 
1183     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1184     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1185     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1186 
1187     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1188 
1189     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 end ----");
1190 }
1191 
1192 /*
1193  * @tc.name: SoftbusBroadcastScannerTest002
1194  * @tc.desc: Two Scanner stop and start success without interfering with each other.
1195  * @tc.type: FUNC
1196  * @tc.require:
1197  */
1198 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest002, TestSize.Level1)
1199 {
1200     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 begin ----");
1201     ManagerMock managerMock;
1202 
1203     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1204     int32_t discListenerId = -1;
1205     int32_t connListenerId = -1;
1206     int32_t lpListenerId = -1;
1207     uint8_t filterNum = 1;
1208     BcScanFilter *discFilter = GetBcScanFilter();
1209     BcScanFilter *connFilter = GetBcScanFilter();
1210     BcScanFilter *lpFilter = GetBcScanFilter();
1211     BcScanParams scanParam = {};
1212     BuildScanParam(&scanParam);
1213 
1214     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1215     EXPECT_TRUE(discListenerId >= 0);
1216     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1217     EXPECT_TRUE(connListenerId >= 0);
1218     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1219     EXPECT_TRUE(lpListenerId  >= 0);
1220 
1221     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1222     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1223     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1224 
1225     // First call, start scan.
1226     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1227     // Scanning, new listenerId is added, stop and start.
1228     EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1229     // A listenerId is removed, stop and start.
1230     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1231     // Another scanner, start scan.
1232     EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1233     // Scanning, new listenerId is added, stop and start.
1234     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1235 
1236     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1237     EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1238     EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1239 
1240     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1241     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1242     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1243 
1244     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1245 
1246     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 end ----");
1247 }
1248 
1249 /*
1250  * @tc.name: SoftbusBroadcastScannerTest003
1251  * @tc.desc: Scanner start scan success when updating frequency.
1252  * @tc.type: FUNC
1253  * @tc.require:
1254  */
1255 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest003, TestSize.Level1)
1256 {
1257     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 begin ----");
1258     ManagerMock managerMock;
1259 
1260     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1261     int32_t discListenerId = -1;
1262     uint8_t filterNum = 1;
1263     BcScanFilter *discFilter = GetBcScanFilter();
1264     BcScanParams scanParam = {};
1265     BuildScanParam(&scanParam);
1266 
1267     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1268     EXPECT_TRUE(discListenerId >= 0);
1269 
1270     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1271 
1272     // First call, start scan.
1273     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1274     // Scanning, update frequency, stop and start
1275     scanParam.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
1276     scanParam.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
1277     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1278 
1279     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1280     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1281 
1282     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1283 
1284     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 end ----");
1285 }
1286 
1287 /*
1288  * @tc.name: SoftbusBroadcastScannerTest004
1289  * @tc.desc: Scanner start scan success when setting a new filter.
1290  * @tc.type: FUNC
1291  * @tc.require:
1292  */
1293 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest004, TestSize.Level1)
1294 {
1295     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 begin ----");
1296     ManagerMock managerMock;
1297 
1298     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1299     int32_t discListenerId = -1;
1300     uint8_t filterNum = 1;
1301     BcScanFilter *discFilter = GetBcScanFilter();
1302     BcScanParams scanParam = {};
1303     BuildScanParam(&scanParam);
1304 
1305     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1306     EXPECT_TRUE(discListenerId >= 0);
1307 
1308     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1309 
1310     // First call, start scan.
1311     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1312     // Scanning, set a new filter, stop and start.
1313     // Last filter is released in SetScanFilter.
1314     BcScanFilter *newFilter = GetBcScanFilter();
1315     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, newFilter, filterNum));
1316     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1317 
1318     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1319 
1320     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1321 
1322     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1323 
1324     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 end ----");
1325 }
1326 
1327 /*
1328  * @tc.name: SoftbusBroadcastScannerTest005
1329  * @tc.desc: Scanner not start scan with same params.
1330  * @tc.type: FUNC
1331  * @tc.require:
1332  */
1333 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest005, TestSize.Level1)
1334 {
1335     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 begin ----");
1336     ManagerMock managerMock;
1337 
1338     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1339     int32_t discListenerId = -1;
1340     uint8_t filterNum = 1;
1341     BcScanFilter *discFilter = GetBcScanFilter();
1342     BcScanParams scanParam = {};
1343     BuildScanParam(&scanParam);
1344 
1345     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1346     EXPECT_TRUE(discListenerId >= 0);
1347 
1348     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1349 
1350     // First call, start scan.
1351     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1352     // Scanning, not start with same params.
1353     EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1354 
1355     EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1356 
1357     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1358 
1359     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1360 
1361     DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 end ----");
1362 }
1363 
1364 /*
1365  * @tc.name: TestGetScanFilter001
1366  * @tc.desc: GetScanFilter Error branching
1367  * @tc.type: FUNC
1368  * @tc.require:
1369  */
1370 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter001, TestSize.Level1)
1371 {
1372     DISC_LOGI(DISC_TEST, "TestGetScanFilter001 begin ----");
1373     ManagerMock managerMock;
1374 
1375     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1376     int32_t listenerId = -1;
1377     BcScanFilter *scanFilter = nullptr;
1378     uint8_t filterNum = 0;
1379 
1380     EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, &scanFilter, nullptr));
1381 
1382     filterNum = 1;
1383     EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, nullptr, &filterNum));
1384     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1385     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(SCAN_NUM_MAX, &scanFilter, &filterNum));
1386 
1387     listenerId = 0;
1388     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1389     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1390     DISC_LOGI(DISC_TEST, "TestGetScanFilter001 end ----");
1391 }
1392 
1393 /*
1394  * @tc.name: TestGetScanFilter002
1395  * @tc.desc: GetScanFilter Proper branching
1396  * @tc.type: FUNC
1397  * @tc.require:
1398  */
1399 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter002, TestSize.Level1)
1400 {
1401     DISC_LOGI(DISC_TEST, "TestGetScanFilter002 begin ----");
1402     ManagerMock managerMock;
1403     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1404 
1405     int32_t listenerId = -1;
1406     uint8_t filterNum = 1;
1407     BcScanFilter *filter = GetBcScanFilter();
1408     BcScanFilter *scanFilter = nullptr;
1409     BcScanParams scanParam = {};
1410     BuildScanParam(&scanParam);
1411 
1412     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1413     EXPECT_TRUE(listenerId >= 0);
1414 
1415     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1416     EXPECT_EQ(SOFTBUS_OK, GetScanFilter(listenerId, &scanFilter, &filterNum));
1417     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1418     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1419     DISC_LOGI(DISC_TEST, "TestGetScanFilter002 end ----");
1420 }
1421 
1422 /*
1423  * @tc.name: BroadcastGetBroadcastHandle001
1424  * @tc.desc: BroadcastGetBroadcastHandle Proper branching
1425  * @tc.type: FUNC
1426  * @tc.require:
1427  */
1428 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastGetBroadcastHandle001, TestSize.Level1)
1429 {
1430     DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 begin ----");
1431     ManagerMock managerMock;
1432 
1433     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1434     int32_t bcId = -1;
1435     int32_t Handle = 1;
1436 
1437     EXPECT_EQ(SOFTBUS_INVALID_PARAM, BroadcastGetBroadcastHandle(bcId, &Handle));
1438 
1439     EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1440     EXPECT_TRUE(bcId >= 0);
1441     EXPECT_EQ(SOFTBUS_OK, BroadcastGetBroadcastHandle(bcId, &Handle));
1442     EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1443 
1444     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1445     DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 end ----");
1446 }
1447 
1448 /*
1449  * @tc.name: BroadcastSetScanReportChannelToLpDevice001
1450  * @tc.desc: BroadcastSetScanReportChannelToLpDevice Error branching
1451  * @tc.type: FUNC
1452  * @tc.require:
1453  */
1454 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice001, TestSize.Level1)
1455 {
1456     DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 begin ----");
1457     ManagerMock managerMock;
1458 
1459     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1460     int32_t listenerId = 1;
1461     bool enable = true;
1462 
1463     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1464     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(SCAN_NUM_MAX, false));
1465 
1466     listenerId = 0;
1467     EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1468 
1469     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1470     DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 end ----");
1471 }
1472 
1473 /*
1474  * @tc.name: BroadcastSetScanReportChannelToLpDevice002
1475  * @tc.desc: BroadcastSetScanReportChannelToLpDevice CheckScanIdIsValid is true
1476  * @tc.type: FUNC
1477  * @tc.require:
1478  */
1479 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice002, TestSize.Level1)
1480 {
1481     DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 begin ----");
1482     ManagerMock managerMock;
1483     EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1484 
1485     int32_t listenerId = -1;
1486     uint8_t filterNum = 1;
1487     BcScanFilter *filter = GetBcScanFilter();
1488 
1489     EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1490     EXPECT_TRUE(listenerId >= 0);
1491 
1492     EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1493     EXPECT_EQ(SOFTBUS_OK, BroadcastSetScanReportChannelToLpDevice(listenerId, true));
1494     EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1495 
1496     EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1497     DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 end ----");
1498 }
1499 } // namespace OHOS
1500