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 "securec.h"
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.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 #include "softbus_broadcast_mgr_mock.h"
26
27 using namespace testing::ext;
28 using ::testing::Return;
29 using namespace testing;
30
31 #define BC_ADV_FLAG 0x2
32 #define BC_ADV_TX_POWER_DEFAULT (-6)
33 #define BC_CHANNLE_MAP 0x0
34 #define BC_INTERNAL 48
35 #define MANUFACTURE_COMPANY_ID 0x027D
36 #define SERVICE_UUID 0xFDEE
37 #define SRV_TYPE_INVALID (-1)
38
39 namespace OHOS {
40 const uint8_t *BASE_FUZZ_DATA = nullptr;
41 size_t g_baseFuzzPos;
42 size_t g_baseFuzzSize = 0;
43 const int32_t listenderId = 15;
44
45 class SoftbusBroadcastMgrTest : public testing::Test {
46 public:
SetUpTestCase()47 static void SetUpTestCase()
48 {
49 LooperInit();
50 }
51
TearDownTestCase()52 static void TearDownTestCase()
53 {
54 LooperDeinit();
55 }
56
SetUp()57 void SetUp() override { }
TearDown()58 void TearDown() override { }
59
60 static inline uint8_t BC_DATA_PAYLOAD[] = { 0x04, 0x05, 0x90, 0x00, 0x00, 0x10, 0x00, 0x18, 0xB9, 0x13, 0x3D, 0x28,
61 0xFC, 0x0D, 0x7F, 0xAB, 0x21, 0x00, 0x30, 0x4F, 0x70, 0x65, 0x6E, 0x48 };
62 static inline uint8_t RSP_DATA_PAYLOAD[] = { 0x61, 0x72, 0x6D, 0x6F, 0x6E, 0x79, 0x20, 0x33, 0x2E, 0x32, 0x00 };
63 };
64
ActionOfSoftbusBleAdapterInitNull()65 static void ActionOfSoftbusBleAdapterInitNull()
66 {
67 DISC_LOGI(DISC_TEST, "enter");
68 static SoftbusBroadcastMediumInterface interface = {};
69 if (RegisterBroadcastMediumFunction(BROADCAST_PROTOCOL_BLE, &interface) != 0) {
70 DISC_LOGE(DISC_TEST, "Register gatt interface failed.");
71 }
72 }
73
BuildBroadcastParam(BroadcastParam * bcParam)74 static void BuildBroadcastParam(BroadcastParam *bcParam)
75 {
76 bcParam->minInterval = BC_INTERNAL;
77 bcParam->maxInterval = BC_INTERNAL;
78 bcParam->advType = SOFTBUS_BC_ADV_IND;
79 bcParam->ownAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
80 bcParam->peerAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
81 bcParam->channelMap = BC_CHANNLE_MAP;
82 bcParam->txPower = BC_ADV_TX_POWER_DEFAULT;
83 }
84
BuildBroadcastPacketExceptPayload(BroadcastPacket * packet)85 static void BuildBroadcastPacketExceptPayload(BroadcastPacket *packet)
86 {
87 packet->bcData.type = BC_DATA_TYPE_SERVICE;
88 packet->bcData.id = SERVICE_UUID;
89 packet->rspData.type = BC_DATA_TYPE_MANUFACTURER;
90 packet->rspData.id = MANUFACTURE_COMPANY_ID;
91 packet->isSupportFlag = true;
92 packet->flag = BC_ADV_FLAG;
93 }
94
BuildScanParam(BcScanParams * scanParam)95 static void BuildScanParam(BcScanParams *scanParam)
96 {
97 scanParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
98 scanParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
99 scanParam->scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE;
100 scanParam->scanPhy = SOFTBUS_BC_SCAN_PHY_1M;
101 scanParam->scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL;
102 }
103
ConvertBcParams(const BroadcastParam * srcParam,SoftbusBroadcastParam * dstParam)104 static void ConvertBcParams(const BroadcastParam *srcParam, SoftbusBroadcastParam *dstParam)
105 {
106 DISC_LOGD(DISC_BROADCAST, "enter covert bc param");
107 dstParam->minInterval = srcParam->minInterval;
108 dstParam->maxInterval = srcParam->maxInterval;
109 dstParam->advType = srcParam->advType;
110 dstParam->advFilterPolicy = srcParam->advFilterPolicy;
111 dstParam->ownAddrType = srcParam->ownAddrType;
112 dstParam->peerAddrType = srcParam->peerAddrType;
113 if (memcpy_s(dstParam->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, srcParam->peerAddr.addr, BC_ADDR_MAC_LEN) != EOK) {
114 DISC_LOGE(DISC_BROADCAST, "memcpy peerAddr failed");
115 return;
116 }
117 dstParam->channelMap = srcParam->channelMap;
118 dstParam->duration = srcParam->duration;
119 dstParam->txPower = srcParam->txPower;
120 dstParam->isSupportRpa = srcParam->isSupportRpa;
121 if (memcpy_s(dstParam->ownIrk, SOFTBUS_IRK_LEN, srcParam->ownIrk, BC_IRK_LEN) != EOK) {
122 DISC_LOGE(DISC_BROADCAST, "memcpy ownIrk failed");
123 return;
124 }
125 if (memcpy_s(dstParam->ownUdidHash, SOFTBUS_UDID_HASH_LEN, srcParam->ownUdidHash, BC_UDID_HASH_LEN) != EOK) {
126 DISC_LOGE(DISC_BROADCAST, "memcpy ownUdidHash failed");
127 return;
128 }
129 if (memcpy_s(dstParam->localAddr.addr, BC_ADDR_MAC_LEN, srcParam->localAddr.addr,
130 BC_ADDR_MAC_LEN) != EOK) {
131 DISC_LOGE(DISC_BROADCAST, "memcpy localAddr failed");
132 return;
133 }
134 }
135
GetData()136 template <class T> T GetData()
137 {
138 T object{};
139 size_t objectSize = sizeof(object);
140 if (BASE_FUZZ_DATA == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
141 return object;
142 }
143 errno_t ret = memcpy_s(&object, objectSize, BASE_FUZZ_DATA + g_baseFuzzPos, objectSize);
144 if (ret != EOK) {
145 return {};
146 }
147 g_baseFuzzPos += objectSize;
148 return object;
149 }
150
BuildLpScanParam()151 static LpScanParam BuildLpScanParam()
152 {
153 LpScanParam lpScanParam;
154 g_baseFuzzPos = 0;
155 BcScanParams scanParam;
156 scanParam.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
157 scanParam.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
158 scanParam.scanType = GetData<bool>();
159 scanParam.scanPhy = GetData<uint8_t>() % SOFTBUS_BC_SCAN_PHY_CODED;
160 scanParam.scanFilterPolicy = GetData<uint8_t>() % SOFTBUS_BC_SCAN_FILTER_POLICY_ONLY_WHITE_LIST_AND_RPA;
161 lpScanParam.scanParam = scanParam;
162
163 return lpScanParam;
164 }
165
BuildLpBroadcastParam(LpBroadcastParam * lpBcParam)166 static int32_t BuildLpBroadcastParam(LpBroadcastParam *lpBcParam)
167 {
168 g_baseFuzzPos = 0;
169 lpBcParam->bcHandle = GetData<int32_t>();
170 BuildBroadcastParam(&lpBcParam->bcParam);
171 BuildBroadcastPacketExceptPayload(&lpBcParam->packet);
172 lpBcParam->packet.bcData.payloadLen = sizeof(SoftbusBroadcastMgrTest::BC_DATA_PAYLOAD);
173 lpBcParam->packet.bcData.payload = SoftbusBroadcastMgrTest::BC_DATA_PAYLOAD;
174 lpBcParam->packet.rspData.payloadLen = sizeof(SoftbusBroadcastMgrTest::RSP_DATA_PAYLOAD);
175 lpBcParam->packet.rspData.payload = SoftbusBroadcastMgrTest::RSP_DATA_PAYLOAD;
176 return SOFTBUS_OK;
177 }
178
179 // filter is released in UnRegisterScanListener
GetBcScanFilter(void)180 static BcScanFilter *GetBcScanFilter(void)
181 {
182 unsigned char serviceData[] = { 0x04, 0x05, 0x90 };
183 unsigned char serviceDataMask[] = { 0xFF, 0xFF, 0xFF };
184 int32_t serviceDataLength = sizeof(serviceData);
185
186 BcScanFilter *filter = static_cast<BcScanFilter *>(SoftBusCalloc(sizeof(BcScanFilter)));
187 DISC_CHECK_AND_RETURN_RET_LOGW(filter != nullptr, nullptr, DISC_TEST, "malloc filter failed");
188
189 unsigned char *data = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
190 unsigned char *mask = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
191 if (data == nullptr || mask == nullptr) {
192 goto EXIT;
193 }
194 if (memcpy_s(data, serviceDataLength, serviceData, serviceDataLength) != EOK) {
195 goto EXIT;
196 }
197 if (memcpy_s(mask, serviceDataLength, serviceDataMask, serviceDataLength) != EOK) {
198 goto EXIT;
199 }
200
201 filter->serviceUuid = SERVICE_UUID;
202 filter->serviceData = data;
203 filter->serviceDataMask = mask;
204 filter->serviceDataLength = serviceDataLength;
205 return filter;
206 EXIT:
207 SoftBusFree(filter);
208 SoftBusFree(data);
209 SoftBusFree(mask);
210 return nullptr;
211 }
212
BleBcEnableCallback(int32_t channel,int32_t status)213 static void BleBcEnableCallback(int32_t channel, int32_t status)
214 {
215 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
216 }
217
BleBcDisableCallback(int32_t channel,int32_t status)218 static void BleBcDisableCallback(int32_t channel, int32_t status)
219 {
220 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
221 }
222
BleBcUpdateCallback(int32_t channel,int32_t status)223 static void BleBcUpdateCallback(int32_t channel, int32_t status)
224 {
225 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
226 }
227
BleBcDataCallback(int32_t channel,int32_t status)228 static void BleBcDataCallback(int32_t channel, int32_t status)
229 {
230 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
231 }
232
BcSetBroadcastingParamCallback(int32_t channel,int32_t status)233 static void BcSetBroadcastingParamCallback(int32_t channel, int32_t status)
234 {
235 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
236 }
237
BcDisableBroadcastingCallback(int32_t channel,int32_t status)238 static void BcDisableBroadcastingCallback(int32_t channel, int32_t status)
239 {
240 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
241 }
242
BcEnableBroadcastingCallback(int32_t channel,int32_t status)243 static void BcEnableBroadcastingCallback(int32_t channel, int32_t status)
244 {
245 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
246 }
247
BleOnScanStart(int32_t listenerId,int32_t status)248 static void BleOnScanStart(int32_t listenerId, int32_t status)
249 {
250 (void)listenerId;
251 (void)status;
252 DISC_LOGI(DISC_TEST, "BleOnScanStart");
253 }
254
BleOnScanStop(int32_t listenerId,int32_t status)255 static void BleOnScanStop(int32_t listenerId, int32_t status)
256 {
257 (void)listenerId;
258 (void)status;
259 DISC_LOGI(DISC_TEST, "BleOnScanStop");
260 }
261
BleScanResultCallback(int32_t listenerId,const BroadcastReportInfo * reportInfo)262 static void BleScanResultCallback(int32_t listenerId, const BroadcastReportInfo *reportInfo)
263 {
264 (void)listenerId;
265 }
266
GetBroadcastCallback()267 static BroadcastCallback *GetBroadcastCallback()
268 {
269 static BroadcastCallback g_bcCallback = {
270 .OnStartBroadcastingCallback = BleBcEnableCallback,
271 .OnStopBroadcastingCallback = BleBcDisableCallback,
272 .OnUpdateBroadcastingCallback = BleBcUpdateCallback,
273 .OnSetBroadcastingCallback = BleBcDataCallback,
274 .OnSetBroadcastingParamCallback = BcSetBroadcastingParamCallback,
275 .OnDisableBroadcastingCallback = BcDisableBroadcastingCallback,
276 .OnEnableBroadcastingCallback = BcEnableBroadcastingCallback,
277 };
278 return &g_bcCallback;
279 }
280
GetScanCallback()281 static ScanCallback *GetScanCallback()
282 {
283 static ScanCallback g_scanListener = {
284 .OnStartScanCallback = BleOnScanStart,
285 .OnStopScanCallback = BleOnScanStop,
286 .OnReportScanDataCallback = BleScanResultCallback,
287 };
288 return &g_scanListener;
289 }
290
291 /*
292 * @tc.name: SoftbusBroadcastMgrInit001
293 * @tc.desc: Init successful.
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit001, TestSize.Level1)
298 {
299 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 begin ----");
300 ManagerMock managerMock;
301
302 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
303 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
304
305 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 end ----");
306 }
307
308 /*
309 * @tc.name: SoftbusBroadcastMgrInit002
310 * @tc.desc: Repeated initializations successful.
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit002, TestSize.Level1)
315 {
316 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 begin ----");
317 ManagerMock managerMock;
318
319 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
320 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
321 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
322
323 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 end ----");
324 }
325
326 /*
327 * @tc.name: SoftbusBroadcastMgrInit003
328 * @tc.desc: Init successful.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit003, TestSize.Level1)
333 {
334 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit003 begin ----");
335 ManagerMock managerMock;
336 EXPECT_CALL(managerMock, BleAsyncCallbackDelayHelper)
337 .WillRepeatedly(Return(SOFTBUS_ERR));
338
339 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
340 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
341
342 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit003 end ----");
343 }
344
345 /*
346 * @tc.name: SoftbusBroadcastMgrDeInit001
347 * @tc.desc: Repeated deinitializations successful.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit001, TestSize.Level1)
352 {
353 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 begin ----");
354 ManagerMock managerMock;
355
356 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
357 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
358 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
359
360 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 end ----");
361 }
362
363 /*
364 * @tc.name: SoftbusBroadcastMgrDeInit002
365 * @tc.desc: Deinit without initialization.
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit002, TestSize.Level1)
370 {
371 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 begin ----");
372 ManagerMock managerMock;
373
374 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
375
376 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 end ----");
377 }
378
379 /*
380 * @tc.name: SoftbusBroadcastInterface001
381 * @tc.desc: Calls the interfaces without initialization.
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface001, TestSize.Level1)
386 {
387 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 begin ----");
388 ManagerMock managerMock;
389
390 int32_t bcId = -1;
391 int32_t listenerId = -1;
392 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
393 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
394 EXPECT_EQ(SOFTBUS_LOCK_ERR, UnRegisterBroadcaster(bcId));
395 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
396 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
397 EXPECT_EQ(SOFTBUS_LOCK_ERR, UnRegisterScanListener(listenerId));
398
399 BroadcastParam bcParam = {};
400 BroadcastPacket packet = {};
401 BuildBroadcastParam(&bcParam);
402 BuildBroadcastPacketExceptPayload(&packet);
403
404 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
405 packet.bcData.payload = BC_DATA_PAYLOAD;
406 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
407 packet.rspData.payload = RSP_DATA_PAYLOAD;
408
409 EXPECT_EQ(SOFTBUS_LOCK_ERR, StartBroadcasting(bcId, &bcParam, &packet));
410 EXPECT_EQ(SOFTBUS_LOCK_ERR, SetBroadcastingData(bcId, &packet));
411 EXPECT_EQ(SOFTBUS_LOCK_ERR, StopBroadcasting(bcId));
412
413 BcScanParams scanParam = {};
414 BuildScanParam(&scanParam);
415
416 EXPECT_EQ(SOFTBUS_LOCK_ERR, StartScan(listenerId, &scanParam));
417 EXPECT_EQ(SOFTBUS_LOCK_ERR, StopScan(listenerId));
418 EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
419
420 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 end ----");
421 }
422
423 /*
424 * @tc.name: SoftbusBroadcastInterface002
425 * @tc.desc: Calls the interface when the function registered is null.
426 * @tc.type: FUNC
427 * @tc.require:
428 */
429 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface002, TestSize.Level1)
430 {
431 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 begin ----");
432 ManagerMock managerMock;
433 EXPECT_CALL(managerMock, SoftbusBleAdapterInit).WillRepeatedly(ActionOfSoftbusBleAdapterInitNull);
434
435 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
436 int32_t bcId = -1;
437 int32_t listenerId = -1;
438 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
439 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
440 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(bcId));
441 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
442 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
443 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(listenerId));
444
445 BroadcastParam bcParam = {};
446 BroadcastPacket packet = {};
447 BuildBroadcastParam(&bcParam);
448 BuildBroadcastPacketExceptPayload(&packet);
449
450 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
451 packet.bcData.payload = BC_DATA_PAYLOAD;
452 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
453 packet.rspData.payload = RSP_DATA_PAYLOAD;
454
455 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StartBroadcasting(bcId, &bcParam, &packet));
456 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(bcId, &packet));
457 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(bcId));
458
459 BcScanParams scanParam = {};
460 BuildScanParam(&scanParam);
461
462 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
463 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(listenerId));
464 EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
465
466 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
467
468 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 end ----");
469 }
470
471 /*
472 * @tc.name: SoftbusBroadcastRegisterBroadcaster001
473 * @tc.desc: Invalid parameter, register broadcaster fail.
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster001, TestSize.Level1)
478 {
479 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 begin ----");
480 ManagerMock managerMock;
481
482 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
483 int32_t bcId = -1;
484 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
485 static_cast<BaseServiceType>(SRV_TYPE_INVALID), &bcId, GetBroadcastCallback()));
486 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
487 SRV_TYPE_DIS, nullptr, GetBroadcastCallback()));
488 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, nullptr));
489
490 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
491
492 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 end ----");
493 }
494
495 /*
496 * @tc.name: SoftbusBroadcastRegisterBroadcaster002
497 * @tc.desc: Register broadcaster and unregister broadcaster success.
498 * @tc.type: FUNC
499 * @tc.require:
500 */
501 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster002, TestSize.Level1)
502 {
503 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 begin ----");
504 ManagerMock managerMock;
505
506 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
507 int32_t bcId = -1;
508 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
509 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
510 EXPECT_TRUE(bcId >= 0);
511
512 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
513 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
514
515 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 end ----");
516 }
517
518 /*
519 * @tc.name: SoftbusBroadcastRegisterBroadcaster003
520 * @tc.desc: Duplicate registration.
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster003, TestSize.Level1)
525 {
526 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 begin ----");
527 ManagerMock managerMock;
528
529 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
530 int32_t bcId[BC_NUM_MAX + 1] = { -1 };
531 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
532 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
533 SRV_TYPE_DIS, &bcId[i], GetBroadcastCallback()));
534 EXPECT_TRUE(bcId[i] >= 0);
535 }
536
537 EXPECT_EQ(SOFTBUS_BC_MGR_REG_NO_AVAILABLE_BC_ID,
538 RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId[BC_NUM_MAX], GetBroadcastCallback()));
539
540 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
541 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId[i]));
542 }
543
544 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
545
546 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 end ----");
547 }
548
549 /*
550 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster001
551 * @tc.desc: Unregister without registration.
552 * @tc.type: FUNC
553 * @tc.require:
554 */
555 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster001, TestSize.Level1)
556 {
557 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 begin ----");
558 ManagerMock managerMock;
559
560 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
561
562 int32_t invalidId = -1;
563 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
564 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(BC_NUM_MAX));
565 invalidId = 1;
566 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
567
568 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
569
570 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 end ----");
571 }
572
573 /*
574 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster002
575 * @tc.desc: Unregister when broadcasting.
576 * @tc.type: FUNC
577 * @tc.require:
578 */
579 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster002, TestSize.Level1)
580 {
581 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 begin ----");
582 ManagerMock managerMock;
583
584 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
585
586 int32_t bcId = -1;
587 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
588 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
589 EXPECT_TRUE(bcId >= 0);
590
591 BroadcastParam bcParam = {};
592 BroadcastPacket packet = {};
593 BuildBroadcastParam(&bcParam);
594 BuildBroadcastPacketExceptPayload(&packet);
595
596 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
597 packet.bcData.payload = BC_DATA_PAYLOAD;
598 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
599 packet.rspData.payload = RSP_DATA_PAYLOAD;
600 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
601 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
602
603 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
604
605 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 end ----");
606 }
607
608 /*
609 * @tc.name: SoftbusBroadcastRegisterScanListener001
610 * @tc.desc: Invalid parameter, register listener fail.
611 * @tc.type: FUNC
612 * @tc.require:
613 */
614 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener001, TestSize.Level1)
615 {
616 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 begin ----");
617 ManagerMock managerMock;
618
619 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
620 int32_t listenerId = -1;
621 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
622 static_cast<BaseServiceType>(SRV_TYPE_INVALID), &listenerId, GetScanCallback()));
623 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
624 SRV_TYPE_DIS, nullptr, GetScanCallback()));
625 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &listenerId, nullptr));
626
627 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
628
629 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 end ----");
630 }
631
632 /*
633 * @tc.name: SoftbusBroadcastRegisterScanListener002
634 * @tc.desc: Register listener and unregister listener success.
635 * @tc.type: FUNC
636 * @tc.require:
637 */
638 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener002, TestSize.Level1)
639 {
640 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 begin ----");
641 ManagerMock managerMock;
642
643 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
644 int32_t listenerId = -1;
645 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &listenerId, GetScanCallback()));
646 EXPECT_TRUE(listenerId >= 0);
647
648 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
649 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
650
651 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 end ----");
652 }
653
654 /*
655 * @tc.name: SoftbusBroadcastRegisterScanListener003
656 * @tc.desc: Duplicate registration.
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener003, TestSize.Level1)
661 {
662 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 begin ----");
663 ManagerMock managerMock;
664
665 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
666 int32_t listenerId = -1;
667 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
668 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
669 EXPECT_TRUE(listenerId >= 0);
670 EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
671 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
672 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
673
674 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
675 SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
676 EXPECT_TRUE(listenerId >= 0);
677 EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
678 SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
679 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
680
681 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
682
683 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 end ----");
684 }
685
686 /*
687 * @tc.name: SoftbusBroadcastUnRegisterScanListener001
688 * @tc.desc: Unregister without registration.
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener001, TestSize.Level1)
693 {
694 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 begin ----");
695 ManagerMock managerMock;
696
697 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
698
699 int32_t invalidId = -1;
700 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
701 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(SCAN_NUM_MAX));
702 invalidId = 0;
703 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
704
705 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
706
707 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 end ----");
708 }
709
710 /*
711 * @tc.name: SoftbusBroadcastUnRegisterScanListener002
712 * @tc.desc: Unregister when scanning.
713 * @tc.type: FUNC
714 * @tc.require:
715 */
716 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener002, TestSize.Level1)
717 {
718 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 begin ----");
719 ManagerMock managerMock;
720
721 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
722 int32_t listenerId = -1;
723 uint8_t filterNum = 1;
724 BcScanFilter *filter = GetBcScanFilter();
725 BcScanParams scanParam = {};
726 BuildScanParam(&scanParam);
727
728 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
729 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
730 EXPECT_TRUE(listenerId >= 0);
731
732 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
733 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
734
735 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
736 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
737
738 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 end ----");
739 }
740
741 /*
742 * @tc.name: SoftbusBroadcastStartBroadcasting001
743 * @tc.desc: Invalid parameter, start broadcasting fail.
744 * @tc.type: FUNC
745 * @tc.require:
746 */
747 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting001, TestSize.Level1)
748 {
749 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 begin ----");
750 ManagerMock managerMock;
751
752 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
753
754 int32_t bcId = -1;
755 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
756 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
757 EXPECT_TRUE(bcId >= 0);
758
759 BroadcastParam bcParam = {};
760 BroadcastPacket packet = {};
761 BuildBroadcastParam(&bcParam);
762 BuildBroadcastPacketExceptPayload(&packet);
763
764 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, nullptr, &packet));
765 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, nullptr));
766 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, &packet));
767
768 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
769 packet.bcData.payload = BC_DATA_PAYLOAD;
770 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
771 packet.rspData.payload = RSP_DATA_PAYLOAD;
772 int32_t invalidBcId = -1;
773 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StartBroadcasting(invalidBcId, &bcParam, &packet));
774
775 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
776
777 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
778
779 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 end ----");
780 }
781
782 /*
783 * @tc.name: SoftbusBroadcastStartBroadcasting002
784 * @tc.desc: Start broadcasting and stop broadcasting success.
785 * @tc.type: FUNC
786 * @tc.require:
787 */
788 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting002, TestSize.Level1)
789 {
790 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 begin ----");
791 ManagerMock managerMock;
792
793 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
794
795 int32_t bcId = -1;
796 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE,
797 SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
798 EXPECT_TRUE(bcId >= 0);
799
800 BroadcastParam bcParam = {};
801 BroadcastPacket packet = {};
802 BuildBroadcastParam(&bcParam);
803 BuildBroadcastPacketExceptPayload(&packet);
804
805 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
806 packet.bcData.payload = BC_DATA_PAYLOAD;
807 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
808 packet.rspData.payload = RSP_DATA_PAYLOAD;
809
810 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
811 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
812
813 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
814 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
815
816 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 end ----");
817 }
818
819 /*
820 * @tc.name: SoftbusBroadcastStartBroadcasting003
821 * @tc.desc: Duplicate start broadcasting.
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting003, TestSize.Level1)
826 {
827 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 begin ----");
828 ManagerMock managerMock;
829
830 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
831
832 int32_t bcId = -1;
833 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
834 EXPECT_TRUE(bcId >= 0);
835
836 BroadcastParam bcParam = {};
837 BroadcastPacket packet = {};
838 BuildBroadcastParam(&bcParam);
839 BuildBroadcastPacketExceptPayload(&packet);
840
841 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
842 packet.bcData.payload = BC_DATA_PAYLOAD;
843 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
844 packet.rspData.payload = RSP_DATA_PAYLOAD;
845
846 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
847 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
848 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
849
850 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
851 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
852
853 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 end ----");
854 }
855
856 /*
857 * @tc.name: SoftbusBroadcastUpdateBroadcasting001
858 * @tc.desc: Invalid parameter, update broadcasting fail.
859 * @tc.type: FUNC
860 * @tc.require:
861 */
862 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting001, TestSize.Level1)
863 {
864 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 begin ----");
865 ManagerMock managerMock;
866
867 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
868
869 int32_t bcId = -1;
870 BroadcastParam bcParam = {};
871 BroadcastPacket packet = {};
872 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, nullptr, &packet));
873 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, &bcParam, nullptr));
874
875 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
876
877 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 end ----");
878 }
879
880 /*
881 * @tc.name: SoftbusBroadcastUpdateBroadcasting002
882 * @tc.desc: Update broadcasting success.
883 * @tc.type: FUNC
884 * @tc.require:
885 */
886 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting002, TestSize.Level1)
887 {
888 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 begin ----");
889 ManagerMock managerMock;
890
891 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
892
893 int32_t bcId = -1;
894 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
895 EXPECT_TRUE(bcId >= 0);
896
897 BroadcastParam bcParam = {};
898 BroadcastPacket packet = {};
899 BuildBroadcastParam(&bcParam);
900 BuildBroadcastPacketExceptPayload(&packet);
901
902 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
903 packet.bcData.payload = BC_DATA_PAYLOAD;
904 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
905 packet.rspData.payload = RSP_DATA_PAYLOAD;
906
907 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
908 EXPECT_EQ(SOFTBUS_OK, UpdateBroadcasting(bcId, &bcParam, &packet));
909
910 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
911 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
912
913 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 end ----");
914 }
915
916 /*
917 * @tc.name: SoftbusBroadcastSetBroadcastingData001
918 * @tc.desc: Invalid parameter, set broadcasting data fail.
919 * @tc.type: FUNC
920 * @tc.require:
921 */
922 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData001, TestSize.Level1)
923 {
924 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 begin ----");
925 ManagerMock managerMock;
926
927 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
928
929 int32_t invalidId = -1;
930 BroadcastPacket packet = {};
931 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingData(invalidId, nullptr));
932 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
933 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(BC_NUM_MAX, &packet));
934 invalidId = 0;
935 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
936
937 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
938
939 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 end ----");
940 }
941
942 /*
943 * @tc.name: SoftbusBroadcastSetBroadcastingData002
944 * @tc.desc: Set broadcasting data without start.
945 * @tc.type: FUNC
946 * @tc.require:
947 */
948 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData002, TestSize.Level1)
949 {
950 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 begin ----");
951 ManagerMock managerMock;
952
953 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
954
955 int32_t bcId = -1;
956 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
957 EXPECT_TRUE(bcId >= 0);
958
959 BroadcastPacket packet = {};
960 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, SetBroadcastingData(bcId, &packet));
961
962 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
963 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
964
965 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 end ----");
966 }
967
968 /*
969 * @tc.name: SoftbusBroadcastSetBroadcastingData003
970 * @tc.desc: Set broadcasting data success.
971 * @tc.type: FUNC
972 * @tc.require:
973 */
974 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData003, TestSize.Level1)
975 {
976 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 begin ----");
977 ManagerMock managerMock;
978
979 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
980
981 int32_t bcId = -1;
982 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
983 EXPECT_TRUE(bcId >= 0);
984
985 BroadcastParam bcParam = {};
986 BroadcastPacket packet = {};
987 BuildBroadcastParam(&bcParam);
988 BuildBroadcastPacketExceptPayload(&packet);
989
990 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
991 packet.bcData.payload = BC_DATA_PAYLOAD;
992 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
993 packet.rspData.payload = RSP_DATA_PAYLOAD;
994
995 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
996 EXPECT_EQ(SOFTBUS_OK, SetBroadcastingData(bcId, &packet));
997 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
998
999 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1000 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1001
1002 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 end ----");
1003 }
1004
1005 /*
1006 * @tc.name: SoftbusBroadcastSetBroadcastingParam001
1007 * @tc.desc: Invalid parameter, set broadcasting param fail.
1008 * @tc.type: FUNC
1009 * @tc.require:
1010 */
1011 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingParam001, TestSize.Level1)
1012 {
1013 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam001 begin ----");
1014 ManagerMock managerMock;
1015
1016 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1017
1018 int32_t invalidId = -1;
1019 BroadcastParam param = {};
1020
1021 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingParam(invalidId, nullptr));
1022 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(invalidId, ¶m));
1023 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(BC_NUM_MAX, ¶m));
1024 invalidId = 0;
1025 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(invalidId, ¶m));
1026
1027 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1028
1029 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam001 end ----");
1030 }
1031
1032 /*
1033 * @tc.name: SoftbusBroadcastSetBroadcastingParam002
1034 * @tc.desc: Set broadcasting param without start.
1035 * @tc.type: FUNC
1036 * @tc.require:
1037 */
1038 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingParam002, TestSize.Level1)
1039 {
1040 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam002 begin ----");
1041 ManagerMock managerMock;
1042
1043 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1044
1045 int32_t bcId = -1;
1046 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1047 EXPECT_TRUE(bcId >= 0);
1048
1049 BroadcastParam param = {};
1050 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, SetBroadcastingParam(bcId, ¶m));
1051
1052 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1053 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1054
1055 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam002 end ----");
1056 }
1057
1058 /*
1059 * @tc.name: SoftbusBroadcastStopBroadcasting001
1060 * @tc.desc: Invalid parameter, stop broadcasting fail.
1061 * @tc.type: FUNC
1062 * @tc.require:
1063 */
1064 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting001, TestSize.Level1)
1065 {
1066 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 begin ----");
1067 ManagerMock managerMock;
1068
1069 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1070
1071 int32_t invalidId = -1;
1072 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
1073 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(BC_NUM_MAX));
1074 invalidId = 0;
1075 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
1076
1077 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1078
1079 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 end ----");
1080 }
1081
1082 /*
1083 * @tc.name: SoftbusBroadcastStopBroadcasting002
1084 * @tc.desc: Stop broadcasting without start.
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting002, TestSize.Level1)
1089 {
1090 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 begin ----");
1091 ManagerMock managerMock;
1092
1093 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1094 int32_t bcId = -1;
1095 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1096 EXPECT_TRUE(bcId >= 0);
1097
1098 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
1099
1100 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1101 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1102
1103 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 end ----");
1104 }
1105
1106 /*
1107 * @tc.name: SoftbusBroadcastSetScanFilter001
1108 * @tc.desc: Invalid parameter, set filter fail.
1109 * @tc.type: FUNC
1110 * @tc.require:
1111 */
1112 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter001, TestSize.Level1)
1113 {
1114 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 begin ----");
1115 ManagerMock managerMock;
1116
1117 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1118 int32_t listenerId = -1;
1119 uint8_t filterNum = 0;
1120 BcScanFilter filter = {};
1121 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, &filter, filterNum));
1122
1123 filterNum = 1;
1124 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, nullptr, filterNum));
1125 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
1126 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(SCAN_NUM_MAX, &filter, filterNum));
1127 listenerId = 0;
1128 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
1129
1130 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1131
1132 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 end ----");
1133 }
1134
1135 /*
1136 * @tc.name: SoftbusBroadcastSetScanFilter002
1137 * @tc.desc: Set filter success.
1138 * @tc.type: FUNC
1139 * @tc.require:
1140 */
1141 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter002, TestSize.Level1)
1142 {
1143 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 begin ----");
1144 ManagerMock managerMock;
1145
1146 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1147 int32_t listenerId = -1;
1148 uint8_t filterNum = 1;
1149 BcScanFilter *filter = GetBcScanFilter();
1150
1151 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1152 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1153 EXPECT_TRUE(listenerId >= 0);
1154
1155 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1156
1157 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1158 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1159
1160 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 end ----");
1161 }
1162
1163 /*
1164 * @tc.name: SoftbusBroadcastStartScan001
1165 * @tc.desc: Invalid parameter, start scan fail.
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan001, TestSize.Level1)
1170 {
1171 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 begin ----");
1172 ManagerMock managerMock;
1173
1174 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1175 int32_t listenerId = -1;
1176 BcScanParams scanParam = {};
1177 BuildScanParam(&scanParam);
1178 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
1179
1180 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1181 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1182 EXPECT_TRUE(listenerId >= 0);
1183 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartScan(listenerId, nullptr));
1184
1185 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1186 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1187
1188 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 end ----");
1189 }
1190
1191 /*
1192 * @tc.name: SoftbusBroadcastStartScan002
1193 * @tc.desc: Start scan without filter.
1194 * @tc.type: FUNC
1195 * @tc.require:
1196 */
1197 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan002, TestSize.Level1)
1198 {
1199 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 begin ----");
1200 ManagerMock managerMock;
1201
1202 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1203 int32_t listenerId = -1;
1204 BcScanParams scanParam = {};
1205 BuildScanParam(&scanParam);
1206
1207 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1208 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1209 EXPECT_TRUE(listenerId >= 0);
1210 int32_t ret = StartScan(listenerId, &scanParam);
1211 EXPECT_EQ(ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_BC_MGR_START_SCAN_NO_FILTER, true);
1212
1213 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1214 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1215
1216 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 end ----");
1217 }
1218
1219 /*
1220 * @tc.name: SoftbusBroadcastStartScan003
1221 * @tc.desc: Start scan and stop scan success.
1222 * @tc.type: FUNC
1223 * @tc.require:
1224 */
1225 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan003, TestSize.Level1)
1226 {
1227 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 begin ----");
1228 ManagerMock managerMock;
1229
1230 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1231 int32_t listenerId = -1;
1232 uint8_t filterNum = 1;
1233 BcScanFilter *filter = GetBcScanFilter();
1234 BcScanParams scanParam = {};
1235 BuildScanParam(&scanParam);
1236
1237 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1238 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1239 EXPECT_TRUE(listenerId >= 0);
1240
1241 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1242 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1243 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1244
1245 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1246 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1247
1248 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 end ----");
1249 }
1250
1251 /*
1252 * @tc.name: SoftbusBroadcastStartScan004
1253 * @tc.desc: Duplicate start scan.
1254 * @tc.type: FUNC
1255 * @tc.require:
1256 */
1257 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan004, TestSize.Level1)
1258 {
1259 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 begin ----");
1260 ManagerMock managerMock;
1261 EXPECT_CALL(managerMock, SoftbusBleAdapterInit).WillRepeatedly(ActionOfSoftbusBleAdapterInitNull);
1262
1263 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1264
1265 int32_t listenerId = -1;
1266 uint8_t filterNum = 1;
1267 BcScanFilter *filter = GetBcScanFilter();
1268 BcScanParams scanParam = {};
1269 BuildScanParam(&scanParam);
1270
1271 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1272 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1273
1274 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, filter, filterNum));
1275 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
1276 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
1277 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(listenerId));
1278
1279 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(listenerId));
1280 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1281
1282 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 end ----");
1283 }
1284
1285 /*
1286 * @tc.name: SoftbusBroadcastStartScan005
1287 * @tc.desc: freq is SCAN_FREQ_P2_30_1500
1288 * @tc.type: FUNC
1289 * @tc.require:
1290 */
1291 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan005, TestSize.Level1)
1292 {
1293 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan005 begin ----");
1294 ManagerMock managerMock;
1295
1296 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1297 int32_t listenerId = -1;
1298 uint8_t filterNum = 1;
1299 BcScanFilter *filter = GetBcScanFilter();
1300 BcScanParams scanParam = {};
1301 BuildScanParam(&scanParam);
1302 // SCAN_FREQ_P2_30_1500
1303 scanParam.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2_FAST;
1304 scanParam.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2_FAST;
1305 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1306 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1307 EXPECT_TRUE(listenerId >= 0);
1308
1309 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1310 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1311 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1312
1313 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1314 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1315 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan005 end ----");
1316 }
1317
1318 /*
1319 * @tc.name: SoftbusBroadcastStartScan006
1320 * @tc.desc: freq is SCAN_FREQ_LOW_POWER
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan006, TestSize.Level1)
1325 {
1326 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan006 begin ----");
1327 ManagerMock managerMock;
1328
1329 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1330 int32_t listenerId = -1;
1331 uint8_t filterNum = 1;
1332 BcScanFilter *filter = GetBcScanFilter();
1333 BcScanParams scanParam = {};
1334 BuildScanParam(&scanParam);
1335 // SCAN_FREQ_LOW_POWER
1336 scanParam.scanInterval = 0;
1337 scanParam.scanWindow = 0;
1338 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1339 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1340 EXPECT_TRUE(listenerId >= 0);
1341
1342 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1343 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1344 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1345
1346 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1347 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1348
1349 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan006 end ----");
1350 }
1351
1352 /*
1353 * @tc.name: SoftbusBroadcastStopScan001
1354 * @tc.desc: Invalid parameter, stop scan fail.
1355 * @tc.type: FUNC
1356 * @tc.require:
1357 */
1358 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan001, TestSize.Level1)
1359 {
1360 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 begin ----");
1361 ManagerMock managerMock;
1362
1363 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1364 int32_t invalidId = -1;
1365 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1366 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(SCAN_NUM_MAX));
1367 invalidId = 0;
1368 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1369
1370 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1371
1372 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 end ----");
1373 }
1374
1375 /*
1376 * @tc.name: SoftbusBroadcastStopScan002
1377 * @tc.desc: Stop scan without start.
1378 * @tc.type: FUNC
1379 * @tc.require:
1380 */
1381 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan002, TestSize.Level1)
1382 {
1383 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 begin ----");
1384 ManagerMock managerMock;
1385
1386 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1387 int32_t listenerId = -1;
1388 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1389 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1390 EXPECT_TRUE(listenerId >= 0);
1391 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1392
1393 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1394 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1395
1396 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 end ----");
1397 }
1398
1399 /*
1400 * @tc.name: SoftbusBroadcastScannerTest001
1401 * @tc.desc: Scanner start scan success when new listenerId is added.
1402 * @tc.type: FUNC
1403 * @tc.require:
1404 */
1405 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest001, TestSize.Level1)
1406 {
1407 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 begin ----");
1408 ManagerMock managerMock;
1409
1410 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1411 int32_t discListenerId = -1;
1412 int32_t connListenerId = -1;
1413 int32_t lpListenerId = -1;
1414 uint8_t filterNum = 1;
1415 BcScanFilter *discFilter = GetBcScanFilter();
1416 BcScanFilter *connFilter = GetBcScanFilter();
1417 BcScanFilter *lpFilter = GetBcScanFilter();
1418 BcScanParams scanParam = {};
1419 BuildScanParam(&scanParam);
1420
1421 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1422 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1423 EXPECT_TRUE(discListenerId >= 0);
1424 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1425 SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1426 EXPECT_TRUE(connListenerId >= 0);
1427 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1428 SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1429 EXPECT_TRUE(lpListenerId >= 0);
1430
1431 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1432 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1433 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1434
1435 // First call, start scan.
1436 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1437 // Scanning, new listenerId is added, stop and start.
1438 EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1439 // Another scanner, start scan.
1440 EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1441
1442 // Another listenerId is scanning, stop and start.
1443 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1444 // Stop scan.
1445 EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1446 // Another scanner, stop scan.
1447 EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1448
1449 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1450 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1451 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1452
1453 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1454
1455 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 end ----");
1456 }
1457
1458 /*
1459 * @tc.name: SoftbusBroadcastScannerTest002
1460 * @tc.desc: Two Scanner stop and start success without interfering with each other.
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest002, TestSize.Level1)
1465 {
1466 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 begin ----");
1467 ManagerMock managerMock;
1468
1469 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1470 int32_t discListenerId = -1;
1471 int32_t connListenerId = -1;
1472 int32_t lpListenerId = -1;
1473 uint8_t filterNum = 1;
1474 BcScanFilter *discFilter = GetBcScanFilter();
1475 BcScanFilter *connFilter = GetBcScanFilter();
1476 BcScanFilter *lpFilter = GetBcScanFilter();
1477 BcScanParams scanParam = {};
1478 BuildScanParam(&scanParam);
1479
1480 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1481 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1482 EXPECT_TRUE(discListenerId >= 0);
1483 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1484 SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1485 EXPECT_TRUE(connListenerId >= 0);
1486 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1487 SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1488 EXPECT_TRUE(lpListenerId >= 0);
1489
1490 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1491 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1492 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1493
1494 // First call, start scan.
1495 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1496 // Scanning, new listenerId is added, stop and start.
1497 EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1498 // A listenerId is removed, stop and start.
1499 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1500 // Another scanner, start scan.
1501 EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1502 // Scanning, new listenerId is added, stop and start.
1503 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1504
1505 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1506 EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1507 EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1508
1509 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1510 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1511 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1512
1513 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1514
1515 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 end ----");
1516 }
1517
1518 /*
1519 * @tc.name: SoftbusBroadcastScannerTest003
1520 * @tc.desc: Scanner start scan success when updating frequency.
1521 * @tc.type: FUNC
1522 * @tc.require:
1523 */
1524 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest003, TestSize.Level1)
1525 {
1526 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 begin ----");
1527 ManagerMock managerMock;
1528
1529 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1530 int32_t discListenerId = -1;
1531 uint8_t filterNum = 1;
1532 BcScanFilter *discFilter = GetBcScanFilter();
1533 BcScanParams scanParam = {};
1534 BuildScanParam(&scanParam);
1535
1536 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1537 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1538 EXPECT_TRUE(discListenerId >= 0);
1539
1540 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1541
1542 // First call, start scan.
1543 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1544 // Scanning, update frequency, stop and start
1545 scanParam.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
1546 scanParam.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
1547 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1548
1549 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1550 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1551
1552 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1553
1554 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 end ----");
1555 }
1556
1557 /*
1558 * @tc.name: SoftbusBroadcastScannerTest004
1559 * @tc.desc: Scanner start scan success when setting a new filter.
1560 * @tc.type: FUNC
1561 * @tc.require:
1562 */
1563 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest004, TestSize.Level1)
1564 {
1565 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 begin ----");
1566 ManagerMock managerMock;
1567
1568 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1569 int32_t discListenerId = -1;
1570 uint8_t filterNum = 1;
1571 BcScanFilter *discFilter = GetBcScanFilter();
1572 BcScanParams scanParam = {};
1573 BuildScanParam(&scanParam);
1574
1575 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1576 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1577 EXPECT_TRUE(discListenerId >= 0);
1578
1579 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1580
1581 // First call, start scan.
1582 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1583 // Scanning, set a new filter, stop and start.
1584 // Last filter is released in SetScanFilter.
1585 BcScanFilter *newFilter = GetBcScanFilter();
1586 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, newFilter, filterNum));
1587 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1588
1589 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1590
1591 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1592
1593 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1594
1595 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 end ----");
1596 }
1597
1598 /*
1599 * @tc.name: SoftbusBroadcastScannerTest005
1600 * @tc.desc: Scanner not start scan with same params.
1601 * @tc.type: FUNC
1602 * @tc.require:
1603 */
1604 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest005, TestSize.Level1)
1605 {
1606 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 begin ----");
1607 ManagerMock managerMock;
1608
1609 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1610 int32_t discListenerId = -1;
1611 uint8_t filterNum = 1;
1612 BcScanFilter *discFilter = GetBcScanFilter();
1613 BcScanParams scanParam = {};
1614 BuildScanParam(&scanParam);
1615
1616 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1617 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1618 EXPECT_TRUE(discListenerId >= 0);
1619
1620 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1621
1622 // First call, start scan.
1623 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1624 // Scanning, not start with same params.
1625 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1626
1627 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1628
1629 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1630
1631 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1632
1633 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 end ----");
1634 }
1635
1636 /*
1637 * @tc.name: SoftbusBroadcastScannerTest006
1638 * @tc.desc: StartScan -> StartScanStub -> CheckChannelScan addSize == deleteSize
1639 * @tc.type: FUNC
1640 * @tc.require:
1641 */
1642 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest006, TestSize.Level1)
1643 {
1644 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest006 begin ----");
1645 ManagerMock managerMock;
1646
1647 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1648 int32_t discListenerId = -1;
1649 uint8_t filterNum = 2;
1650
1651 BcScanFilter *firstDiscFilter = (BcScanFilter *)SoftBusCalloc(sizeof(BcScanFilter) * filterNum);
1652 firstDiscFilter[0] = *GetBcScanFilter();
1653 firstDiscFilter[1] = *GetBcScanFilter();
1654 unsigned char serviceData1[] = { 0x06, 0x05, 0x90 };
1655 EXPECT_EQ(EOK, memcpy_s(firstDiscFilter[1].serviceData, sizeof(serviceData1), serviceData1, sizeof(serviceData1)));
1656
1657 BcScanFilter *secondDiscFilter = (BcScanFilter *)SoftBusCalloc(sizeof(BcScanFilter) * filterNum);
1658 secondDiscFilter[0] = *GetBcScanFilter();
1659 secondDiscFilter[1] = *GetBcScanFilter();
1660 unsigned char serviceData2[] = { 0x05, 0x05, 0x90 };
1661 EXPECT_EQ(EOK, memcpy_s(secondDiscFilter[1].serviceData, sizeof(serviceData2), serviceData2, sizeof(serviceData2)));
1662
1663 BcScanParams scanParam = {};
1664 BuildScanParam(&scanParam);
1665
1666 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1667 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1668 EXPECT_TRUE(discListenerId >= 0);
1669 // First SetScanFilter call
1670 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, firstDiscFilter, filterNum));
1671 // First StartScan call, set isScanning = true, isFliterChanged = false
1672 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1673 // Second SetScanFilter call, must be different filter, set isScanning = true, isFliterChanged = true
1674 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, secondDiscFilter, filterNum));
1675 // Second StartScan
1676 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1677
1678 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1679
1680 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1681
1682 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1683
1684 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest006 end ----");
1685 }
1686
1687 /*
1688 * @tc.name: SoftbusBroadcastScannerTest007
1689 * @tc.desc: StartScan -> StartScanStub -> CheckChannelScan -> CheckNotScaning
1690 * @tc.type: FUNC
1691 * @tc.require:
1692 */
1693 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest007, TestSize.Level1)
1694 {
1695 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest007 begin ----");
1696 ManagerMock managerMock;
1697
1698 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1699 int32_t discListenerId = -1;
1700 uint8_t filterNum = 2;
1701 uint8_t secondFilterNum = 3;
1702
1703 BcScanFilter *firstDiscFilter = (BcScanFilter *)SoftBusCalloc(sizeof(BcScanFilter) * filterNum);
1704 firstDiscFilter[0] = *GetBcScanFilter();
1705 firstDiscFilter[1] = *GetBcScanFilter();
1706 unsigned char serviceData1[] = { 0x05, 0x05, 0x90 };
1707 EXPECT_EQ(EOK, memcpy_s(firstDiscFilter[1].serviceData, sizeof(serviceData1), serviceData1, sizeof(serviceData1)));
1708
1709 BcScanFilter *secondDiscFilter = (BcScanFilter *)SoftBusCalloc(sizeof(BcScanFilter) * secondFilterNum);
1710 secondDiscFilter[0] = *GetBcScanFilter();
1711 secondDiscFilter[1] = *GetBcScanFilter();
1712 secondDiscFilter[2] = *GetBcScanFilter();
1713 unsigned char serviceData2[] = { 0x06, 0x05, 0x90 };
1714 EXPECT_EQ(EOK, memcpy_s(secondDiscFilter[1].serviceData, sizeof(serviceData2), serviceData2, sizeof(serviceData2)));
1715 unsigned char serviceData3[] = { 0x07, 0x05, 0x90 };
1716 EXPECT_EQ(EOK, memcpy_s(secondDiscFilter[2].serviceData, sizeof(serviceData3), serviceData3, sizeof(serviceData3)));
1717
1718 BcScanParams scanParam = {};
1719 BuildScanParam(&scanParam);
1720
1721 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1722 SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1723 EXPECT_TRUE(discListenerId >= 0);
1724 // First SetScanFilter call
1725 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, firstDiscFilter, filterNum));
1726 // First StartScan call, set isScanning = true, isFliterChanged = false
1727 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1728 // Second SetScanFilter call, must be different filter, set isScanning = true, isFliterChanged = true
1729 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, secondDiscFilter, secondFilterNum));
1730 // Second StartScan
1731 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1732
1733 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1734
1735 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1736
1737 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1738
1739 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest007 end ----");
1740 }
1741
1742 /*
1743 * @tc.name: TestGetScanFilter001
1744 * @tc.desc: GetScanFilter Error branching
1745 * @tc.type: FUNC
1746 * @tc.require:
1747 */
1748 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter001, TestSize.Level1)
1749 {
1750 DISC_LOGI(DISC_TEST, "TestGetScanFilter001 begin ----");
1751 ManagerMock managerMock;
1752
1753 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1754 int32_t listenerId = -1;
1755 BcScanFilter *scanFilter = nullptr;
1756 uint8_t filterNum = 0;
1757
1758 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, &scanFilter, nullptr));
1759
1760 filterNum = 1;
1761 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, nullptr, &filterNum));
1762 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1763 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(SCAN_NUM_MAX, &scanFilter, &filterNum));
1764
1765 listenerId = 0;
1766 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1767 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1768 DISC_LOGI(DISC_TEST, "TestGetScanFilter001 end ----");
1769 }
1770
1771 /*
1772 * @tc.name: TestGetScanFilter002
1773 * @tc.desc: GetScanFilter Proper branching
1774 * @tc.type: FUNC
1775 * @tc.require:
1776 */
1777 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter002, TestSize.Level1)
1778 {
1779 DISC_LOGI(DISC_TEST, "TestGetScanFilter002 begin ----");
1780 ManagerMock managerMock;
1781 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1782
1783 int32_t listenerId = -1;
1784 uint8_t filterNum = 1;
1785 BcScanFilter *filter = GetBcScanFilter();
1786 BcScanFilter *scanFilter = nullptr;
1787 BcScanParams scanParam = {};
1788 BuildScanParam(&scanParam);
1789
1790 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1791 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1792 EXPECT_TRUE(listenerId >= 0);
1793
1794 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1795 EXPECT_EQ(SOFTBUS_OK, GetScanFilter(listenerId, &scanFilter, &filterNum));
1796 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1797 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1798 DISC_LOGI(DISC_TEST, "TestGetScanFilter002 end ----");
1799 }
1800
1801 /*
1802 * @tc.name: BroadcastGetBroadcastHandle001
1803 * @tc.desc: BroadcastGetBroadcastHandle Proper branching
1804 * @tc.type: FUNC
1805 * @tc.require:
1806 */
1807 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastGetBroadcastHandle001, TestSize.Level1)
1808 {
1809 DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 begin ----");
1810 ManagerMock managerMock;
1811
1812 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1813 int32_t bcId = -1;
1814 int32_t Handle = 1;
1815
1816 EXPECT_EQ(SOFTBUS_INVALID_PARAM, BroadcastGetBroadcastHandle(bcId, &Handle));
1817
1818 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1819 EXPECT_TRUE(bcId >= 0);
1820 EXPECT_EQ(SOFTBUS_OK, BroadcastGetBroadcastHandle(bcId, &Handle));
1821 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1822
1823 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1824 DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 end ----");
1825 }
1826
1827 /*
1828 * @tc.name: BroadcastSetScanReportChannelToLpDevice001
1829 * @tc.desc: BroadcastSetScanReportChannelToLpDevice Error branching
1830 * @tc.type: FUNC
1831 * @tc.require:
1832 */
1833 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice001, TestSize.Level1)
1834 {
1835 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 begin ----");
1836 ManagerMock managerMock;
1837
1838 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1839 int32_t listenerId = 1;
1840 bool enable = true;
1841
1842 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1843 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(SCAN_NUM_MAX, false));
1844
1845 listenerId = 0;
1846 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1847
1848 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1849 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 end ----");
1850 }
1851
1852 /*
1853 * @tc.name: BroadcastSetScanReportChannelToLpDevice002
1854 * @tc.desc: BroadcastSetScanReportChannelToLpDevice CheckScanIdIsValid is true
1855 * @tc.type: FUNC
1856 * @tc.require:
1857 */
1858 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice002, TestSize.Level1)
1859 {
1860 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 begin ----");
1861 ManagerMock managerMock;
1862 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1863
1864 int32_t listenerId = -1;
1865 uint8_t filterNum = 1;
1866 BcScanFilter *filter = GetBcScanFilter();
1867
1868 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
1869 SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1870 EXPECT_TRUE(listenerId >= 0);
1871
1872 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1873 EXPECT_EQ(SOFTBUS_OK, BroadcastSetScanReportChannelToLpDevice(listenerId, true));
1874 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1875
1876 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1877 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 end ----");
1878 }
1879
1880 /*
1881 * @tc.name: CompareSameFilter001
1882 * @tc.desc: CompareSameFilter001 CompareSameFilter is FALSE
1883 * @tc.type: FUNC
1884 * @tc.require:
1885 */
1886 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter001, TestSize.Level1)
1887 {
1888 DISC_LOGI(DISC_TEST, "CompareSameFilter001 begin ----");
1889 ManagerMock managerMock;
1890
1891 EXPECT_FALSE(CompareSameFilter(NULL, NULL));
1892
1893 DISC_LOGI(DISC_TEST, "CompareSameFilter001 end ----");
1894 }
1895
1896 /*
1897 * @tc.name: CompareSameFilter002
1898 * @tc.desc: CompareSameFilter002 CompareSameFilter is FALSE
1899 * @tc.type: FUNC
1900 * @tc.require:
1901 */
1902 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter002, TestSize.Level1)
1903 {
1904 DISC_LOGI(DISC_TEST, "CompareSameFilter002 begin ----");
1905 ManagerMock managerMock;
1906 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1907 BcScanFilter *filter = GetBcScanFilter();
1908
1909 EXPECT_FALSE(CompareSameFilter(filter, NULL));
1910
1911 DISC_LOGI(DISC_TEST, "CompareSameFilter002 end ----");
1912 }
1913
1914 /*
1915 * @tc.name: CompareSameFilter003
1916 * @tc.desc: CompareSameFilter003 CompareSameFilter is TRUE
1917 * @tc.type: FUNC
1918 * @tc.require:
1919 */
1920 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter003, TestSize.Level1)
1921 {
1922 DISC_LOGI(DISC_TEST, "CompareSameFilter003 begin ----");
1923 ManagerMock managerMock;
1924 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1925 BcScanFilter *filter = GetBcScanFilter();
1926 BcScanFilter *filter2 = GetBcScanFilter();
1927
1928 EXPECT_TRUE(CompareSameFilter(filter, filter2));
1929
1930 DISC_LOGI(DISC_TEST, "CompareSameFilter003 end ----");
1931 }
1932
1933 /*
1934 * @tc.name: CompareSameFilter004
1935 * @tc.desc: CompareSameFilter004 CompareSameFilter is FALSE
1936 * @tc.type: FUNC
1937 * @tc.require:
1938 */
1939 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter004, TestSize.Level1)
1940 {
1941 DISC_LOGI(DISC_TEST, "CompareSameFilter004 begin ----");
1942 ManagerMock managerMock;
1943 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1944 BcScanFilter *filter = GetBcScanFilter();
1945 BcScanFilter *filter2 = GetBcScanFilter();
1946
1947 BcScanFilter srcFilter = *filter;
1948 BcScanFilter dstFilter = *filter2;
1949 if (srcFilter.serviceData != NULL && dstFilter.serviceData != NULL &&
1950 srcFilter.serviceDataMask != NULL && dstFilter.serviceDataMask != NULL &&
1951 memcmp(srcFilter.serviceData, dstFilter.serviceData, srcFilter.serviceDataLength) == 0 &&
1952 memcmp(srcFilter.serviceDataMask, dstFilter.serviceDataMask, srcFilter.serviceDataLength) == 0) {
1953 std::cout << "srcFilter.serviceData != NULL" << std::endl;
1954 srcFilter.serviceData = NULL;
1955 dstFilter.serviceData = NULL;
1956 srcFilter.serviceDataMask = NULL;
1957 dstFilter.serviceDataMask = NULL;
1958 }
1959
1960 if (srcFilter.manufactureData == NULL && dstFilter.manufactureData == NULL &&
1961 srcFilter.manufactureDataMask == NULL && dstFilter.manufactureDataMask == NULL) {
1962 std::cout << "srcFilter.manufactureData == NULL" << std::endl;
1963 uint8_t test[] = {1, 2};
1964 srcFilter.manufactureDataLength = sizeof(test) / sizeof(test[0]);
1965 srcFilter.manufactureData = test;
1966 srcFilter.manufactureDataMask = test;
1967 dstFilter.manufactureDataLength = sizeof(test) / sizeof(test[0]);
1968 dstFilter.manufactureData = test;
1969 dstFilter.manufactureDataMask = test;
1970 }
1971 EXPECT_TRUE(CompareSameFilter(&srcFilter, &dstFilter));
1972
1973 DISC_LOGI(DISC_TEST, "CompareSameFilter004 end ----");
1974 }
1975
1976 /*
1977 * @tc.name: PerformSetBroadcastingParam001
1978 * @tc.desc: PerformSetBroadcastingParam001
1979 * @tc.type: FUNC
1980 * @tc.require:
1981 */
1982 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam001, TestSize.Level1)
1983 {
1984 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam001 begin ----");
1985 ManagerMock managerMock;
1986 EXPECT_CALL(managerMock, SoftBusCondWait)
1987 .WillRepeatedly(Return(SOFTBUS_OK));
1988 BroadcastParam bcParam = {};
1989 BuildBroadcastParam(&bcParam);
1990 SoftbusBroadcastParam adapterParam = {};
1991 ConvertBcParams(&bcParam, &adapterParam);
1992
1993 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1994
1995 int32_t bcId = -1;
1996 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1997 EXPECT_TRUE(bcId >= 0);
1998
1999 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, PerformSetBroadcastingParam(bcId, &adapterParam));
2000 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2001 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2002 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam001 end ----");
2003 }
2004
2005 /*
2006 * @tc.name: PerformSetBroadcastingParam002
2007 * @tc.desc: PerformSetBroadcastingParam002
2008 * @tc.type: FUNC
2009 * @tc.require:
2010 */
2011 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam002, TestSize.Level1)
2012 {
2013 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam002 begin ----");
2014 ManagerMock managerMock;
2015 EXPECT_CALL(managerMock, SoftBusCondWait)
2016 .WillRepeatedly(Return(SOFTBUS_OK));
2017 BroadcastParam bcParam = {};
2018 BuildBroadcastParam(&bcParam);
2019 SoftbusBroadcastParam adapterParam = {};
2020 ConvertBcParams(&bcParam, &adapterParam);
2021
2022 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2023
2024 int32_t bcId = -1;
2025 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2026 EXPECT_TRUE(bcId >= 0);
2027 int32_t bcIdTest = bcId + 1;
2028
2029 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, PerformSetBroadcastingParam(bcIdTest, &adapterParam));
2030 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2031 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2032 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam002 end ----");
2033 }
2034
2035 /*
2036 * @tc.name: PerformSetBroadcastingParam003
2037 * @tc.desc: PerformSetBroadcastingParam003
2038 * @tc.type: FUNC
2039 * @tc.require:
2040 */
2041 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam003, TestSize.Level1)
2042 {
2043 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam003 begin ----");
2044 ManagerMock managerMock;
2045 EXPECT_CALL(managerMock, SoftBusCondWait)
2046 .WillRepeatedly(Return(SOFTBUS_OK));
2047 BroadcastParam bcParam = {};
2048 BroadcastPacket packet = {};
2049 BuildBroadcastParam(&bcParam);
2050 SoftbusBroadcastParam adapterParam = {};
2051 ConvertBcParams(&bcParam, &adapterParam);
2052 BuildBroadcastPacketExceptPayload(&packet);
2053
2054 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
2055 packet.bcData.payload = BC_DATA_PAYLOAD;
2056 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
2057 packet.rspData.payload = RSP_DATA_PAYLOAD;
2058
2059 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2060
2061 int32_t bcId = -1;
2062 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2063 EXPECT_TRUE(bcId >= 0);
2064
2065 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
2066 EXPECT_EQ(SOFTBUS_OK, PerformSetBroadcastingParam(bcId, &adapterParam));
2067 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2068 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2069 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam003 end ----");
2070 }
2071
2072 /*
2073 * @tc.name: PerformSetBroadcastingParam004
2074 * @tc.desc: PerformSetBroadcastingParam004
2075 * @tc.type: FUNC
2076 * @tc.require:
2077 */
2078 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam004, TestSize.Level1)
2079 {
2080 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam004 begin ----");
2081 ManagerMock managerMock;
2082 EXPECT_CALL(managerMock, SoftBusCondWait)
2083 .WillRepeatedly(Return(SOFTBUS_ERR));
2084
2085 BroadcastParam bcParam = {};
2086 BroadcastPacket packet = {};
2087 BuildBroadcastParam(&bcParam);
2088 SoftbusBroadcastParam adapterParam = {};
2089 ConvertBcParams(&bcParam, &adapterParam);
2090 BuildBroadcastPacketExceptPayload(&packet);
2091
2092 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
2093 packet.bcData.payload = BC_DATA_PAYLOAD;
2094 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
2095 packet.rspData.payload = RSP_DATA_PAYLOAD;
2096
2097 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2098
2099 int32_t bcId = -1;
2100 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2101 EXPECT_TRUE(bcId >= 0);
2102
2103 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
2104 EXPECT_EQ(SOFTBUS_OK, PerformSetBroadcastingParam(bcId, &adapterParam));
2105 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2106 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2107 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam004 end ----");
2108 }
2109
2110 /*
2111 * @tc.name: EnableBroadcasting001
2112 * @tc.desc: EnableBroadcasting001
2113 * @tc.type: FUNC
2114 * @tc.require:
2115 */
2116 HWTEST_F(SoftbusBroadcastMgrTest, EnableBroadcasting001, TestSize.Level1)
2117 {
2118 DISC_LOGI(DISC_TEST, "EnableBroadcasting001 begin ----");
2119 ManagerMock managerMock;
2120 EXPECT_CALL(managerMock, SoftBusCondWait)
2121 .WillRepeatedly(Return(SOFTBUS_ERR));
2122
2123 BroadcastParam bcParam = {};
2124 BroadcastPacket packet = {};
2125 BuildBroadcastParam(&bcParam);
2126 SoftbusBroadcastParam adapterParam = {};
2127 ConvertBcParams(&bcParam, &adapterParam);
2128 BuildBroadcastPacketExceptPayload(&packet);
2129
2130 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
2131 packet.bcData.payload = BC_DATA_PAYLOAD;
2132 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
2133 packet.rspData.payload = RSP_DATA_PAYLOAD;
2134
2135 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2136
2137 int32_t bcId = -1;
2138 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2139 EXPECT_TRUE(bcId >= 0);
2140 int32_t bcIdTest = bcId + 1;
2141
2142 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, EnableBroadcasting(bcIdTest));
2143 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2144 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2145 DISC_LOGI(DISC_TEST, "EnableBroadcasting001 end ----");
2146 }
2147
2148 /*
2149 * @tc.name: EnableBroadcasting002
2150 * @tc.desc: EnableBroadcasting002
2151 * @tc.type: FUNC
2152 * @tc.require:
2153 */
2154 HWTEST_F(SoftbusBroadcastMgrTest, EnableBroadcasting002, TestSize.Level1)
2155 {
2156 DISC_LOGI(DISC_TEST, "EnableBroadcasting002 begin ----");
2157 ManagerMock managerMock;
2158 EXPECT_CALL(managerMock, SoftBusCondWait)
2159 .WillRepeatedly(Return(SOFTBUS_ERR));
2160
2161 BroadcastParam bcParam = {};
2162 BroadcastPacket packet = {};
2163 BuildBroadcastParam(&bcParam);
2164 SoftbusBroadcastParam adapterParam = {};
2165 ConvertBcParams(&bcParam, &adapterParam);
2166 BuildBroadcastPacketExceptPayload(&packet);
2167
2168 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
2169 packet.bcData.payload = BC_DATA_PAYLOAD;
2170 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
2171 packet.rspData.payload = RSP_DATA_PAYLOAD;
2172
2173 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2174
2175 int32_t bcId = -1;
2176 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2177 EXPECT_TRUE(bcId >= 0);
2178
2179 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, EnableBroadcasting(bcId));
2180 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2181 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2182 DISC_LOGI(DISC_TEST, "EnableBroadcasting002 end ----");
2183 }
2184
2185 /*
2186 * @tc.name: QueryBroadcastStatus001
2187 * @tc.desc: QueryBroadcastStatus001
2188 * @tc.type: FUNC
2189 * @tc.require:
2190 */
2191 HWTEST_F(SoftbusBroadcastMgrTest, QueryBroadcastStatus001, TestSize.Level1)
2192 {
2193 DISC_LOGI(DISC_TEST, "QueryBroadcastStatus001 begin ----");
2194 ManagerMock managerMock;
2195 EXPECT_CALL(managerMock, SoftBusCondWait)
2196 .WillRepeatedly(Return(SOFTBUS_ERR));
2197
2198 int32_t bcId = -1;
2199 EXPECT_EQ(SOFTBUS_OK, QueryBroadcastStatus(bcId, &bcId));
2200 DISC_LOGI(DISC_TEST, "QueryBroadcastStatus001 end ----");
2201 }
2202
2203 /*
2204 * @tc.name: BroadcastSetAdvDeviceParam001
2205 * @tc.desc: BroadcastSetAdvDeviceParam001
2206 * @tc.type: FUNC
2207 * @tc.require:
2208 */
2209 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetAdvDeviceParam001, TestSize.Level1)
2210 {
2211 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam001 begin ----");
2212 ManagerMock managerMock;
2213
2214 g_baseFuzzPos = 0;
2215 uint8_t type = GetData<uint8_t>();
2216 LpScanParam lpScanParam = BuildLpScanParam();
2217 lpScanParam.listenerId = listenderId;
2218 LpBroadcastParam lpBcParam;
2219 BuildLpBroadcastParam(&lpBcParam);
2220
2221 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2222 int32_t bcId = -1;
2223 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(BROADCAST_PROTOCOL_BLE, SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2224 EXPECT_TRUE(bcId >= 0);
2225
2226 EXPECT_FALSE(BroadcastSetAdvDeviceParam(static_cast<LpServerType>(type), &lpBcParam, &lpScanParam));
2227
2228 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2229 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2230 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam001 end ----");
2231 }
2232
2233 /*
2234 * @tc.name: BroadcastSetAdvDeviceParam002
2235 * @tc.desc: BroadcastSetAdvDeviceParam002
2236 * @tc.type: FUNC
2237 * @tc.require:
2238 */
2239 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetAdvDeviceParam002, TestSize.Level1)
2240 {
2241 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam002 begin ----");
2242 ManagerMock managerMock;
2243
2244 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2245 int32_t bcId = -1;
2246 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(BROADCAST_PROTOCOL_BLE,
2247 SRV_TYPE_DIS, &bcId, GetScanCallback()));
2248 EXPECT_TRUE(bcId >= 0);
2249
2250 g_baseFuzzPos = 0;
2251 uint8_t type = GetData<uint8_t>();
2252 LpScanParam lpScanParam = BuildLpScanParam();
2253 lpScanParam.listenerId = bcId;
2254 uint8_t filterNum = 1;
2255 BcScanFilter *filter = GetBcScanFilter();
2256 LpBroadcastParam lpBcParam;
2257 BuildLpBroadcastParam(&lpBcParam);
2258
2259 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(bcId, filter, filterNum));
2260 EXPECT_FALSE(BroadcastSetAdvDeviceParam(static_cast<LpServerType>(type), &lpBcParam, &lpScanParam));
2261
2262 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(bcId));
2263 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2264 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam002 end ----");
2265 }
2266
2267 /*
2268 * @tc.name: BroadcastEnableSyncDataToLpDevice001
2269 * @tc.desc: BroadcastEnableSyncDataToLpDevice001
2270 * @tc.type: FUNC
2271 * @tc.require:
2272 */
2273 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastEnableSyncDataToLpDevice001, TestSize.Level1)
2274 {
2275 DISC_LOGI(DISC_TEST, "BroadcastEnableSyncDataToLpDevice001 begin ----");
2276 ManagerMock managerMock;
2277 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2278
2279 EXPECT_EQ(SOFTBUS_OK, BroadcastEnableSyncDataToLpDevice());
2280
2281 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2282 DISC_LOGI(DISC_TEST, "BroadcastEnableSyncDataToLpDevice001 end ----");
2283 }
2284
2285 /*
2286 * @tc.name: BroadcastDisableSyncDataToLpDevice001
2287 * @tc.desc: BroadcastDisableSyncDataToLpDevice001
2288 * @tc.type: FUNC
2289 * @tc.require:
2290 */
2291 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastDisableSyncDataToLpDevice001, TestSize.Level1)
2292 {
2293 DISC_LOGI(DISC_TEST, "BroadcastDisableSyncDataToLpDevice001 begin ----");
2294 ManagerMock managerMock;
2295 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2296
2297 EXPECT_EQ(SOFTBUS_OK, BroadcastDisableSyncDataToLpDevice());
2298
2299 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2300 DISC_LOGI(DISC_TEST, "BroadcastDisableSyncDataToLpDevice001 end ----");
2301 }
2302
2303 /*
2304 * @tc.name: BroadcastSetLpAdvParam001
2305 * @tc.desc: BroadcastSetLpAdvParam001
2306 * @tc.type: FUNC
2307 * @tc.require:
2308 */
2309 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetLpAdvParam001, TestSize.Level1)
2310 {
2311 DISC_LOGI(DISC_TEST, "BroadcastSetLpAdvParam001 begin ----");
2312 ManagerMock managerMock;
2313 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2314
2315 int32_t duration = 0;
2316 int32_t maxExtAdvEvents = 0;
2317 int32_t window = 0;
2318 int32_t interval = 0;
2319 int32_t bcHandle = 0;
2320 EXPECT_EQ(SOFTBUS_OK, BroadcastSetLpAdvParam(duration, maxExtAdvEvents, window, interval, bcHandle));
2321
2322 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2323 DISC_LOGI(DISC_TEST, "BroadcastSetLpAdvParam001 end ----");
2324 }
2325 } // namespace OHOS
2326