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
18 #include "disc_log.h"
19 #include "message_handler.h"
20 #include "securec.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_MEDIUM_TYPE_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(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
393 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, UnRegisterBroadcaster(bcId));
394 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
395 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, UnRegisterScanListener(listenerId));
396
397 BroadcastParam bcParam = {};
398 BroadcastPacket packet = {};
399 BuildBroadcastParam(&bcParam);
400 BuildBroadcastPacketExceptPayload(&packet);
401
402 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
403 packet.bcData.payload = BC_DATA_PAYLOAD;
404 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
405 packet.rspData.payload = RSP_DATA_PAYLOAD;
406
407 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StartBroadcasting(bcId, &bcParam, &packet));
408 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, SetBroadcastingData(bcId, &packet));
409 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StopBroadcasting(bcId));
410
411 BcScanParams scanParam = {};
412 BuildScanParam(&scanParam);
413
414 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StartScan(listenerId, &scanParam));
415 EXPECT_EQ(SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, StopScan(listenerId));
416 EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
417
418 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 end ----");
419 }
420
421 /*
422 * @tc.name: SoftbusBroadcastInterface002
423 * @tc.desc: Calls the interface when the function registered is null.
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface002, TestSize.Level1)
428 {
429 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 begin ----");
430 ManagerMock managerMock;
431 EXPECT_CALL(managerMock, SoftbusBleAdapterInit).WillRepeatedly(ActionOfSoftbusBleAdapterInitNull);
432
433 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, InitBroadcastMgr());
434 int32_t bcId = -1;
435 int32_t listenerId = -1;
436 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
437 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, UnRegisterBroadcaster(bcId));
438 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
439 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, UnRegisterScanListener(listenerId));
440
441 BroadcastParam bcParam = {};
442 BroadcastPacket packet = {};
443 BuildBroadcastParam(&bcParam);
444 BuildBroadcastPacketExceptPayload(&packet);
445
446 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
447 packet.bcData.payload = BC_DATA_PAYLOAD;
448 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
449 packet.rspData.payload = RSP_DATA_PAYLOAD;
450
451 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartBroadcasting(bcId, &bcParam, &packet));
452 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, SetBroadcastingData(bcId, &packet));
453 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StopBroadcasting(bcId));
454
455 BcScanParams scanParam = {};
456 BuildScanParam(&scanParam);
457
458 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartScan(listenerId, &scanParam));
459 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StopScan(listenerId));
460 EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
461
462 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, DeInitBroadcastMgr());
463
464 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface002 end ----");
465 }
466
467 /*
468 * @tc.name: SoftbusBroadcastRegisterBroadcaster001
469 * @tc.desc: Invalid parameter, register broadcaster fail.
470 * @tc.type: FUNC
471 * @tc.require:
472 */
473 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster001, TestSize.Level1)
474 {
475 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 begin ----");
476 ManagerMock managerMock;
477
478 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
479 int32_t bcId = -1;
480 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV,
481 RegisterBroadcaster(static_cast<BaseServiceType>(SRV_TYPE_INVALID), &bcId, GetBroadcastCallback()));
482 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, nullptr, GetBroadcastCallback()));
483 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, nullptr));
484
485 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
486
487 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 end ----");
488 }
489
490 /*
491 * @tc.name: SoftbusBroadcastRegisterBroadcaster002
492 * @tc.desc: Register broadcaster and unregister broadcaster success.
493 * @tc.type: FUNC
494 * @tc.require:
495 */
496 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster002, TestSize.Level1)
497 {
498 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 begin ----");
499 ManagerMock managerMock;
500
501 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
502 int32_t bcId = -1;
503 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
504 EXPECT_TRUE(bcId >= 0);
505
506 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
507 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
508
509 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 end ----");
510 }
511
512 /*
513 * @tc.name: SoftbusBroadcastRegisterBroadcaster003
514 * @tc.desc: Duplicate registration.
515 * @tc.type: FUNC
516 * @tc.require:
517 */
518 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster003, TestSize.Level1)
519 {
520 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 begin ----");
521 ManagerMock managerMock;
522
523 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
524 int32_t bcId[BC_NUM_MAX + 1] = { -1 };
525 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
526 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId[i], GetBroadcastCallback()));
527 EXPECT_TRUE(bcId[i] >= 0);
528 }
529
530 EXPECT_EQ(SOFTBUS_BC_MGR_REG_NO_AVAILABLE_BC_ID,
531 RegisterBroadcaster(SRV_TYPE_DIS, &bcId[BC_NUM_MAX], GetBroadcastCallback()));
532
533 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
534 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId[i]));
535 }
536
537 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
538
539 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 end ----");
540 }
541
542 /*
543 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster001
544 * @tc.desc: Unregister without registration.
545 * @tc.type: FUNC
546 * @tc.require:
547 */
548 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster001, TestSize.Level1)
549 {
550 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 begin ----");
551 ManagerMock managerMock;
552
553 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
554
555 int32_t invalidId = -1;
556 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
557 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(BC_NUM_MAX));
558 invalidId = 1;
559 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
560
561 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
562
563 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 end ----");
564 }
565
566 /*
567 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster002
568 * @tc.desc: Unregister when broadcasting.
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster002, TestSize.Level1)
573 {
574 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 begin ----");
575 ManagerMock managerMock;
576
577 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
578
579 int32_t bcId = -1;
580 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
581 EXPECT_TRUE(bcId >= 0);
582
583 BroadcastParam bcParam = {};
584 BroadcastPacket packet = {};
585 BuildBroadcastParam(&bcParam);
586 BuildBroadcastPacketExceptPayload(&packet);
587
588 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
589 packet.bcData.payload = BC_DATA_PAYLOAD;
590 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
591 packet.rspData.payload = RSP_DATA_PAYLOAD;
592 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
593 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
594
595 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
596
597 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 end ----");
598 }
599
600 /*
601 * @tc.name: SoftbusBroadcastRegisterScanListener001
602 * @tc.desc: Invalid parameter, register listener fail.
603 * @tc.type: FUNC
604 * @tc.require:
605 */
606 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener001, TestSize.Level1)
607 {
608 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 begin ----");
609 ManagerMock managerMock;
610
611 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
612 int32_t listenerId = -1;
613 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_SRV,
614 RegisterScanListener(static_cast<BaseServiceType>(SRV_TYPE_INVALID), &listenerId, GetScanCallback()));
615 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, nullptr, GetScanCallback()));
616 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, &listenerId, nullptr));
617
618 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
619
620 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 end ----");
621 }
622
623 /*
624 * @tc.name: SoftbusBroadcastRegisterScanListener002
625 * @tc.desc: Register listener and unregister listener success.
626 * @tc.type: FUNC
627 * @tc.require:
628 */
629 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener002, TestSize.Level1)
630 {
631 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 begin ----");
632 ManagerMock managerMock;
633
634 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
635 int32_t listenerId = -1;
636 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
637 EXPECT_TRUE(listenerId >= 0);
638
639 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
640 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
641
642 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 end ----");
643 }
644
645 /*
646 * @tc.name: SoftbusBroadcastRegisterScanListener003
647 * @tc.desc: Duplicate registration.
648 * @tc.type: FUNC
649 * @tc.require:
650 */
651 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener003, TestSize.Level1)
652 {
653 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 begin ----");
654 ManagerMock managerMock;
655
656 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
657 int32_t listenerId = -1;
658 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
659 EXPECT_TRUE(listenerId >= 0);
660 EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
661 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
662
663 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
664 EXPECT_TRUE(listenerId >= 0);
665 EXPECT_EQ(SOFTBUS_BC_MGR_REG_DUP, RegisterScanListener(SRV_TYPE_LP_BURST, &listenerId, GetScanCallback()));
666 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
667
668 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
669
670 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 end ----");
671 }
672
673 /*
674 * @tc.name: SoftbusBroadcastUnRegisterScanListener001
675 * @tc.desc: Unregister without registration.
676 * @tc.type: FUNC
677 * @tc.require:
678 */
679 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener001, TestSize.Level1)
680 {
681 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 begin ----");
682 ManagerMock managerMock;
683
684 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
685
686 int32_t invalidId = -1;
687 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
688 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(SCAN_NUM_MAX));
689 invalidId = 0;
690 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
691
692 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
693
694 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 end ----");
695 }
696
697 /*
698 * @tc.name: SoftbusBroadcastUnRegisterScanListener002
699 * @tc.desc: Unregister when scanning.
700 * @tc.type: FUNC
701 * @tc.require:
702 */
703 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener002, TestSize.Level1)
704 {
705 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 begin ----");
706 ManagerMock managerMock;
707
708 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
709 int32_t listenerId = -1;
710 uint8_t filterNum = 1;
711 BcScanFilter *filter = GetBcScanFilter();
712 BcScanParams scanParam = {};
713 BuildScanParam(&scanParam);
714
715 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
716 EXPECT_TRUE(listenerId >= 0);
717
718 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
719 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
720
721 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
722 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
723
724 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 end ----");
725 }
726
727 /*
728 * @tc.name: SoftbusBroadcastStartBroadcasting001
729 * @tc.desc: Invalid parameter, start broadcasting fail.
730 * @tc.type: FUNC
731 * @tc.require:
732 */
733 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting001, TestSize.Level1)
734 {
735 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 begin ----");
736 ManagerMock managerMock;
737
738 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
739
740 int32_t bcId = -1;
741 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
742 EXPECT_TRUE(bcId >= 0);
743
744 BroadcastParam bcParam = {};
745 BroadcastPacket packet = {};
746 BuildBroadcastParam(&bcParam);
747 BuildBroadcastPacketExceptPayload(&packet);
748
749 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, nullptr, &packet));
750 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, nullptr));
751 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, &packet));
752
753 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
754 packet.bcData.payload = BC_DATA_PAYLOAD;
755 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
756 packet.rspData.payload = RSP_DATA_PAYLOAD;
757 int32_t invalidBcId = -1;
758 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StartBroadcasting(invalidBcId, &bcParam, &packet));
759
760 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
761
762 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
763
764 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 end ----");
765 }
766
767 /*
768 * @tc.name: SoftbusBroadcastStartBroadcasting002
769 * @tc.desc: Start broadcasting and stop broadcasting success.
770 * @tc.type: FUNC
771 * @tc.require:
772 */
773 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting002, TestSize.Level1)
774 {
775 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 begin ----");
776 ManagerMock managerMock;
777
778 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
779
780 int32_t bcId = -1;
781 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
782 EXPECT_TRUE(bcId >= 0);
783
784 BroadcastParam bcParam = {};
785 BroadcastPacket packet = {};
786 BuildBroadcastParam(&bcParam);
787 BuildBroadcastPacketExceptPayload(&packet);
788
789 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
790 packet.bcData.payload = BC_DATA_PAYLOAD;
791 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
792 packet.rspData.payload = RSP_DATA_PAYLOAD;
793
794 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
795 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
796
797 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
798 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
799
800 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 end ----");
801 }
802
803 /*
804 * @tc.name: SoftbusBroadcastStartBroadcasting003
805 * @tc.desc: Duplicate start broadcasting.
806 * @tc.type: FUNC
807 * @tc.require:
808 */
809 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting003, TestSize.Level1)
810 {
811 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 begin ----");
812 ManagerMock managerMock;
813
814 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
815
816 int32_t bcId = -1;
817 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
818 EXPECT_TRUE(bcId >= 0);
819
820 BroadcastParam bcParam = {};
821 BroadcastPacket packet = {};
822 BuildBroadcastParam(&bcParam);
823 BuildBroadcastPacketExceptPayload(&packet);
824
825 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
826 packet.bcData.payload = BC_DATA_PAYLOAD;
827 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
828 packet.rspData.payload = RSP_DATA_PAYLOAD;
829
830 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
831 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
832 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
833
834 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
835 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
836
837 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 end ----");
838 }
839
840 /*
841 * @tc.name: SoftbusBroadcastUpdateBroadcasting001
842 * @tc.desc: Invalid parameter, update broadcasting fail.
843 * @tc.type: FUNC
844 * @tc.require:
845 */
846 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting001, TestSize.Level1)
847 {
848 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 begin ----");
849 ManagerMock managerMock;
850
851 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
852
853 int32_t bcId = -1;
854 BroadcastParam bcParam = {};
855 BroadcastPacket packet = {};
856 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, nullptr, &packet));
857 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, &bcParam, nullptr));
858
859 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
860
861 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 end ----");
862 }
863
864 /*
865 * @tc.name: SoftbusBroadcastUpdateBroadcasting002
866 * @tc.desc: Update broadcasting success.
867 * @tc.type: FUNC
868 * @tc.require:
869 */
870 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting002, TestSize.Level1)
871 {
872 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 begin ----");
873 ManagerMock managerMock;
874
875 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
876
877 int32_t bcId = -1;
878 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
879 EXPECT_TRUE(bcId >= 0);
880
881 BroadcastParam bcParam = {};
882 BroadcastPacket packet = {};
883 BuildBroadcastParam(&bcParam);
884 BuildBroadcastPacketExceptPayload(&packet);
885
886 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
887 packet.bcData.payload = BC_DATA_PAYLOAD;
888 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
889 packet.rspData.payload = RSP_DATA_PAYLOAD;
890
891 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
892 EXPECT_EQ(SOFTBUS_OK, UpdateBroadcasting(bcId, &bcParam, &packet));
893
894 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
895 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
896
897 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 end ----");
898 }
899
900 /*
901 * @tc.name: SoftbusBroadcastSetBroadcastingData001
902 * @tc.desc: Invalid parameter, set broadcasting data fail.
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData001, TestSize.Level1)
907 {
908 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 begin ----");
909 ManagerMock managerMock;
910
911 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
912
913 int32_t invalidId = -1;
914 BroadcastPacket packet = {};
915 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingData(invalidId, nullptr));
916 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
917 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(BC_NUM_MAX, &packet));
918 invalidId = 0;
919 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingData(invalidId, &packet));
920
921 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
922
923 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 end ----");
924 }
925
926 /*
927 * @tc.name: SoftbusBroadcastSetBroadcastingData002
928 * @tc.desc: Set broadcasting data without start.
929 * @tc.type: FUNC
930 * @tc.require:
931 */
932 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData002, TestSize.Level1)
933 {
934 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 begin ----");
935 ManagerMock managerMock;
936
937 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
938
939 int32_t bcId = -1;
940 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
941 EXPECT_TRUE(bcId >= 0);
942
943 BroadcastPacket packet = {};
944 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, SetBroadcastingData(bcId, &packet));
945
946 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
947 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
948
949 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 end ----");
950 }
951
952 /*
953 * @tc.name: SoftbusBroadcastSetBroadcastingData003
954 * @tc.desc: Set broadcasting data success.
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData003, TestSize.Level1)
959 {
960 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 begin ----");
961 ManagerMock managerMock;
962
963 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
964
965 int32_t bcId = -1;
966 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
967 EXPECT_TRUE(bcId >= 0);
968
969 BroadcastParam bcParam = {};
970 BroadcastPacket packet = {};
971 BuildBroadcastParam(&bcParam);
972 BuildBroadcastPacketExceptPayload(&packet);
973
974 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
975 packet.bcData.payload = BC_DATA_PAYLOAD;
976 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
977 packet.rspData.payload = RSP_DATA_PAYLOAD;
978
979 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
980 EXPECT_EQ(SOFTBUS_OK, SetBroadcastingData(bcId, &packet));
981 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
982
983 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
984 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
985
986 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 end ----");
987 }
988
989 /*
990 * @tc.name: SoftbusBroadcastSetBroadcastingParam001
991 * @tc.desc: Invalid parameter, set broadcasting param fail.
992 * @tc.type: FUNC
993 * @tc.require:
994 */
995 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingParam001, TestSize.Level1)
996 {
997 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam001 begin ----");
998 ManagerMock managerMock;
999
1000 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1001
1002 int32_t invalidId = -1;
1003 BroadcastParam param = {};
1004
1005 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingParam(invalidId, nullptr));
1006 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(invalidId, ¶m));
1007 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(BC_NUM_MAX, ¶m));
1008 invalidId = 0;
1009 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, SetBroadcastingParam(invalidId, ¶m));
1010
1011 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1012
1013 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam001 end ----");
1014 }
1015
1016 /*
1017 * @tc.name: SoftbusBroadcastSetBroadcastingParam002
1018 * @tc.desc: Set broadcasting param without start.
1019 * @tc.type: FUNC
1020 * @tc.require:
1021 */
1022 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingParam002, TestSize.Level1)
1023 {
1024 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam002 begin ----");
1025 ManagerMock managerMock;
1026
1027 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1028
1029 int32_t bcId = -1;
1030 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1031 EXPECT_TRUE(bcId >= 0);
1032
1033 BroadcastParam param = {};
1034 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, SetBroadcastingParam(bcId, ¶m));
1035
1036 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1037 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1038
1039 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingParam002 end ----");
1040 }
1041
1042 /*
1043 * @tc.name: SoftbusBroadcastStopBroadcasting001
1044 * @tc.desc: Invalid parameter, stop broadcasting fail.
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 */
1048 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting001, TestSize.Level1)
1049 {
1050 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 begin ----");
1051 ManagerMock managerMock;
1052
1053 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1054
1055 int32_t invalidId = -1;
1056 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
1057 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(BC_NUM_MAX));
1058 invalidId = 0;
1059 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, StopBroadcasting(invalidId));
1060
1061 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1062
1063 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 end ----");
1064 }
1065
1066 /*
1067 * @tc.name: SoftbusBroadcastStopBroadcasting002
1068 * @tc.desc: Stop broadcasting without start.
1069 * @tc.type: FUNC
1070 * @tc.require:
1071 */
1072 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting002, TestSize.Level1)
1073 {
1074 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 begin ----");
1075 ManagerMock managerMock;
1076
1077 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1078 int32_t bcId = -1;
1079 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1080 EXPECT_TRUE(bcId >= 0);
1081
1082 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
1083
1084 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1085 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1086
1087 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 end ----");
1088 }
1089
1090 /*
1091 * @tc.name: SoftbusBroadcastSetScanFilter001
1092 * @tc.desc: Invalid parameter, set filter fail.
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter001, TestSize.Level1)
1097 {
1098 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 begin ----");
1099 ManagerMock managerMock;
1100
1101 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1102 int32_t listenerId = -1;
1103 uint8_t filterNum = 0;
1104 BcScanFilter filter = {};
1105 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, &filter, filterNum));
1106
1107 filterNum = 1;
1108 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, nullptr, filterNum));
1109 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
1110 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(SCAN_NUM_MAX, &filter, filterNum));
1111 listenerId = 0;
1112 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, &filter, filterNum));
1113
1114 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1115
1116 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 end ----");
1117 }
1118
1119 /*
1120 * @tc.name: SoftbusBroadcastSetScanFilter002
1121 * @tc.desc: Set filter success.
1122 * @tc.type: FUNC
1123 * @tc.require:
1124 */
1125 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter002, TestSize.Level1)
1126 {
1127 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 begin ----");
1128 ManagerMock managerMock;
1129
1130 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1131 int32_t listenerId = -1;
1132 uint8_t filterNum = 1;
1133 BcScanFilter *filter = GetBcScanFilter();
1134
1135 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1136 EXPECT_TRUE(listenerId >= 0);
1137
1138 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1139
1140 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1141 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1142
1143 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 end ----");
1144 }
1145
1146 /*
1147 * @tc.name: SoftbusBroadcastStartScan001
1148 * @tc.desc: Invalid parameter, start scan fail.
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan001, TestSize.Level1)
1153 {
1154 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 begin ----");
1155 ManagerMock managerMock;
1156
1157 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1158 int32_t listenerId = -1;
1159 BcScanParams scanParam = {};
1160 BuildScanParam(&scanParam);
1161 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StartScan(listenerId, &scanParam));
1162
1163 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1164 EXPECT_TRUE(listenerId >= 0);
1165 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartScan(listenerId, nullptr));
1166
1167 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1168 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1169
1170 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 end ----");
1171 }
1172
1173 /*
1174 * @tc.name: SoftbusBroadcastStartScan002
1175 * @tc.desc: Start scan without filter.
1176 * @tc.type: FUNC
1177 * @tc.require:
1178 */
1179 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan002, TestSize.Level1)
1180 {
1181 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 begin ----");
1182 ManagerMock managerMock;
1183
1184 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1185 int32_t listenerId = -1;
1186 BcScanParams scanParam = {};
1187 BuildScanParam(&scanParam);
1188
1189 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1190 EXPECT_TRUE(listenerId >= 0);
1191 int32_t ret = StartScan(listenerId, &scanParam);
1192 EXPECT_EQ(ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_BC_MGR_START_SCAN_NO_FILTER, true);
1193
1194 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1195 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1196
1197 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 end ----");
1198 }
1199
1200 /*
1201 * @tc.name: SoftbusBroadcastStartScan003
1202 * @tc.desc: Start scan and stop scan success.
1203 * @tc.type: FUNC
1204 * @tc.require:
1205 */
1206 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan003, TestSize.Level1)
1207 {
1208 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 begin ----");
1209 ManagerMock managerMock;
1210
1211 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1212 int32_t listenerId = -1;
1213 uint8_t filterNum = 1;
1214 BcScanFilter *filter = GetBcScanFilter();
1215 BcScanParams scanParam = {};
1216 BuildScanParam(&scanParam);
1217
1218 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1219 EXPECT_TRUE(listenerId >= 0);
1220
1221 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1222 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1223 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1224
1225 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1226 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1227
1228 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 end ----");
1229 }
1230
1231 /*
1232 * @tc.name: SoftbusBroadcastStartScan004
1233 * @tc.desc: Duplicate start scan.
1234 * @tc.type: FUNC
1235 * @tc.require:
1236 */
1237 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan004, TestSize.Level1)
1238 {
1239 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 begin ----");
1240 ManagerMock managerMock;
1241 EXPECT_CALL(managerMock, SoftbusBleAdapterInit).WillRepeatedly(ActionOfSoftbusBleAdapterInitNull);
1242
1243 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, InitBroadcastMgr());
1244
1245 int32_t listenerId = -1;
1246 uint8_t filterNum = 1;
1247 BcScanFilter *filter = GetBcScanFilter();
1248 BcScanParams scanParam = {};
1249 BuildScanParam(&scanParam);
1250
1251 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1252
1253 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, SetScanFilter(listenerId, filter, filterNum));
1254 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartScan(listenerId, &scanParam));
1255 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StartScan(listenerId, &scanParam));
1256 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, StopScan(listenerId));
1257
1258 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, UnRegisterScanListener(listenerId));
1259 EXPECT_EQ(SOFTBUS_BC_MGR_FUNC_NULL, DeInitBroadcastMgr());
1260
1261 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 end ----");
1262 }
1263
1264 /*
1265 * @tc.name: SoftbusBroadcastStopScan001
1266 * @tc.desc: Invalid parameter, stop scan fail.
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan001, TestSize.Level1)
1271 {
1272 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 begin ----");
1273 ManagerMock managerMock;
1274
1275 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1276 int32_t invalidId = -1;
1277 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1278 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(SCAN_NUM_MAX));
1279 invalidId = 0;
1280 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, StopScan(invalidId));
1281
1282 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1283
1284 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 end ----");
1285 }
1286
1287 /*
1288 * @tc.name: SoftbusBroadcastStopScan002
1289 * @tc.desc: Stop scan without start.
1290 * @tc.type: FUNC
1291 * @tc.require:
1292 */
1293 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan002, TestSize.Level1)
1294 {
1295 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 begin ----");
1296 ManagerMock managerMock;
1297
1298 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1299 int32_t listenerId = -1;
1300 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1301 EXPECT_TRUE(listenerId >= 0);
1302 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1303
1304 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1305 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1306
1307 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 end ----");
1308 }
1309
1310 /*
1311 * @tc.name: SoftbusBroadcastScannerTest001
1312 * @tc.desc: Scanner start scan success when new listenerId is added.
1313 * @tc.type: FUNC
1314 * @tc.require:
1315 */
1316 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest001, TestSize.Level1)
1317 {
1318 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 begin ----");
1319 ManagerMock managerMock;
1320
1321 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1322 int32_t discListenerId = -1;
1323 int32_t connListenerId = -1;
1324 int32_t lpListenerId = -1;
1325 uint8_t filterNum = 1;
1326 BcScanFilter *discFilter = GetBcScanFilter();
1327 BcScanFilter *connFilter = GetBcScanFilter();
1328 BcScanFilter *lpFilter = GetBcScanFilter();
1329 BcScanParams scanParam = {};
1330 BuildScanParam(&scanParam);
1331
1332 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1333 EXPECT_TRUE(discListenerId >= 0);
1334 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1335 EXPECT_TRUE(connListenerId >= 0);
1336 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1337 EXPECT_TRUE(lpListenerId >= 0);
1338
1339 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1340 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1341 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1342
1343 // First call, start scan.
1344 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1345 // Scanning, new listenerId is added, stop and start.
1346 EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1347 // Another scanner, start scan.
1348 EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1349
1350 // Another listenerId is scanning, stop and start.
1351 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1352 // Stop scan.
1353 EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1354 // Another scanner, stop scan.
1355 EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1356
1357 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1358 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1359 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1360
1361 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1362
1363 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest001 end ----");
1364 }
1365
1366 /*
1367 * @tc.name: SoftbusBroadcastScannerTest002
1368 * @tc.desc: Two Scanner stop and start success without interfering with each other.
1369 * @tc.type: FUNC
1370 * @tc.require:
1371 */
1372 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest002, TestSize.Level1)
1373 {
1374 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 begin ----");
1375 ManagerMock managerMock;
1376
1377 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1378 int32_t discListenerId = -1;
1379 int32_t connListenerId = -1;
1380 int32_t lpListenerId = -1;
1381 uint8_t filterNum = 1;
1382 BcScanFilter *discFilter = GetBcScanFilter();
1383 BcScanFilter *connFilter = GetBcScanFilter();
1384 BcScanFilter *lpFilter = GetBcScanFilter();
1385 BcScanParams scanParam = {};
1386 BuildScanParam(&scanParam);
1387
1388 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1389 EXPECT_TRUE(discListenerId >= 0);
1390 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_CONN, &connListenerId, GetScanCallback()));
1391 EXPECT_TRUE(connListenerId >= 0);
1392 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_LP_HB, &lpListenerId, GetScanCallback()));
1393 EXPECT_TRUE(lpListenerId >= 0);
1394
1395 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1396 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(connListenerId, connFilter, filterNum));
1397 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(lpListenerId, lpFilter, filterNum));
1398
1399 // First call, start scan.
1400 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1401 // Scanning, new listenerId is added, stop and start.
1402 EXPECT_EQ(SOFTBUS_OK, StartScan(connListenerId, &scanParam));
1403 // A listenerId is removed, stop and start.
1404 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1405 // Another scanner, start scan.
1406 EXPECT_EQ(SOFTBUS_OK, StartScan(lpListenerId, &scanParam));
1407 // Scanning, new listenerId is added, stop and start.
1408 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1409
1410 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1411 EXPECT_EQ(SOFTBUS_OK, StopScan(connListenerId));
1412 EXPECT_EQ(SOFTBUS_OK, StopScan(lpListenerId));
1413
1414 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1415 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(connListenerId));
1416 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(lpListenerId));
1417
1418 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1419
1420 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest002 end ----");
1421 }
1422
1423 /*
1424 * @tc.name: SoftbusBroadcastScannerTest003
1425 * @tc.desc: Scanner start scan success when updating frequency.
1426 * @tc.type: FUNC
1427 * @tc.require:
1428 */
1429 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest003, TestSize.Level1)
1430 {
1431 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 begin ----");
1432 ManagerMock managerMock;
1433
1434 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1435 int32_t discListenerId = -1;
1436 uint8_t filterNum = 1;
1437 BcScanFilter *discFilter = GetBcScanFilter();
1438 BcScanParams scanParam = {};
1439 BuildScanParam(&scanParam);
1440
1441 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1442 EXPECT_TRUE(discListenerId >= 0);
1443
1444 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1445
1446 // First call, start scan.
1447 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1448 // Scanning, update frequency, stop and start
1449 scanParam.scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P10;
1450 scanParam.scanWindow = SOFTBUS_BC_SCAN_WINDOW_P10;
1451 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1452
1453 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1454 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1455
1456 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1457
1458 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest003 end ----");
1459 }
1460
1461 /*
1462 * @tc.name: SoftbusBroadcastScannerTest004
1463 * @tc.desc: Scanner start scan success when setting a new filter.
1464 * @tc.type: FUNC
1465 * @tc.require:
1466 */
1467 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest004, TestSize.Level1)
1468 {
1469 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 begin ----");
1470 ManagerMock managerMock;
1471
1472 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1473 int32_t discListenerId = -1;
1474 uint8_t filterNum = 1;
1475 BcScanFilter *discFilter = GetBcScanFilter();
1476 BcScanParams scanParam = {};
1477 BuildScanParam(&scanParam);
1478
1479 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1480 EXPECT_TRUE(discListenerId >= 0);
1481
1482 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1483
1484 // First call, start scan.
1485 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1486 // Scanning, set a new filter, stop and start.
1487 // Last filter is released in SetScanFilter.
1488 BcScanFilter *newFilter = GetBcScanFilter();
1489 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, newFilter, filterNum));
1490 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1491
1492 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1493
1494 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1495
1496 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1497
1498 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest004 end ----");
1499 }
1500
1501 /*
1502 * @tc.name: SoftbusBroadcastScannerTest005
1503 * @tc.desc: Scanner not start scan with same params.
1504 * @tc.type: FUNC
1505 * @tc.require:
1506 */
1507 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastScannerTest005, TestSize.Level1)
1508 {
1509 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 begin ----");
1510 ManagerMock managerMock;
1511
1512 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1513 int32_t discListenerId = -1;
1514 uint8_t filterNum = 1;
1515 BcScanFilter *discFilter = GetBcScanFilter();
1516 BcScanParams scanParam = {};
1517 BuildScanParam(&scanParam);
1518
1519 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &discListenerId, GetScanCallback()));
1520 EXPECT_TRUE(discListenerId >= 0);
1521
1522 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(discListenerId, discFilter, filterNum));
1523
1524 // First call, start scan.
1525 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1526 // Scanning, not start with same params.
1527 EXPECT_EQ(SOFTBUS_OK, StartScan(discListenerId, &scanParam));
1528
1529 EXPECT_EQ(SOFTBUS_OK, StopScan(discListenerId));
1530
1531 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(discListenerId));
1532
1533 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1534
1535 DISC_LOGI(DISC_TEST, "SoftbusBroadcastScannerTest005 end ----");
1536 }
1537
1538 /*
1539 * @tc.name: TestGetScanFilter001
1540 * @tc.desc: GetScanFilter Error branching
1541 * @tc.type: FUNC
1542 * @tc.require:
1543 */
1544 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter001, TestSize.Level1)
1545 {
1546 DISC_LOGI(DISC_TEST, "TestGetScanFilter001 begin ----");
1547 ManagerMock managerMock;
1548
1549 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1550 int32_t listenerId = -1;
1551 BcScanFilter *scanFilter = nullptr;
1552 uint8_t filterNum = 0;
1553
1554 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, &scanFilter, nullptr));
1555
1556 filterNum = 1;
1557 EXPECT_EQ(SOFTBUS_INVALID_PARAM, GetScanFilter(listenerId, nullptr, &filterNum));
1558 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1559 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(SCAN_NUM_MAX, &scanFilter, &filterNum));
1560
1561 listenerId = 0;
1562 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, GetScanFilter(listenerId, &scanFilter, &filterNum));
1563 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1564 DISC_LOGI(DISC_TEST, "TestGetScanFilter001 end ----");
1565 }
1566
1567 /*
1568 * @tc.name: TestGetScanFilter002
1569 * @tc.desc: GetScanFilter Proper branching
1570 * @tc.type: FUNC
1571 * @tc.require:
1572 */
1573 HWTEST_F(SoftbusBroadcastMgrTest, TestGetScanFilter002, TestSize.Level1)
1574 {
1575 DISC_LOGI(DISC_TEST, "TestGetScanFilter002 begin ----");
1576 ManagerMock managerMock;
1577 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1578
1579 int32_t listenerId = -1;
1580 uint8_t filterNum = 1;
1581 BcScanFilter *filter = GetBcScanFilter();
1582 BcScanFilter *scanFilter = nullptr;
1583 BcScanParams scanParam = {};
1584 BuildScanParam(&scanParam);
1585
1586 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1587 EXPECT_TRUE(listenerId >= 0);
1588
1589 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1590 EXPECT_EQ(SOFTBUS_OK, GetScanFilter(listenerId, &scanFilter, &filterNum));
1591 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1592 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1593 DISC_LOGI(DISC_TEST, "TestGetScanFilter002 end ----");
1594 }
1595
1596 /*
1597 * @tc.name: BroadcastGetBroadcastHandle001
1598 * @tc.desc: BroadcastGetBroadcastHandle Proper branching
1599 * @tc.type: FUNC
1600 * @tc.require:
1601 */
1602 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastGetBroadcastHandle001, TestSize.Level1)
1603 {
1604 DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 begin ----");
1605 ManagerMock managerMock;
1606
1607 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1608 int32_t bcId = -1;
1609 int32_t Handle = 1;
1610
1611 EXPECT_EQ(SOFTBUS_INVALID_PARAM, BroadcastGetBroadcastHandle(bcId, &Handle));
1612
1613 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1614 EXPECT_TRUE(bcId >= 0);
1615 EXPECT_EQ(SOFTBUS_OK, BroadcastGetBroadcastHandle(bcId, &Handle));
1616 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1617
1618 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1619 DISC_LOGI(DISC_TEST, "BroadcastGetBroadcastHandle001 end ----");
1620 }
1621
1622 /*
1623 * @tc.name: BroadcastSetScanReportChannelToLpDevice001
1624 * @tc.desc: BroadcastSetScanReportChannelToLpDevice Error branching
1625 * @tc.type: FUNC
1626 * @tc.require:
1627 */
1628 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice001, TestSize.Level1)
1629 {
1630 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 begin ----");
1631 ManagerMock managerMock;
1632
1633 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1634 int32_t listenerId = 1;
1635 bool enable = true;
1636
1637 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1638 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(SCAN_NUM_MAX, false));
1639
1640 listenerId = 0;
1641 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_LISN_ID, BroadcastSetScanReportChannelToLpDevice(listenerId, enable));
1642
1643 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1644 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice001 end ----");
1645 }
1646
1647 /*
1648 * @tc.name: BroadcastSetScanReportChannelToLpDevice002
1649 * @tc.desc: BroadcastSetScanReportChannelToLpDevice CheckScanIdIsValid is true
1650 * @tc.type: FUNC
1651 * @tc.require:
1652 */
1653 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetScanReportChannelToLpDevice002, TestSize.Level1)
1654 {
1655 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 begin ----");
1656 ManagerMock managerMock;
1657 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1658
1659 int32_t listenerId = -1;
1660 uint8_t filterNum = 1;
1661 BcScanFilter *filter = GetBcScanFilter();
1662
1663 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1664 EXPECT_TRUE(listenerId >= 0);
1665
1666 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1667 EXPECT_EQ(SOFTBUS_OK, BroadcastSetScanReportChannelToLpDevice(listenerId, true));
1668 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1669
1670 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1671 DISC_LOGI(DISC_TEST, "BroadcastSetScanReportChannelToLpDevice002 end ----");
1672 }
1673
1674 /*
1675 * @tc.name: CompareSameFilter001
1676 * @tc.desc: CompareSameFilter001 CompareSameFilter is FALSE
1677 * @tc.type: FUNC
1678 * @tc.require:
1679 */
1680 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter001, TestSize.Level1)
1681 {
1682 DISC_LOGI(DISC_TEST, "CompareSameFilter001 begin ----");
1683 ManagerMock managerMock;
1684
1685 EXPECT_FALSE(CompareSameFilter(NULL, NULL));
1686
1687 DISC_LOGI(DISC_TEST, "CompareSameFilter001 end ----");
1688 }
1689
1690 /*
1691 * @tc.name: CompareSameFilter002
1692 * @tc.desc: CompareSameFilter002 CompareSameFilter is FALSE
1693 * @tc.type: FUNC
1694 * @tc.require:
1695 */
1696 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter002, TestSize.Level1)
1697 {
1698 DISC_LOGI(DISC_TEST, "CompareSameFilter002 begin ----");
1699 ManagerMock managerMock;
1700 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1701 BcScanFilter *filter = GetBcScanFilter();
1702
1703 EXPECT_FALSE(CompareSameFilter(filter, NULL));
1704
1705 DISC_LOGI(DISC_TEST, "CompareSameFilter002 end ----");
1706 }
1707
1708 /*
1709 * @tc.name: CompareSameFilter003
1710 * @tc.desc: CompareSameFilter003 CompareSameFilter is TRUE
1711 * @tc.type: FUNC
1712 * @tc.require:
1713 */
1714 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter003, TestSize.Level1)
1715 {
1716 DISC_LOGI(DISC_TEST, "CompareSameFilter003 begin ----");
1717 ManagerMock managerMock;
1718 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1719 BcScanFilter *filter = GetBcScanFilter();
1720 BcScanFilter *filter2 = GetBcScanFilter();
1721
1722 EXPECT_TRUE(CompareSameFilter(filter, filter2));
1723
1724 DISC_LOGI(DISC_TEST, "CompareSameFilter003 end ----");
1725 }
1726
1727 /*
1728 * @tc.name: CompareSameFilter004
1729 * @tc.desc: CompareSameFilter004 CompareSameFilter is FALSE
1730 * @tc.type: FUNC
1731 * @tc.require:
1732 */
1733 HWTEST_F(SoftbusBroadcastMgrTest, CompareSameFilter004, TestSize.Level1)
1734 {
1735 DISC_LOGI(DISC_TEST, "CompareSameFilter004 begin ----");
1736 ManagerMock managerMock;
1737 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1738 BcScanFilter *filter = GetBcScanFilter();
1739 BcScanFilter *filter2 = GetBcScanFilter();
1740
1741 BcScanFilter srcFilter = *filter;
1742 BcScanFilter dstFilter = *filter2;
1743 if (srcFilter.serviceData != NULL && dstFilter.serviceData != NULL &&
1744 srcFilter.serviceDataMask != NULL && dstFilter.serviceDataMask != NULL &&
1745 memcmp(srcFilter.serviceData, dstFilter.serviceData, srcFilter.serviceDataLength) == 0 &&
1746 memcmp(srcFilter.serviceDataMask, dstFilter.serviceDataMask, srcFilter.serviceDataLength) == 0) {
1747 std::cout << "srcFilter.serviceData != NULL" << std::endl;
1748 srcFilter.serviceData = NULL;
1749 dstFilter.serviceData = NULL;
1750 srcFilter.serviceDataMask = NULL;
1751 dstFilter.serviceDataMask = NULL;
1752 }
1753
1754 if (srcFilter.manufactureData == NULL && dstFilter.manufactureData == NULL &&
1755 srcFilter.manufactureDataMask == NULL && dstFilter.manufactureDataMask == NULL) {
1756 std::cout << "srcFilter.manufactureData == NULL" << std::endl;
1757 uint8_t test[] = {1, 2};
1758 srcFilter.manufactureDataLength = sizeof(test) / sizeof(test[0]);
1759 srcFilter.manufactureData = test;
1760 srcFilter.manufactureDataMask = test;
1761 dstFilter.manufactureDataLength = sizeof(test) / sizeof(test[0]);
1762 dstFilter.manufactureData = test;
1763 dstFilter.manufactureDataMask = test;
1764 }
1765 EXPECT_TRUE(CompareSameFilter(&srcFilter, &dstFilter));
1766
1767 DISC_LOGI(DISC_TEST, "CompareSameFilter004 end ----");
1768 }
1769
1770 /*
1771 * @tc.name: PerformSetBroadcastingParam001
1772 * @tc.desc: PerformSetBroadcastingParam001
1773 * @tc.type: FUNC
1774 * @tc.require:
1775 */
1776 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam001, TestSize.Level1)
1777 {
1778 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam001 begin ----");
1779 ManagerMock managerMock;
1780 EXPECT_CALL(managerMock, SoftBusCondWait)
1781 .WillRepeatedly(Return(SOFTBUS_OK));
1782 BroadcastParam bcParam = {};
1783 BuildBroadcastParam(&bcParam);
1784 SoftbusBroadcastParam adapterParam = {};
1785 ConvertBcParams(&bcParam, &adapterParam);
1786
1787 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1788
1789 int32_t bcId = -1;
1790 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1791 EXPECT_TRUE(bcId >= 0);
1792
1793 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, PerformSetBroadcastingParam(bcId, &adapterParam));
1794 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1795 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1796 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam001 end ----");
1797 }
1798
1799 /*
1800 * @tc.name: PerformSetBroadcastingParam002
1801 * @tc.desc: PerformSetBroadcastingParam002
1802 * @tc.type: FUNC
1803 * @tc.require:
1804 */
1805 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam002, TestSize.Level1)
1806 {
1807 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam002 begin ----");
1808 ManagerMock managerMock;
1809 EXPECT_CALL(managerMock, SoftBusCondWait)
1810 .WillRepeatedly(Return(SOFTBUS_OK));
1811 BroadcastParam bcParam = {};
1812 BuildBroadcastParam(&bcParam);
1813 SoftbusBroadcastParam adapterParam = {};
1814 ConvertBcParams(&bcParam, &adapterParam);
1815
1816 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1817
1818 int32_t bcId = -1;
1819 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1820 EXPECT_TRUE(bcId >= 0);
1821 int32_t bcIdTest = bcId + 1;
1822
1823 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, PerformSetBroadcastingParam(bcIdTest, &adapterParam));
1824 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1825 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1826 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam002 end ----");
1827 }
1828
1829 /*
1830 * @tc.name: PerformSetBroadcastingParam003
1831 * @tc.desc: PerformSetBroadcastingParam003
1832 * @tc.type: FUNC
1833 * @tc.require:
1834 */
1835 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam003, TestSize.Level1)
1836 {
1837 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam003 begin ----");
1838 ManagerMock managerMock;
1839 EXPECT_CALL(managerMock, SoftBusCondWait)
1840 .WillRepeatedly(Return(SOFTBUS_OK));
1841 BroadcastParam bcParam = {};
1842 BroadcastPacket packet = {};
1843 BuildBroadcastParam(&bcParam);
1844 SoftbusBroadcastParam adapterParam = {};
1845 ConvertBcParams(&bcParam, &adapterParam);
1846 BuildBroadcastPacketExceptPayload(&packet);
1847
1848 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
1849 packet.bcData.payload = BC_DATA_PAYLOAD;
1850 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
1851 packet.rspData.payload = RSP_DATA_PAYLOAD;
1852
1853 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1854
1855 int32_t bcId = -1;
1856 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1857 EXPECT_TRUE(bcId >= 0);
1858
1859 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
1860 EXPECT_EQ(SOFTBUS_OK, PerformSetBroadcastingParam(bcId, &adapterParam));
1861 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1862 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1863 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam003 end ----");
1864 }
1865
1866 /*
1867 * @tc.name: PerformSetBroadcastingParam004
1868 * @tc.desc: PerformSetBroadcastingParam004
1869 * @tc.type: FUNC
1870 * @tc.require:
1871 */
1872 HWTEST_F(SoftbusBroadcastMgrTest, PerformSetBroadcastingParam004, TestSize.Level1)
1873 {
1874 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam004 begin ----");
1875 ManagerMock managerMock;
1876 EXPECT_CALL(managerMock, SoftBusCondWait)
1877 .WillRepeatedly(Return(SOFTBUS_ERR));
1878
1879 BroadcastParam bcParam = {};
1880 BroadcastPacket packet = {};
1881 BuildBroadcastParam(&bcParam);
1882 SoftbusBroadcastParam adapterParam = {};
1883 ConvertBcParams(&bcParam, &adapterParam);
1884 BuildBroadcastPacketExceptPayload(&packet);
1885
1886 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
1887 packet.bcData.payload = BC_DATA_PAYLOAD;
1888 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
1889 packet.rspData.payload = RSP_DATA_PAYLOAD;
1890
1891 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1892
1893 int32_t bcId = -1;
1894 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1895 EXPECT_TRUE(bcId >= 0);
1896
1897 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
1898 EXPECT_EQ(SOFTBUS_BC_MGR_WAIT_COND_FAIL, PerformSetBroadcastingParam(bcId, &adapterParam));
1899 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1900 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1901 DISC_LOGI(DISC_TEST, "PerformSetBroadcastingParam004 end ----");
1902 }
1903
1904 /*
1905 * @tc.name: EnableBroadcasting001
1906 * @tc.desc: EnableBroadcasting001
1907 * @tc.type: FUNC
1908 * @tc.require:
1909 */
1910 HWTEST_F(SoftbusBroadcastMgrTest, EnableBroadcasting001, TestSize.Level1)
1911 {
1912 DISC_LOGI(DISC_TEST, "EnableBroadcasting001 begin ----");
1913 ManagerMock managerMock;
1914 EXPECT_CALL(managerMock, SoftBusCondWait)
1915 .WillRepeatedly(Return(SOFTBUS_ERR));
1916
1917 BroadcastParam bcParam = {};
1918 BroadcastPacket packet = {};
1919 BuildBroadcastParam(&bcParam);
1920 SoftbusBroadcastParam adapterParam = {};
1921 ConvertBcParams(&bcParam, &adapterParam);
1922 BuildBroadcastPacketExceptPayload(&packet);
1923
1924 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
1925 packet.bcData.payload = BC_DATA_PAYLOAD;
1926 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
1927 packet.rspData.payload = RSP_DATA_PAYLOAD;
1928
1929 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1930
1931 int32_t bcId = -1;
1932 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1933 EXPECT_TRUE(bcId >= 0);
1934 int32_t bcIdTest = bcId + 1;
1935
1936 EXPECT_EQ(SOFTBUS_BC_MGR_INVALID_BC_ID, EnableBroadcasting(bcIdTest));
1937 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1938 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1939 DISC_LOGI(DISC_TEST, "EnableBroadcasting001 end ----");
1940 }
1941
1942 /*
1943 * @tc.name: EnableBroadcasting002
1944 * @tc.desc: EnableBroadcasting002
1945 * @tc.type: FUNC
1946 * @tc.require:
1947 */
1948 HWTEST_F(SoftbusBroadcastMgrTest, EnableBroadcasting002, TestSize.Level1)
1949 {
1950 DISC_LOGI(DISC_TEST, "EnableBroadcasting002 begin ----");
1951 ManagerMock managerMock;
1952 EXPECT_CALL(managerMock, SoftBusCondWait)
1953 .WillRepeatedly(Return(SOFTBUS_ERR));
1954
1955 BroadcastParam bcParam = {};
1956 BroadcastPacket packet = {};
1957 BuildBroadcastParam(&bcParam);
1958 SoftbusBroadcastParam adapterParam = {};
1959 ConvertBcParams(&bcParam, &adapterParam);
1960 BuildBroadcastPacketExceptPayload(&packet);
1961
1962 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
1963 packet.bcData.payload = BC_DATA_PAYLOAD;
1964 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
1965 packet.rspData.payload = RSP_DATA_PAYLOAD;
1966
1967 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1968
1969 int32_t bcId = -1;
1970 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
1971 EXPECT_TRUE(bcId >= 0);
1972
1973 EXPECT_EQ(SOFTBUS_BC_MGR_NOT_BROADCASTING, EnableBroadcasting(bcId));
1974 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
1975 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1976 DISC_LOGI(DISC_TEST, "EnableBroadcasting002 end ----");
1977 }
1978
1979 /*
1980 * @tc.name: QueryBroadcastStatus001
1981 * @tc.desc: QueryBroadcastStatus001
1982 * @tc.type: FUNC
1983 * @tc.require:
1984 */
1985 HWTEST_F(SoftbusBroadcastMgrTest, QueryBroadcastStatus001, TestSize.Level1)
1986 {
1987 DISC_LOGI(DISC_TEST, "QueryBroadcastStatus001 begin ----");
1988 ManagerMock managerMock;
1989 EXPECT_CALL(managerMock, SoftBusCondWait)
1990 .WillRepeatedly(Return(SOFTBUS_ERR));
1991
1992 int32_t bcId = -1;
1993 EXPECT_EQ(SOFTBUS_OK, QueryBroadcastStatus(bcId, &bcId));
1994 DISC_LOGI(DISC_TEST, "QueryBroadcastStatus001 end ----");
1995 }
1996
1997 /*
1998 * @tc.name: BroadcastSetAdvDeviceParam001
1999 * @tc.desc: BroadcastSetAdvDeviceParam001
2000 * @tc.type: FUNC
2001 * @tc.require:
2002 */
2003 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetAdvDeviceParam001, TestSize.Level1)
2004 {
2005 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam001 begin ----");
2006 ManagerMock managerMock;
2007
2008 g_baseFuzzPos = 0;
2009 uint8_t type = GetData<uint8_t>();
2010 LpScanParam lpScanParam = BuildLpScanParam();
2011 lpScanParam.listenerId = listenderId;
2012 LpBroadcastParam lpBcParam;
2013 BuildLpBroadcastParam(&lpBcParam);
2014
2015 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2016 int32_t bcId = -1;
2017 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
2018 EXPECT_TRUE(bcId >= 0);
2019
2020 EXPECT_FALSE(BroadcastSetAdvDeviceParam(static_cast<LpServerType>(type), &lpBcParam, &lpScanParam));
2021
2022 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
2023 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2024 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam001 end ----");
2025 }
2026
2027 /*
2028 * @tc.name: BroadcastSetAdvDeviceParam002
2029 * @tc.desc: BroadcastSetAdvDeviceParam002
2030 * @tc.type: FUNC
2031 * @tc.require:
2032 */
2033 HWTEST_F(SoftbusBroadcastMgrTest, BroadcastSetAdvDeviceParam002, TestSize.Level1)
2034 {
2035 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam002 begin ----");
2036 ManagerMock managerMock;
2037
2038 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
2039 int32_t bcId = -1;
2040 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &bcId, GetScanCallback()));
2041 EXPECT_TRUE(bcId >= 0);
2042
2043 g_baseFuzzPos = 0;
2044 uint8_t type = GetData<uint8_t>();
2045 LpScanParam lpScanParam = BuildLpScanParam();
2046 lpScanParam.listenerId = bcId;
2047 uint8_t filterNum = 1;
2048 BcScanFilter *filter = GetBcScanFilter();
2049 LpBroadcastParam lpBcParam;
2050 BuildLpBroadcastParam(&lpBcParam);
2051
2052 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(bcId, filter, filterNum));
2053 EXPECT_FALSE(BroadcastSetAdvDeviceParam(static_cast<LpServerType>(type), &lpBcParam, &lpScanParam));
2054
2055 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(bcId));
2056 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
2057 DISC_LOGI(DISC_TEST, "BroadcastSetAdvDeviceParam002 end ----");
2058 }
2059 } // namespace OHOS
2060