1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "assert_helper.h"
17 #include "bluetooth_mock.h"
18 #include "c_header/ohos_bt_gatt.h"
19 #include "disc_log.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_ble_gatt_public.h"
22 #include "softbus_broadcast_type.h"
23 #include "softbus_error_code.h"
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26
27 #define GATT_ADV_MAX_NUM 20
28
29 using namespace testing::ext;
30 using ::testing::AtMost;
31 using ::testing::Return;
32
33 namespace OHOS {
34
35 class ScanResultCtx : public RecordCtx {
36 public:
37 explicit ScanResultCtx(const char *identifier);
38 ~ScanResultCtx();
39 bool Update(int32_t scannerId, const SoftBusBcScanResult *reportData);
40 testing::AssertionResult Expect(int32_t scannerId, const SoftBusBcScanResult *reportData);
41
42 private:
43 SoftBusBcScanResult scanResult;
44 void Reset();
45 };
46
47 class SoftbusBleGattTest : public testing::Test {
48 public:
49 static ScanResultCtx scanResultCtx;
50
51 static StRecordCtx advEnableCtx;
52 static StRecordCtx advDisableCtx;
53 static StRecordCtx advDataCtx;
54 static StRecordCtx advUpdateCtx;
55 static int32_t btInnerAdvId;
56 static int32_t g_status;
57 static int32_t g_adapterBcld;
58
59 static void SetUpTestCase(void);
60 };
61
62 ScanResultCtx SoftbusBleGattTest::scanResultCtx("OnReportScanDataCallback");
63
64 StRecordCtx SoftbusBleGattTest::advEnableCtx("AdvEnableCallback");
65 StRecordCtx SoftbusBleGattTest::advDisableCtx("AdvDisableCallback");
66 StRecordCtx SoftbusBleGattTest::advDataCtx("AdvDataCallback");
67 StRecordCtx SoftbusBleGattTest::advUpdateCtx("AdvUpdateCallback");
68 int32_t SoftbusBleGattTest::btInnerAdvId = -1;
69 int32_t SoftbusBleGattTest::g_status = -1;
70 int32_t SoftbusBleGattTest::g_adapterBcld = -1;
71
SetUpTestCase()72 void SoftbusBleGattTest::SetUpTestCase()
73 {
74 MockBluetooth mocker;
75 SoftbusBleAdapterInit();
76 ASSERT_NE(MockBluetooth::interface, nullptr);
77 MockBluetooth::interface->Init();
78 }
79
StubOnScanResult(BroadcastProtocol protocol,int32_t scannerId,const SoftBusBcScanResult * reportData)80 static void StubOnScanResult(BroadcastProtocol protocol, int32_t scannerId, const SoftBusBcScanResult *reportData)
81 {
82 (void)protocol;
83 SoftbusBleGattTest::scanResultCtx.Update(scannerId, reportData);
84 }
85
GetStubScanListener()86 static SoftbusScanCallback *GetStubScanListener()
87 {
88 static SoftbusScanCallback listener = { .OnStartScanCallback = nullptr,
89 .OnStopScanCallback = nullptr,
90 .OnReportScanDataCallback = StubOnScanResult,
91 .OnScanStateChanged = nullptr };
92 return &listener;
93 }
94
StubAdvEnableCallback(BroadcastProtocol protocol,int32_t advId,int32_t status)95 static void StubAdvEnableCallback(BroadcastProtocol protocol, int32_t advId, int32_t status)
96 {
97 (void)protocol;
98 SoftbusBleGattTest::advEnableCtx.Update(advId, status);
99 }
100
StubAdvDisableCallback(BroadcastProtocol protocol,int32_t advId,int32_t status)101 static void StubAdvDisableCallback(BroadcastProtocol protocol, int32_t advId, int32_t status)
102 {
103 (void)protocol;
104 SoftbusBleGattTest::advDisableCtx.Update(advId, status);
105 }
106
StubAdvUpdateCallback(BroadcastProtocol protocol,int32_t advId,int32_t status)107 static void StubAdvUpdateCallback(BroadcastProtocol protocol, int32_t advId, int32_t status)
108 {
109 (void)protocol;
110 SoftbusBleGattTest::advUpdateCtx.Update(advId, status);
111 }
112
StubAdvDataCallback(BroadcastProtocol protocol,int32_t advId,int32_t status)113 static void StubAdvDataCallback(BroadcastProtocol protocol, int32_t advId, int32_t status)
114 {
115 (void)protocol;
116 SoftbusBleGattTest::advDataCtx.Update(advId, status);
117 }
118
GetStubAdvCallback()119 SoftbusBroadcastCallback *GetStubAdvCallback()
120 {
121 static SoftbusBroadcastCallback callback = {
122 .OnStartBroadcastingCallback = StubAdvEnableCallback,
123 .OnStopBroadcastingCallback = StubAdvDisableCallback,
124 .OnUpdateBroadcastingCallback = StubAdvUpdateCallback,
125 .OnSetBroadcastingCallback = StubAdvDataCallback,
126 };
127 return &callback;
128 }
129
PrepareScanListener(int32_t * scannerId)130 static testing::AssertionResult PrepareScanListener(int32_t *scannerId)
131 {
132 int32_t ret = MockBluetooth::interface->RegisterScanListener(scannerId, GetStubScanListener());
133 if (ret != SOFTBUS_OK) {
134 return testing::AssertionFailure() << "RegisterScanListener failed";
135 }
136 if (MockBluetooth::bleScanCallback == nullptr) {
137 return testing::AssertionFailure() << "RegisterScanListener is not invoke";
138 }
139 return testing::AssertionSuccess();
140 }
141
CreateScanFilter()142 static SoftBusBcScanFilter *CreateScanFilter()
143 {
144 unsigned char serviceData[] = { 0xE, 0xE, 0xF, 0xF, 0x04, 0x05 };
145 int32_t len = sizeof(serviceData);
146
147 SoftBusBcScanFilter *filter = static_cast<SoftBusBcScanFilter *>(SoftBusCalloc(sizeof(SoftBusBcScanFilter)));
148 unsigned char *serviceDataPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
149 unsigned char *serviceDataMaskPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
150 if (filter == nullptr || serviceDataPtr == nullptr || serviceDataMaskPtr == nullptr) {
151 goto EXIT;
152 }
153 if (memcpy_s(serviceDataPtr, len, serviceData, len) != EOK) {
154 goto EXIT;
155 }
156 if (memset_s(serviceDataMaskPtr, len, 0xFF, len) != EOK) {
157 goto EXIT;
158 }
159 filter->serviceData = serviceDataPtr;
160 filter->serviceDataMask = serviceDataMaskPtr;
161 filter->serviceDataLength = len;
162 return filter;
163 EXIT:
164 SoftBusFree(filter);
165 SoftBusFree(serviceDataPtr);
166 SoftBusFree(serviceDataMaskPtr);
167 return nullptr;
168 }
169
170 /**
171 * @tc.name: SoftbusGattInit001
172 * @tc.desc: Test lnit will return SOFTBUS_OK when called more than once
173 * @tc.type: FUNC
174 * @tc.require: NONE
175 */
176 HWTEST_F(SoftbusBleGattTest, SoftbusGattInit001, TestSize.Level1)
177 {
178 int32_t ret = MockBluetooth::interface->Init();
179 EXPECT_EQ(ret, SOFTBUS_OK);
180
181 ret = MockBluetooth::interface->Init();
182 EXPECT_EQ(ret, SOFTBUS_OK);
183 }
184
185 /**
186 * @tc.name: SoftbusGattDeInit001
187 * @tc.desc: Test DeInit will return SOFTBUS_OK when called more than once
188 * @tc.type: FUNC
189 * @tc.require: NONE
190 */
191 HWTEST_F(SoftbusBleGattTest, SoftbusGattDeInit001, TestSize.Level1)
192 {
193 int32_t ret = MockBluetooth::interface->DeInit();
194 EXPECT_EQ(ret, SOFTBUS_OK);
195
196 ret = MockBluetooth::interface->DeInit();
197 EXPECT_EQ(ret, SOFTBUS_OK);
198 }
199
200 /**
201 * @tc.name: SoftbusRegisterAdvCb001
202 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_INVALID_PARAM when called more than once
203 * @tc.type: FUNC
204 * @tc.require: NONE
205 */
206 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterAdvCb001, TestSize.Level1)
207 {
208 int32_t ret = MockBluetooth::interface->RegisterBroadcaster(nullptr, nullptr);
209 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
210 }
211
212 // 充当参数
FakeBcBleCallback(BroadcastProtocol protocol,int32_t adapterBcld,int32_t status)213 static void FakeBcBleCallback(BroadcastProtocol protocol, int32_t adapterBcld, int32_t status)
214 {
215 (void)protocol;
216 SoftbusBleGattTest::g_adapterBcld = adapterBcld;
217 SoftbusBleGattTest::g_status = status;
218 }
219
220 static SoftbusBroadcastCallback g_softbusBcBleCbTest = {
221 .OnStartBroadcastingCallback = FakeBcBleCallback,
222 .OnStopBroadcastingCallback = FakeBcBleCallback,
223 .OnUpdateBroadcastingCallback = FakeBcBleCallback,
224 .OnSetBroadcastingCallback = FakeBcBleCallback,
225 .OnSetBroadcastingParamCallback = FakeBcBleCallback,
226 .OnDisableBroadcastingCallback = FakeBcBleCallback,
227 .OnEnableBroadcastingCallback = FakeBcBleCallback,
228 };
229
230 /**
231 * @tc.name: SoftbusRegisterAdvCb002
232 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_LOCK_ERR when called more than once
233 * @tc.type: FUNC
234 * @tc.require: NONE
235 */
236 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterAdvCb002, TestSize.Level1)
237 {
238 int32_t advld = 0;
239 int32_t ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
240 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
241 }
242
243 /**
244 * @tc.name: SoftbusRegisterAdvCb003
245 * @tc.desc: Test SoftbusRegisterAdvCb will return OHOS_BT_STATUS_FAIL
246 * @tc.type: FUNC
247 * @tc.require: NONE
248 */
249 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterAdvCb003, TestSize.Level1)
250 {
251 MockBluetooth mocker;
252 int32_t ret = MockBluetooth::interface->Init();
253 EXPECT_EQ(ret, SOFTBUS_OK);
254
255 int32_t advld = 0;
256 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
257 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
258 EXPECT_EQ(ret, OHOS_BT_STATUS_FAIL);
259
260 ret = MockBluetooth::interface->DeInit();
261 EXPECT_EQ(ret, SOFTBUS_OK);
262 }
263
264 /**
265 * @tc.name: SoftbusRegisterAdvCb004
266 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_OK when BleGattRegisterCallbacks
267 * @tc.type: FUNC
268 * @tc.require: NONE
269 */
270 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterAdvCb004, TestSize.Level1)
271 {
272 MockBluetooth mocker;
273 int32_t ret = MockBluetooth::interface->Init();
274 EXPECT_EQ(ret, SOFTBUS_OK);
275
276 int32_t advld = 0;
277 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
278 EXPECT_EQ(ret, SOFTBUS_OK);
279
280 ret = MockBluetooth::interface->DeInit();
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 }
283
284 /**
285 * @tc.name: SoftbusUnRegisterAdvCb001
286 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_INVALID_PARAM when given invalid param
287 * @tc.type: FUNC
288 * @tc.require: NONE
289 */
290 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterAdvCb001, TestSize.Level1)
291 {
292 int32_t ret = MockBluetooth::interface->UnRegisterBroadcaster(GATT_ADV_MAX_NUM);
293 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
294
295 int32_t advld = -1;
296 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
297 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
298 }
299
300 /**
301 * @tc.name: SoftbusUnRegisterAdvCb002
302 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_LOCK_ERR when never called init
303 * @tc.type: FUNC
304 * @tc.require: NONE
305 */
306 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterAdvCb002, TestSize.Level1)
307 {
308 int32_t advld = 0;
309 int32_t ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
310 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
311 }
312
313 /**
314 * @tc.name: SoftbusUnRegisterAdvCb003
315 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_OK when given vaild param
316 * @tc.type: FUNC
317 * @tc.require: NONE
318 */
319 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterAdvCb003, TestSize.Level1)
320 {
321 int32_t ret = MockBluetooth::interface->Init();
322 EXPECT_EQ(ret, SOFTBUS_OK);
323
324 int32_t advld = 0;
325 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
326 EXPECT_EQ(ret, SOFTBUS_OK);
327
328 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
329 EXPECT_EQ(ret, SOFTBUS_OK);
330
331 ret = MockBluetooth::interface->DeInit();
332 EXPECT_EQ(ret, SOFTBUS_OK);
333 }
334
335 /**
336 * @tc.name: SoftbusRegisterScanCb001
337 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_INVALID_PARAM when given invalid param
338 * @tc.type: FUNC
339 * @tc.require: NONE
340 */
341 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterScanCb001, TestSize.Level1)
342 {
343 int32_t ret = MockBluetooth::interface->RegisterScanListener(nullptr, nullptr);
344 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
345 }
346
347 // 充当参数
FakeScanCallback(BroadcastProtocol protocol,int32_t adapterScanld,int32_t status)348 static void FakeScanCallback(BroadcastProtocol protocol, int32_t adapterScanld, int32_t status)
349 {
350 (void)protocol;
351 (void)adapterScanld;
352 (void)status;
353 }
354
FakeReportScanDataCallback(BroadcastProtocol protocol,int32_t adapterScanld,const SoftBusBcScanResult * reportData)355 static void FakeReportScanDataCallback(BroadcastProtocol protocol,
356 int32_t adapterScanld, const SoftBusBcScanResult *reportData)
357 {
358 (void)protocol;
359 (void)adapterScanld;
360 (void)reportData;
361 }
362
FakeScanStateChanged(BroadcastProtocol protocol,int32_t resultCode,bool isStartScan)363 static void FakeScanStateChanged(BroadcastProtocol protocol, int32_t resultCode, bool isStartScan)
364 {
365 (void)protocol;
366 (void)resultCode;
367 (void)isStartScan;
368 }
369
FakeLpDeviceInfoCallback(BroadcastProtocol protocol,const SoftbusBroadcastUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)370 static void FakeLpDeviceInfoCallback(BroadcastProtocol protocol,
371 const SoftbusBroadcastUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
372 {
373 (void)protocol;
374 (void)uuid;
375 (void)type;
376 (void)data;
377 (void)dataSize;
378 }
379
380 static SoftbusScanCallback g_softbusBcBleScanCbTest = {
381 .OnStartScanCallback = FakeScanCallback,
382 .OnStopScanCallback = FakeScanCallback,
383 .OnReportScanDataCallback = FakeReportScanDataCallback,
384 .OnScanStateChanged = FakeScanStateChanged,
385 .OnLpDeviceInfoCallback = FakeLpDeviceInfoCallback,
386 };
387
388 /**
389 * @tc.name: SoftbusRegisterScanCb002
390 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_LOCK_ERR when never called init
391 * @tc.type: FUNC
392 * @tc.require: NONE
393 */
394 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterScanCb002, TestSize.Level1)
395 {
396 int32_t scannerld = 0;
397 int32_t ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
398 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
399 }
400
401 /**
402 * @tc.name: SoftbusRegisterScanCb003
403 * @tc.desc: Test SoftbusRegisterScanCb will return OHOS_BT_STATUS_FAIL
404 * @tc.type: FUNC
405 * @tc.require: NONE
406 */
407 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterScanCb003, TestSize.Level1)
408 {
409 MockBluetooth mocker;
410 int32_t ret = MockBluetooth::interface->Init();
411 EXPECT_EQ(ret, SOFTBUS_OK);
412
413 int32_t scannerld = 0;
414 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
415 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
416 EXPECT_EQ(ret, OHOS_BT_STATUS_FAIL);
417
418 ret = MockBluetooth::interface->DeInit();
419 EXPECT_EQ(ret, SOFTBUS_OK);
420 }
421
422 /**
423 * @tc.name: SoftbusRegisterScanCb004
424 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_BC_ADAPTER_REGISTER_FAIL when scan channel are all uesd
425 * @tc.type: FUNC
426 * @tc.require: NONE
427 */
428 HWTEST_F(SoftbusBleGattTest, SoftbusRegisterScanCb004, TestSize.Level1)
429 {
430 MockBluetooth mocker;
431 int32_t ret = MockBluetooth::interface->Init();
432 EXPECT_EQ(ret, SOFTBUS_OK);
433
434 int32_t scannerld = 0;
435 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
436
437 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
438 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
439 EXPECT_EQ(ret, OHOS_BT_STATUS_SUCCESS);
440 }
441
442 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
443 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_REGISTER_FAIL);
444
445 ret = MockBluetooth::interface->DeInit();
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 }
448
449 /**
450 * @tc.name: SoftbusUnRegisterScanCb001
451 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_INVALID_PARAM when given invalid param
452 * @tc.type: FUNC
453 * @tc.require: NONE
454 */
455 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterScanCb001, TestSize.Level1)
456 {
457 int32_t scannerld = -1;
458 int32_t ret = MockBluetooth::interface->UnRegisterScanListener(GATT_SCAN_MAX_NUM);
459 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
460
461 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
462 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
463 }
464
465 /**
466 * @tc.name: SoftbusUnRegisterScanCb002
467 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_LOCK_ERR when never called init
468 * @tc.type: FUNC
469 * @tc.require: NONE
470 */
471 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterScanCb002, TestSize.Level1)
472 {
473 int32_t scannerld = 0;
474 int32_t ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
475 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
476 }
477
478 /**
479 * @tc.name: SoftbusUnRegisterScanCb003
480 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_OK when successfully unregistered
481 * @tc.type: FUNC
482 * @tc.require: NONE
483 */
484 HWTEST_F(SoftbusBleGattTest, SoftbusUnRegisterScanCb003, TestSize.Level1)
485 {
486 MockBluetooth mocker;
487 int32_t ret = MockBluetooth::interface->Init();
488 EXPECT_EQ(ret, SOFTBUS_OK);
489
490 int32_t scannerld = 0;
491 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
492 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
493 EXPECT_EQ(ret, SOFTBUS_OK);
494
495 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
496 EXPECT_EQ(ret, SOFTBUS_OK);
497
498 ret = MockBluetooth::interface->DeInit();
499 EXPECT_EQ(ret, SOFTBUS_OK);
500 }
501
502 /**
503 * @tc.name: SoftbusStartAdv001
504 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_INVALID_PARAM when given invalid param
505 * @tc.type: FUNC
506 * @tc.require: NONE
507 */
508 HWTEST_F(SoftbusBleGattTest, SoftbusStartAdv001, TestSize.Level1)
509 {
510 int32_t advld = 0;
511 int32_t ret = MockBluetooth::interface->StartBroadcasting(advld, nullptr, nullptr);
512 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
513 }
514
515 const char ADV_DATA_EXAMPLE[] = {
516 0x02,
517 0x01,
518 0x02,
519 0x15,
520 0x16,
521 0xEE,
522 0xFD,
523 0x04,
524 0x05,
525 0x90,
526 0x00,
527 0x00,
528 0x04,
529 0x00,
530 0x18,
531 0x33,
532 0x39,
533 0x36,
534 0x62,
535 0x33,
536 0x61,
537 0x33,
538 0x31,
539 0x21,
540 0x00,
541 0x02,
542 0x0A,
543 0xEF,
544 };
545 const unsigned char SCAN_RSP_DATA_EXAMPLE[] = { 0x03, 0xFF, 0x7D, 0x02 };
546
BuildBcData(void)547 static SoftbusBroadcastData BuildBcData(void)
548 {
549 SoftbusBroadcastData data = {};
550 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
551 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
552 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
553 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
554 return data;
555 }
556
557 /**
558 * @tc.name: SoftbusStartAdv002
559 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_LOCK_ERR when never called init
560 * @tc.type: FUNC
561 * @tc.require: NONE
562 */
563 HWTEST_F(SoftbusBleGattTest, SoftbusStartAdv002, TestSize.Level1)
564 {
565 int32_t advld = 0;
566 SoftbusBroadcastParam params = {};
567 SoftbusBroadcastData data = BuildBcData();
568
569 int32_t ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
570 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
571 }
572
573 /**
574 * @tc.name: SoftbusStartAdv003
575 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld is not used
576 * @tc.type: FUNC
577 * @tc.require: NONE
578 */
579 HWTEST_F(SoftbusBleGattTest, SoftbusStartAdv003, TestSize.Level1)
580 {
581 int32_t ret = MockBluetooth::interface->Init();
582 EXPECT_EQ(ret, SOFTBUS_OK);
583
584 int32_t advld = 0;
585 SoftbusBroadcastParam params = {};
586 SoftbusBroadcastData data = BuildBcData();
587
588 ret = MockBluetooth::interface->StartBroadcasting(GATT_ADV_MAX_NUM, ¶ms, &data);
589 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
590
591 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
592 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
593
594 ret = MockBluetooth::interface->DeInit();
595 EXPECT_EQ(ret, SOFTBUS_OK);
596 }
597
598 /**
599 * @tc.name: SoftbusStartAdv004
600 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_ALREADY_TRIGGERED
601 * @tc.type: FUNC
602 * @tc.require: NONE
603 */
604 HWTEST_F(SoftbusBleGattTest, SoftbusStartAdv004, TestSize.Level1)
605 {
606 MockBluetooth mocker;
607 int32_t ret = MockBluetooth::interface->Init();
608 EXPECT_EQ(ret, SOFTBUS_OK);
609
610 int32_t advld = 0;
611 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
612 EXPECT_EQ(ret, SOFTBUS_OK);
613
614 EXPECT_CALL(mocker, BleStartAdvEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
615 SoftbusBroadcastParam params = {};
616 SoftbusBroadcastData data = BuildBcData();
617
618 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
619 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
620 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
621 ret = MockBluetooth::interface->DeInit();
622 EXPECT_EQ(ret, SOFTBUS_OK);
623 }
624
625 /**
626 * @tc.name: SoftbusStopAdv001
627 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_LOCK_ERR when never called lnit
628 * @tc.type: FUNC
629 * @tc.require: NONE
630 */
631 HWTEST_F(SoftbusBleGattTest, SoftbusStopAdv001, TestSize.Level1)
632 {
633 int32_t advld = 0;
634 int32_t ret = MockBluetooth::interface->StopBroadcasting(advld);
635 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
636 }
637
638 /**
639 * @tc.name: SoftbusStopAdv002
640 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld never registed
641 * @tc.type: FUNC
642 * @tc.require: NONE
643 */
644 HWTEST_F(SoftbusBleGattTest, SoftbusStopAdv002, TestSize.Level1)
645 {
646 int32_t ret = MockBluetooth::interface->Init();
647 EXPECT_EQ(ret, SOFTBUS_OK);
648
649 ret = MockBluetooth::interface->StopBroadcasting(GATT_ADV_MAX_NUM);
650 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
651
652 ret = MockBluetooth::interface->DeInit();
653 EXPECT_EQ(ret, SOFTBUS_OK);
654 }
655
656 /**
657 * @tc.name: SoftbusStopAdv004
658 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_OK when advld has been registed
659 * @tc.type: FUNC
660 * @tc.require: NONE
661 */
662 HWTEST_F(SoftbusBleGattTest, SoftbusStopAdv004, TestSize.Level1)
663 {
664 MockBluetooth mocker;
665 int32_t ret = MockBluetooth::interface->Init();
666 EXPECT_EQ(ret, SOFTBUS_OK);
667
668 int32_t advld = 0;
669 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
670 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
671 EXPECT_EQ(ret, SOFTBUS_OK);
672
673 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
674 ret = MockBluetooth::interface->StopBroadcasting(advld);
675 EXPECT_EQ(ret, SOFTBUS_OK);
676
677 ret = MockBluetooth::interface->DeInit();
678 EXPECT_EQ(ret, SOFTBUS_OK);
679 }
680
681 /**
682 * @tc.name: SoftbusStopAdv005
683 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_OK when advld has been stopped
684 * @tc.type: FUNC
685 * @tc.require: NONE
686 */
687 HWTEST_F(SoftbusBleGattTest, SoftbusStopAdv005, TestSize.Level1)
688 {
689 MockBluetooth mocker;
690 int32_t ret = MockBluetooth::interface->Init();
691 EXPECT_EQ(ret, SOFTBUS_OK);
692
693 int32_t advld = 0;
694 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
695 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
696 EXPECT_EQ(ret, SOFTBUS_OK);
697
698 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
699 ret = MockBluetooth::interface->StopBroadcasting(advld);
700 EXPECT_EQ(ret, SOFTBUS_OK);
701
702 ret = MockBluetooth::interface->StopBroadcasting(advld);
703 EXPECT_EQ(ret, SOFTBUS_OK);
704
705 ret = MockBluetooth::interface->DeInit();
706 EXPECT_EQ(ret, SOFTBUS_OK);
707 }
708
709 /**
710 * @tc.name: SoftbusSetAdvData001
711 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_INVALID_PARAM when given invalid param
712 * @tc.type: FUNC
713 * @tc.require: NONE
714 */
715 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvData001, TestSize.Level1)
716 {
717 int32_t advld = 0;
718 int32_t ret = MockBluetooth::interface->SetBroadcastingData(advld, nullptr);
719 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
720 }
721
722 /**
723 * @tc.name: SoftbusSetAdvData002
724 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_LOCK_ERR when never lnit
725 * @tc.type: FUNC
726 * @tc.require: NONE
727 */
728 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvData002, TestSize.Level1)
729 {
730 int32_t advld = 0;
731 SoftbusBroadcastData data = BuildBcData();
732
733 int32_t ret = MockBluetooth::interface->SetBroadcastingData(advld, &data);
734 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
735 }
736
737 /**
738 * @tc.name: SoftbusSetAdvData003
739 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld is not used
740 * @tc.type: FUNC
741 * @tc.require: NONE
742 */
743 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvData003, TestSize.Level1)
744 {
745 int32_t ret = MockBluetooth::interface->Init();
746 EXPECT_EQ(ret, SOFTBUS_OK);
747
748 SoftbusBroadcastData data = BuildBcData();
749 ret = MockBluetooth::interface->SetBroadcastingData(GATT_ADV_MAX_NUM, &data);
750 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
751
752 ret = MockBluetooth::interface->DeInit();
753 EXPECT_EQ(ret, SOFTBUS_OK);
754 }
755
756 /**
757 * @tc.name: SoftbusSetAdvData005
758 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_ALREADY_TRIGGERED when broadcast has already registed
759 * @tc.type: FUNC
760 * @tc.require: NONE
761 */
762 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvData005, TestSize.Level1)
763 {
764 MockBluetooth mocker;
765 int32_t ret = MockBluetooth::interface->Init();
766 EXPECT_EQ(ret, SOFTBUS_OK);
767
768 int32_t advld = 0;
769 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
770 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
771 EXPECT_EQ(ret, SOFTBUS_OK);
772
773 SoftbusBroadcastData data = BuildBcData();
774 ret = MockBluetooth::interface->SetBroadcastingData(advld, &data);
775 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
776
777 ret = MockBluetooth::interface->DeInit();
778 EXPECT_EQ(ret, SOFTBUS_OK);
779 }
780
781 /**
782 * @tc.name: SoftbusUpdateAdvData001
783 * @tc.desc: Test SoftbusUpdateAdvData will return SOFTBUS_LOCK_ERR when never called init
784 * @tc.type: FUNC
785 * @tc.require: NONE
786 */
787 HWTEST_F(SoftbusBleGattTest, SoftbusUpdateAdvData001, TestSize.Level1)
788 {
789 int32_t advld = 0;
790 SoftbusBroadcastParam param;
791 SoftbusBroadcastData packet;
792 int32_t ret = MockBluetooth::interface->UpdateBroadcasting(advld, ¶m, &packet);
793 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
794 }
795
796 /**
797 * @tc.name: SoftbusUpdateAdvData002
798 * @tc.desc: Test SoftbusUpdateAdvData will return SOFTBUS_INVALID_PARAM when given invalid params
799 * @tc.type: FUNC
800 * @tc.require: NONE
801 */
802 HWTEST_F(SoftbusBleGattTest, SoftbusUpdateAdvData002, TestSize.Level1)
803 {
804 MockBluetooth mocker;
805 int32_t ret = MockBluetooth::interface->Init();
806 EXPECT_EQ(ret, SOFTBUS_OK);
807
808 int32_t advld = 0;
809 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
810 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
811 EXPECT_EQ(ret, SOFTBUS_OK);
812
813 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
814 ret = MockBluetooth::interface->UpdateBroadcasting(advld, nullptr, nullptr);
815 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
816
817 ret = MockBluetooth::interface->DeInit();
818 EXPECT_EQ(ret, SOFTBUS_OK);
819 }
820
821 /**
822 * @tc.name: SoftbusStartScan001
823 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_INVALID_PARAM when given invalid params
824 * @tc.type: FUNC
825 * @tc.require: NONE
826 */
827 HWTEST_F(SoftbusBleGattTest, SoftbusStartScan001, TestSize.Level1)
828 {
829 int32_t scannerld = 0;
830 int32_t ret = MockBluetooth::interface->StartScan(scannerld, nullptr, nullptr, 0);
831 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
832 }
833
834 /**
835 * @tc.name: SoftbusStartScan002
836 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_LOCK_ERR when never called init
837 * @tc.type: FUNC
838 * @tc.require: NONE
839 */
840 HWTEST_F(SoftbusBleGattTest, SoftbusStartScan002, TestSize.Level1)
841 {
842 SoftBusBcScanParams scanParam = {
843 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
844 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
845 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
846 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
847 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
848 };
849
850 SoftBusBcScanFilter softBusBcScanFilter = {};
851 softBusBcScanFilter.address = (int8_t *)"address";
852 softBusBcScanFilter.deviceName = (int8_t *)"deviceName";
853 softBusBcScanFilter.serviceUuid = 1;
854 softBusBcScanFilter.serviceDataLength = 1;
855 softBusBcScanFilter.manufactureId = 1;
856 softBusBcScanFilter.manufactureDataLength = 1;
857
858 int32_t scannerld = 0;
859 int32_t filterSize = 1;
860 int32_t ret = MockBluetooth::interface->StartScan(scannerld, &scanParam, &softBusBcScanFilter, filterSize);
861 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
862 }
863
864 /**
865 * @tc.name: SoftbusStartScan003
866 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when given invalid params scannerld
867 * @tc.type: FUNC
868 * @tc.require: NONE
869 */
870 HWTEST_F(SoftbusBleGattTest, SoftbusStartScan003, TestSize.Level1)
871 {
872 int32_t ret = MockBluetooth::interface->Init();
873 EXPECT_EQ(ret, SOFTBUS_OK);
874
875 SoftBusBcScanParams scanParam = {
876 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
877 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
878 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
879 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
880 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
881 };
882
883 SoftBusBcScanFilter softBusBcScanFilter = {};
884 softBusBcScanFilter.address = (int8_t *)"address";
885 softBusBcScanFilter.deviceName = (int8_t *)"deviceName";
886 softBusBcScanFilter.serviceUuid = 1;
887 softBusBcScanFilter.serviceDataLength = 1;
888 softBusBcScanFilter.manufactureId = 1;
889 softBusBcScanFilter.manufactureDataLength = 1;
890
891 int32_t filterSize = 1;
892 ret = MockBluetooth::interface->StartScan(GATT_SCAN_MAX_NUM, &scanParam, &softBusBcScanFilter, filterSize);
893 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
894
895 ret = MockBluetooth::interface->DeInit();
896 EXPECT_EQ(ret, SOFTBUS_OK);
897 }
898
899 /**
900 * @tc.name: SoftbusGetBroadcastHandle001
901 * @tc.desc: Test SoftbusGetBroadcastHandle is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
902 * @tc.type: FUNC
903 * @tc.require: NONE
904 */
905 HWTEST_F(SoftbusBleGattTest, SoftbusGetBroadcastHandle001, TestSize.Level1)
906 {
907 MockBluetooth mocker;
908 int32_t ret = MockBluetooth::interface->Init();
909 EXPECT_EQ(ret, SOFTBUS_OK);
910
911 int32_t bchand = 0;
912
913 ret = MockBluetooth::interface->GetBroadcastHandle(GATT_ADV_MAX_NUM, &bchand);
914 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
915
916 ret = MockBluetooth::interface->DeInit();
917 EXPECT_EQ(ret, SOFTBUS_OK);
918 }
919
920 /**
921 * @tc.name: SoftbusGetBroadcastHandle002
922 * @tc.desc: Test SoftbusGetBroadcastHandle is SOFTBUS_OK
923 * @tc.type: FUNC
924 * @tc.require: NONE
925 */
926 HWTEST_F(SoftbusBleGattTest, SoftbusGetBroadcastHandle002, TestSize.Level1)
927 {
928 MockBluetooth mocker;
929 int32_t ret = MockBluetooth::interface->Init();
930 EXPECT_EQ(ret, SOFTBUS_OK);
931
932 int32_t advld = 0;
933 int32_t bchand = 0;
934
935 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
936 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
937 EXPECT_EQ(ret, SOFTBUS_OK);
938
939 EXPECT_CALL(mocker, GetAdvHandle).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
940 ret = MockBluetooth::interface->GetBroadcastHandle(advld, &bchand);
941 EXPECT_EQ(ret, SOFTBUS_OK);
942
943 ret = MockBluetooth::interface->DeInit();
944 EXPECT_EQ(ret, SOFTBUS_OK);
945 }
946
947 /**
948 * @tc.name: SoftbusEnableSyncDataToLp001
949 * @tc.desc: Test SoftbusEnableSyncDataToLp is SOFTBUS_OK
950 * @tc.type: FUNC
951 * @tc.require: NONE
952 */
953 HWTEST_F(SoftbusBleGattTest, SoftbusEnableSyncDataToLp001, TestSize.Level1)
954 {
955 MockBluetooth mocker;
956 int32_t ret = MockBluetooth::interface->Init();
957 EXPECT_EQ(ret, SOFTBUS_OK);
958
959 EXPECT_CALL(mocker, EnableSyncDataToLpDevice).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
960 ret = MockBluetooth::interface->EnableSyncDataToLpDevice();
961 EXPECT_EQ(ret, SOFTBUS_OK);
962
963 ret = MockBluetooth::interface->DeInit();
964 EXPECT_EQ(ret, SOFTBUS_OK);
965 }
966
967 /**
968 * @tc.name: DisableSyncDataToLpDevice001
969 * @tc.desc: Test DisableSyncDataToLpDevice is SOFTBUS_OK
970 * @tc.type: FUNC
971 * @tc.require: NONE
972 */
973 HWTEST_F(SoftbusBleGattTest, DisableSyncDataToLpDevice001, TestSize.Level1)
974 {
975 MockBluetooth mocker;
976 int32_t ret = MockBluetooth::interface->Init();
977 EXPECT_EQ(ret, SOFTBUS_OK);
978
979 EXPECT_CALL(mocker, DisableSyncDataToLpDevice).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
980 ret = MockBluetooth::interface->DisableSyncDataToLpDevice();
981 EXPECT_EQ(ret, SOFTBUS_OK);
982
983 ret = MockBluetooth::interface->DeInit();
984 EXPECT_EQ(ret, SOFTBUS_OK);
985 }
986
987 /**
988 * @tc.name: SoftbusSetScanReportChanToLp001
989 * @tc.desc: Test SoftbusSetScanReportChanToLp is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
990 * @tc.type: FUNC
991 * @tc.require: NONE
992 */
993 HWTEST_F(SoftbusBleGattTest, SoftbusSetScanReportChanToLp001, TestSize.Level1)
994 {
995 MockBluetooth mocker;
996 int32_t ret = MockBluetooth::interface->Init();
997 EXPECT_EQ(ret, SOFTBUS_OK);
998
999 ret = MockBluetooth::interface->SetScanReportChannelToLpDevice(GATT_ADV_MAX_NUM, false);
1000 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1001
1002 ret = MockBluetooth::interface->DeInit();
1003 EXPECT_EQ(ret, SOFTBUS_OK);
1004 }
1005
1006 /**
1007 * @tc.name: SoftbusSetLpAdvParam001
1008 * @tc.desc: Test SoftbusSetLpAdvParam is SOFTBUS_OK
1009 * @tc.type: FUNC
1010 * @tc.require: NONE
1011 */
1012 HWTEST_F(SoftbusBleGattTest, SoftbusSetLpAdvParam001, TestSize.Level1)
1013 {
1014 MockBluetooth mocker;
1015 int32_t ret = MockBluetooth::interface->Init();
1016 EXPECT_EQ(ret, SOFTBUS_OK);
1017
1018 int32_t duration = 0;
1019 int32_t maxExtAdvEvents = 0;
1020 int32_t window = 0;
1021 int32_t interval = 0;
1022 int32_t bcHandle = 0;
1023
1024 EXPECT_CALL(mocker, SetLpDeviceAdvParam).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1025 ret = MockBluetooth::interface->SetLpDeviceParam(duration, maxExtAdvEvents, window, interval, bcHandle);
1026 EXPECT_EQ(ret, SOFTBUS_OK);
1027
1028 ret = MockBluetooth::interface->DeInit();
1029 EXPECT_EQ(ret, SOFTBUS_OK);
1030 }
1031
1032 /**
1033 * @tc.name: SoftbusStopScan001
1034 * @tc.desc: Test SoftbusStopScan is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
1035 * @tc.type: FUNC
1036 * @tc.require: NONE
1037 */
1038 HWTEST_F(SoftbusBleGattTest, SoftbusStopScan001, TestSize.Level1)
1039 {
1040 MockBluetooth mocker;
1041 int32_t ret = MockBluetooth::interface->Init();
1042 EXPECT_EQ(ret, SOFTBUS_OK);
1043
1044 ret = MockBluetooth::interface->StopScan(GATT_ADV_MAX_NUM);
1045 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1046
1047 ret = MockBluetooth::interface->DeInit();
1048 EXPECT_EQ(ret, SOFTBUS_OK);
1049 }
1050
1051 /**
1052 * @tc.name: WrapperAdvEnableCb001
1053 * @tc.desc: WrapperAdvEnableCb will traverse when not Regist, will traverse when btAdvId is invalid
1054 will make true isAdvertising when BtStatus=OHOS_BT_STATUS_SUCCESS,
1055 will make false isAdvertising when BtStatus=OHOS_BT_STATUS_FAIL
1056 * @tc.type: FUNC
1057 * @tc.require: NONE
1058 */
1059 HWTEST_F(SoftbusBleGattTest, WrapperAdvEnableCb001, TestSize.Level1)
1060 {
1061 DISC_LOGI(DISC_TEST, "WrapperAdvEnableCb001 enter");
1062 MockBluetooth mock;
1063 ASSERT_NE(MockBluetooth::interface, nullptr);
1064 int32_t ret = MockBluetooth::interface->Init();
1065 EXPECT_EQ(ret, SOFTBUS_OK);
1066
1067 SoftbusBleGattTest::g_adapterBcld = -1;
1068 SoftbusBleGattTest::g_status = -1;
1069 int32_t advld = -1;
1070 int32_t invalidBtAdvId = -1;
1071 MockBluetooth::btGattCallback->advEnableCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1072 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1073 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1074 EXPECT_EQ(ret, SOFTBUS_OK);
1075 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1076
1077 SoftbusBroadcastParam params = {};
1078 SoftbusBroadcastData data = BuildBcData();
1079 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1080 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1081 EXPECT_EQ(ret, SOFTBUS_OK);
1082 MockBluetooth::btGattCallback->advEnableCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1083 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1084
1085 MockBluetooth::btGattCallback->advEnableCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_FAIL);
1086 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1087
1088 MockBluetooth::interface->StopBroadcasting(advld);
1089 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1090 ret = MockBluetooth::interface->DeInit();
1091 EXPECT_EQ(ret, SOFTBUS_OK);
1092 }
1093
1094 /**
1095 * @tc.name: WrapperAdvEnableCb002
1096 * @tc.desc: WrapperAdvEnableCb will keep traverse when advCallback.OnStartBroadcastingCallback=nullptr
1097 * @tc.type: FUNC
1098 * @tc.require: NONE
1099 */
1100 HWTEST_F(SoftbusBleGattTest, WrapperAdvEnableCb002, TestSize.Level1)
1101 {
1102 DISC_LOGI(DISC_TEST, "WrapperAdvEnableCb002 enter");
1103 MockBluetooth mock;
1104 ASSERT_NE(MockBluetooth::interface, nullptr);
1105 int32_t ret = MockBluetooth::interface->Init();
1106 EXPECT_EQ(ret, SOFTBUS_OK);
1107
1108 SoftbusBleGattTest::g_adapterBcld = -1;
1109 SoftbusBleGattTest::g_status = -1;
1110 int32_t advld = -1;
1111 g_softbusBcBleCbTest.OnStartBroadcastingCallback = nullptr;
1112 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1113 EXPECT_EQ(ret, SOFTBUS_OK);
1114 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1115
1116 SoftbusBroadcastParam params = {};
1117 SoftbusBroadcastData data = BuildBcData();
1118 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1119 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1120 EXPECT_EQ(ret, SOFTBUS_OK);
1121 MockBluetooth::btGattCallback->advEnableCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1122 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1123
1124 MockBluetooth::interface->StopBroadcasting(advld);
1125 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1126
1127 g_softbusBcBleCbTest.OnStartBroadcastingCallback = FakeBcBleCallback;
1128 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1129 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1130 EXPECT_EQ(ret, SOFTBUS_OK);
1131 MockBluetooth::btGattCallback->advEnableCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1132 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1133
1134 MockBluetooth::interface->StopBroadcasting(advld);
1135 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1136 ret = MockBluetooth::interface->DeInit();
1137 EXPECT_EQ(ret, SOFTBUS_OK);
1138 }
1139
1140 /**
1141 * @tc.name: WrapperAdvDisableCb001
1142 * @tc.desc: WrapperAdvDisableCb will keep traverse when not Regist, will keep traverse when btAdvId is invalid
1143 * @tc.type: FUNC
1144 * @tc.require: NONE
1145 */
1146 HWTEST_F(SoftbusBleGattTest, WrapperAdvDisableCb001, TestSize.Level1)
1147 {
1148 DISC_LOGI(DISC_TEST, "WrapperAdvDisableCb001 enter");
1149 MockBluetooth mock;
1150 ASSERT_NE(MockBluetooth::interface, nullptr);
1151 int32_t ret = MockBluetooth::interface->Init();
1152 EXPECT_EQ(ret, SOFTBUS_OK);
1153
1154 SoftbusBleGattTest::g_adapterBcld = -1;
1155 SoftbusBleGattTest::g_status = -1;
1156 int32_t advld = -1;
1157 int32_t invalidBtAdvId = -1;
1158 MockBluetooth::btGattCallback->advDisableCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1159 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1160 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1161 EXPECT_EQ(ret, SOFTBUS_OK);
1162 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1163
1164 SoftbusBroadcastParam params = {};
1165 SoftbusBroadcastData data = BuildBcData();
1166 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1167 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1168 EXPECT_EQ(ret, SOFTBUS_OK);
1169 MockBluetooth::btGattCallback->advDisableCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1170 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1171
1172 MockBluetooth::interface->StopBroadcasting(advld);
1173 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1174 ret = MockBluetooth::interface->DeInit();
1175 EXPECT_EQ(ret, SOFTBUS_OK);
1176 }
1177
1178 /**
1179 * @tc.name: WrapperAdvDisableCb002
1180 * @tc.desc: WrapperAdvDisableCb will keep traverse when advCallback.OnStopBroadcastingCallback=nullptr
1181 * @tc.type: FUNC
1182 * @tc.require: NONE
1183 */
1184 HWTEST_F(SoftbusBleGattTest, WrapperAdvDisableCb002, TestSize.Level1)
1185 {
1186 DISC_LOGI(DISC_TEST, "WrapperAdvDisableCb002 enter");
1187 MockBluetooth mock;
1188 ASSERT_NE(MockBluetooth::interface, nullptr);
1189 int32_t ret = MockBluetooth::interface->Init();
1190 EXPECT_EQ(ret, SOFTBUS_OK);
1191
1192 SoftbusBleGattTest::g_adapterBcld = -1;
1193 SoftbusBleGattTest::g_status = -1;
1194 int32_t advld = -1;
1195 g_softbusBcBleCbTest.OnStopBroadcastingCallback = nullptr;
1196 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1197 EXPECT_EQ(ret, SOFTBUS_OK);
1198 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1199
1200 SoftbusBroadcastParam params = {};
1201 SoftbusBroadcastData data = BuildBcData();
1202 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1203 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1204 EXPECT_EQ(ret, SOFTBUS_OK);
1205 MockBluetooth::btGattCallback->advDisableCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1206 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1207
1208 MockBluetooth::interface->StopBroadcasting(advld);
1209 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1210
1211 g_softbusBcBleCbTest.OnStopBroadcastingCallback = FakeBcBleCallback;
1212 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1213 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1214 EXPECT_EQ(ret, SOFTBUS_OK);
1215 MockBluetooth::btGattCallback->advDisableCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1216 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1217
1218 MockBluetooth::interface->StopBroadcasting(advld);
1219 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1220 ret = MockBluetooth::interface->DeInit();
1221 EXPECT_EQ(ret, SOFTBUS_OK);
1222 }
1223
1224 /**
1225 * @tc.name: WrapperAdvSetDataCb001
1226 * @tc.desc: WrapperAdvSetDataCb will keep traverse when not Regist, will keep traverse when btAdvId is invalid
1227 * @tc.type: FUNC
1228 * @tc.require: NONE
1229 */
1230 HWTEST_F(SoftbusBleGattTest, WrapperAdvSetDataCb001, TestSize.Level1)
1231 {
1232 DISC_LOGI(DISC_TEST, "WrapperAdvSetDataCb001 enter");
1233 MockBluetooth mock;
1234 ASSERT_NE(MockBluetooth::interface, nullptr);
1235 int32_t ret = MockBluetooth::interface->Init();
1236 EXPECT_EQ(ret, SOFTBUS_OK);
1237
1238 SoftbusBleGattTest::g_adapterBcld = -1;
1239 SoftbusBleGattTest::g_status = -1;
1240 int32_t advld = -1;
1241 int32_t invalidBtAdvId = -1;
1242 MockBluetooth::btGattCallback->advDataCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1243 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1244
1245 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1246 EXPECT_EQ(ret, SOFTBUS_OK);
1247 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1248
1249 SoftbusBroadcastParam params = {};
1250 SoftbusBroadcastData data = BuildBcData();
1251 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1252 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1253 EXPECT_EQ(ret, SOFTBUS_OK);
1254
1255 MockBluetooth::btGattCallback->advDataCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1256 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1257
1258 MockBluetooth::interface->StopBroadcasting(advld);
1259 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1260 ret = MockBluetooth::interface->DeInit();
1261 EXPECT_EQ(ret, SOFTBUS_OK);
1262 }
1263
1264 /**
1265 * @tc.name: WrapperAdvSetDataCb002
1266 * @tc.desc: WrapperAdvSetDataCb will keep traverse when advCallback.OnSetBroadcastingCallback=nullptr
1267 * @tc.type: FUNC
1268 * @tc.require: NONE
1269 */
1270 HWTEST_F(SoftbusBleGattTest, WrapperAdvSetDataCb002, TestSize.Level1)
1271 {
1272 DISC_LOGI(DISC_TEST, "WrapperAdvSetDataCb002 enter");
1273 MockBluetooth mock;
1274 ASSERT_NE(MockBluetooth::interface, nullptr);
1275 int32_t ret = MockBluetooth::interface->Init();
1276 EXPECT_EQ(ret, SOFTBUS_OK);
1277
1278 SoftbusBleGattTest::g_adapterBcld = -1;
1279 SoftbusBleGattTest::g_status = -1;
1280 int32_t advld = -1;
1281 g_softbusBcBleCbTest.OnSetBroadcastingCallback = nullptr;
1282 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1283 EXPECT_EQ(ret, SOFTBUS_OK);
1284 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1285
1286 SoftbusBroadcastParam params = {};
1287 SoftbusBroadcastData data = BuildBcData();
1288 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1289 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1290 EXPECT_EQ(ret, SOFTBUS_OK);
1291 MockBluetooth::btGattCallback->advDataCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1292 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1293
1294 MockBluetooth::interface->StopBroadcasting(advld);
1295 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1296
1297 g_softbusBcBleCbTest.OnSetBroadcastingCallback = FakeBcBleCallback;
1298 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1299 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1300 EXPECT_EQ(ret, SOFTBUS_OK);
1301 MockBluetooth::btGattCallback->advDataCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1302 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1303
1304 MockBluetooth::interface->StopBroadcasting(advld);
1305 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1306 ret = MockBluetooth::interface->DeInit();
1307 EXPECT_EQ(ret, SOFTBUS_OK);
1308 }
1309
1310 /**
1311 * @tc.name: WrapperAdvUpdateDataCb001
1312 * @tc.desc: WrapperAdvUpdateDataCb will keep traverse when not Regist, will keep traverse when btAdvId is invalid
1313 * @tc.type: FUNC
1314 * @tc.require: NONE
1315 */
1316 HWTEST_F(SoftbusBleGattTest, WrapperAdvUpdateDataCb001, TestSize.Level1)
1317 {
1318 DISC_LOGI(DISC_TEST, "WrapperAdvUpdateDataCb001 enter");
1319 MockBluetooth mock;
1320 ASSERT_NE(MockBluetooth::interface, nullptr);
1321 int32_t ret = MockBluetooth::interface->Init();
1322 EXPECT_EQ(ret, SOFTBUS_OK);
1323
1324 SoftbusBleGattTest::g_adapterBcld = -1;
1325 SoftbusBleGattTest::g_status = -1;
1326 int32_t advld = -1;
1327 int32_t invalidBtAdvId = -1;
1328 MockBluetooth::btGattCallback->advUpdateCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1329 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1330
1331 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1332 EXPECT_EQ(ret, SOFTBUS_OK);
1333 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1334
1335 SoftbusBroadcastParam params = {};
1336 SoftbusBroadcastData data = BuildBcData();
1337 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1338 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1339 EXPECT_EQ(ret, SOFTBUS_OK);
1340
1341 MockBluetooth::btGattCallback->advUpdateCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1342 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1343
1344 MockBluetooth::interface->StopBroadcasting(advld);
1345 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1346 ret = MockBluetooth::interface->DeInit();
1347 EXPECT_EQ(ret, SOFTBUS_OK);
1348 }
1349
1350 /**
1351 * @tc.name: WrapperAdvUpdateDataCb002
1352 * @tc.desc: WrapperAdvUpdateDataCb will keep traverse when advCallback.OnUpdateBroadcastingCallback=nullptr
1353 * @tc.type: FUNC
1354 * @tc.require: NONE
1355 */
1356 HWTEST_F(SoftbusBleGattTest, WrapperAdvUpdateDataCb002, TestSize.Level1)
1357 {
1358 DISC_LOGI(DISC_TEST, "WrapperAdvUpdateDataCb002 enter");
1359 MockBluetooth mock;
1360 ASSERT_NE(MockBluetooth::interface, nullptr);
1361 int32_t ret = MockBluetooth::interface->Init();
1362 EXPECT_EQ(ret, SOFTBUS_OK);
1363
1364 SoftbusBleGattTest::g_adapterBcld = -1;
1365 SoftbusBleGattTest::g_status = -1;
1366 int32_t advld = -1;
1367 g_softbusBcBleCbTest.OnUpdateBroadcastingCallback = nullptr;
1368 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1369 EXPECT_EQ(ret, SOFTBUS_OK);
1370 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1371
1372 SoftbusBroadcastParam params = {};
1373 SoftbusBroadcastData data = BuildBcData();
1374 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1375 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1376 EXPECT_EQ(ret, SOFTBUS_OK);
1377 MockBluetooth::btGattCallback->advUpdateCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1378 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1379
1380 MockBluetooth::interface->StopBroadcasting(advld);
1381 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1382
1383 g_softbusBcBleCbTest.OnUpdateBroadcastingCallback = FakeBcBleCallback;
1384 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1385 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1386 EXPECT_EQ(ret, SOFTBUS_OK);
1387 MockBluetooth::btGattCallback->advUpdateCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1388 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1389
1390 MockBluetooth::interface->StopBroadcasting(advld);
1391 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1392 ret = MockBluetooth::interface->DeInit();
1393 EXPECT_EQ(ret, SOFTBUS_OK);
1394 }
1395
1396 /**
1397 * @tc.name: WrapperAdvUpdateParamCb001
1398 * @tc.desc: WrapperAdvUpdateParamCb will keep traverse when not regist, will keep traverse when btAdvId is invalid
1399 * @tc.type: FUNC
1400 * @tc.require: NONE
1401 */
1402 HWTEST_F(SoftbusBleGattTest, WrapperAdvUpdateParamCb001, TestSize.Level1)
1403 {
1404 DISC_LOGI(DISC_TEST, "WrapperAdvUpdateParamCb001 enter");
1405 MockBluetooth mock;
1406 ASSERT_NE(MockBluetooth::interface, nullptr);
1407 int32_t ret = MockBluetooth::interface->Init();
1408 EXPECT_EQ(ret, SOFTBUS_OK);
1409
1410 SoftbusBleGattTest::g_adapterBcld = -1;
1411 SoftbusBleGattTest::g_status = -1;
1412 int32_t advld = -1;
1413 int32_t invalidBtAdvId = -1;
1414 MockBluetooth::btGattCallback->advChangeCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1415 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1416
1417 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1418 EXPECT_EQ(ret, SOFTBUS_OK);
1419 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1420
1421 SoftbusBroadcastParam params = {};
1422 SoftbusBroadcastData data = BuildBcData();
1423 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1424 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1425 EXPECT_EQ(ret, SOFTBUS_OK);
1426 MockBluetooth::btGattCallback->advChangeCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1427 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1428
1429 MockBluetooth::interface->StopBroadcasting(advld);
1430 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1431 ret = MockBluetooth::interface->DeInit();
1432 EXPECT_EQ(ret, SOFTBUS_OK);
1433 }
1434
1435 /**
1436 * @tc.name: WrapperAdvUpdateParamCb002
1437 * @tc.desc: WrapperAdvUpdateParamCb will keep traverse when advCallback.OnSetBroadcastingParamCallback=nullptr
1438 * @tc.type: FUNC
1439 * @tc.require: NONE
1440 */
1441 HWTEST_F(SoftbusBleGattTest, WrapperAdvUpdateParamCb002, TestSize.Level1)
1442 {
1443 DISC_LOGI(DISC_TEST, "WrapperAdvUpdateParamCb002 enter");
1444 MockBluetooth mock;
1445 ASSERT_NE(MockBluetooth::interface, nullptr);
1446 int32_t ret = MockBluetooth::interface->Init();
1447 EXPECT_EQ(ret, SOFTBUS_OK);
1448
1449 SoftbusBleGattTest::g_adapterBcld = -1;
1450 SoftbusBleGattTest::g_status = -1;
1451 int32_t advld = -1;
1452 g_softbusBcBleCbTest.OnSetBroadcastingParamCallback = nullptr;
1453 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1454 EXPECT_EQ(ret, SOFTBUS_OK);
1455 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1456
1457 SoftbusBroadcastParam params = {};
1458 SoftbusBroadcastData data = BuildBcData();
1459 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1460 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1461 EXPECT_EQ(ret, SOFTBUS_OK);
1462 MockBluetooth::btGattCallback->advChangeCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1463 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1464
1465 MockBluetooth::interface->StopBroadcasting(advld);
1466 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1467
1468 g_softbusBcBleCbTest.OnSetBroadcastingParamCallback = FakeBcBleCallback;
1469 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1470 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1471 EXPECT_EQ(ret, SOFTBUS_OK);
1472
1473 MockBluetooth::btGattCallback->advChangeCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1474 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1475
1476 MockBluetooth::interface->StopBroadcasting(advld);
1477 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1478 ret = MockBluetooth::interface->DeInit();
1479 EXPECT_EQ(ret, SOFTBUS_OK);
1480 }
1481
1482 /**
1483 * @tc.name: WrapperOnAdvEnableExCb001
1484 * @tc.desc: WrapperOnAdvEnableExCb will keep traverse when not regist, will keep traverse when btAdvId is invalid
1485 * @tc.type: FUNC
1486 * @tc.require: NONE
1487 */
1488 HWTEST_F(SoftbusBleGattTest, WrapperOnAdvEnableExCb001, TestSize.Level1)
1489 {
1490 DISC_LOGI(DISC_TEST, "WrapperOnAdvEnableExCb001 enter");
1491 MockBluetooth mock;
1492 ASSERT_NE(MockBluetooth::interface, nullptr);
1493 int32_t ret = MockBluetooth::interface->Init();
1494 EXPECT_EQ(ret, SOFTBUS_OK);
1495
1496 SoftbusBleGattTest::g_adapterBcld = -1;
1497 SoftbusBleGattTest::g_status = -1;
1498 int32_t advld = -1;
1499 int32_t invalidBtAdvId = -1;
1500 MockBluetooth::btGattCallback->onEnableExCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1501 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1502 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1503 EXPECT_EQ(ret, SOFTBUS_OK);
1504 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1505
1506 SoftbusBroadcastParam params = {};
1507 SoftbusBroadcastData data = BuildBcData();
1508 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1509 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1510 EXPECT_EQ(ret, SOFTBUS_OK);
1511 MockBluetooth::btGattCallback->onEnableExCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1512 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1513
1514 MockBluetooth::interface->StopBroadcasting(advld);
1515 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1516 ret = MockBluetooth::interface->DeInit();
1517 EXPECT_EQ(ret, SOFTBUS_OK);
1518 }
1519
1520 /**
1521 * @tc.name: WrapperOnAdvEnableExCb002
1522 * @tc.desc: WrapperOnAdvEnableExCb will keep traverse when advCallback.OnSetBroadcastingParamCallback=nullptr
1523 * @tc.type: FUNC
1524 * @tc.require: NONE
1525 */
1526 HWTEST_F(SoftbusBleGattTest, WrapperOnAdvEnableExCb002, TestSize.Level1)
1527 {
1528 DISC_LOGI(DISC_TEST, "WrapperOnAdvEnableExCb002 enter");
1529 MockBluetooth mock;
1530 ASSERT_NE(MockBluetooth::interface, nullptr);
1531 int32_t ret = MockBluetooth::interface->Init();
1532 EXPECT_EQ(ret, SOFTBUS_OK);
1533
1534 SoftbusBleGattTest::g_adapterBcld = -1;
1535 SoftbusBleGattTest::g_status = -1;
1536 int32_t advld = -1;
1537 g_softbusBcBleCbTest.OnEnableBroadcastingCallback = nullptr;
1538 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1539 EXPECT_EQ(ret, SOFTBUS_OK);
1540 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1541
1542 SoftbusBroadcastParam params = {};
1543 SoftbusBroadcastData data = BuildBcData();
1544 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1545 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1546 EXPECT_EQ(ret, SOFTBUS_OK);
1547 MockBluetooth::btGattCallback->onEnableExCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1548 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1549
1550 MockBluetooth::interface->StopBroadcasting(advld);
1551 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1552
1553 g_softbusBcBleCbTest.OnEnableBroadcastingCallback = FakeBcBleCallback;
1554 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1555 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1556 EXPECT_EQ(ret, SOFTBUS_OK);
1557 MockBluetooth::btGattCallback->onEnableExCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1558 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1559
1560 MockBluetooth::interface->StopBroadcasting(advld);
1561 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1562 ret = MockBluetooth::interface->DeInit();
1563 EXPECT_EQ(ret, SOFTBUS_OK);
1564 }
1565
1566 /**
1567 * @tc.name: WrapperOnAdvDisableExCb001
1568 * @tc.desc: WrapperOnAdvDisableExCb will keep traverse when not regist, will keep traverse when btAdvId is invalid
1569 * @tc.type: FUNC
1570 * @tc.require: NONE
1571 */
1572 HWTEST_F(SoftbusBleGattTest, WrapperOnAdvDisableExCb001, TestSize.Level1)
1573 {
1574 DISC_LOGI(DISC_TEST, "WrapperOnAdvDisableExCb001 enter");
1575 MockBluetooth mock;
1576 ASSERT_NE(MockBluetooth::interface, nullptr);
1577 int32_t ret = MockBluetooth::interface->Init();
1578 EXPECT_EQ(ret, SOFTBUS_OK);
1579
1580 SoftbusBleGattTest::g_adapterBcld = -1;
1581 SoftbusBleGattTest::g_status = -1;
1582 int32_t advld = -1;
1583 int32_t invalidBtAdvId = -1;
1584 MockBluetooth::btGattCallback->onDisableExCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1585 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1586 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1587 EXPECT_EQ(ret, SOFTBUS_OK);
1588 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1589
1590 SoftbusBroadcastParam params = {};
1591 SoftbusBroadcastData data = BuildBcData();
1592 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1593 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1594 EXPECT_EQ(ret, SOFTBUS_OK);
1595 MockBluetooth::btGattCallback->onDisableExCb(invalidBtAdvId, OHOS_BT_STATUS_SUCCESS);
1596 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1597
1598 MockBluetooth::interface->StopBroadcasting(advld);
1599 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1600 ret = MockBluetooth::interface->DeInit();
1601 EXPECT_EQ(ret, SOFTBUS_OK);
1602 }
1603
1604 /**
1605 * @tc.name: WrapperOnAdvDisableExCb002
1606 * @tc.desc: WrapperOnAdvDisableExCb will keep traverse when advCallback.OnDisableBroadcastingCallback=nullptr
1607 * @tc.type: FUNC
1608 * @tc.require: NONE
1609 */
1610 HWTEST_F(SoftbusBleGattTest, WrapperOnAdvDisableExCb002, TestSize.Level1)
1611 {
1612 DISC_LOGI(DISC_TEST, "WrapperOnAdvDisableExCb002 enter");
1613 MockBluetooth mock;
1614 ASSERT_NE(MockBluetooth::interface, nullptr);
1615 int32_t ret = MockBluetooth::interface->Init();
1616 EXPECT_EQ(ret, SOFTBUS_OK);
1617
1618 SoftbusBleGattTest::g_adapterBcld = -1;
1619 SoftbusBleGattTest::g_status = -1;
1620 int32_t advld = -1;
1621 g_softbusBcBleCbTest.OnDisableBroadcastingCallback = nullptr;
1622 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1623 EXPECT_EQ(ret, SOFTBUS_OK);
1624 DISC_LOGI(DISC_TEST, "advld = %{public}d", advld);
1625
1626 SoftbusBroadcastParam params = {};
1627 SoftbusBroadcastData data = BuildBcData();
1628 EXPECT_CALL(mock, BleStartAdvEx).WillRepeatedly(MockBluetooth::ActionBleStartAdvEx);
1629 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1630 EXPECT_EQ(ret, SOFTBUS_OK);
1631 MockBluetooth::btGattCallback->onDisableExCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1632 EXPECT_FALSE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1633
1634 MockBluetooth::interface->StopBroadcasting(advld);
1635 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1636
1637 g_softbusBcBleCbTest.OnDisableBroadcastingCallback = FakeBcBleCallback;
1638 MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1639 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
1640 EXPECT_EQ(ret, SOFTBUS_OK);
1641 MockBluetooth::btGattCallback->onDisableExCb(MockBluetooth::g_btAdvId, OHOS_BT_STATUS_SUCCESS);
1642 EXPECT_TRUE(SoftbusBleGattTest::g_adapterBcld == advld && SoftbusBleGattTest::g_status == OHOS_BT_STATUS_SUCCESS);
1643
1644 MockBluetooth::interface->StopBroadcasting(advld);
1645 MockBluetooth::interface->UnRegisterBroadcaster(advld);
1646 ret = MockBluetooth::interface->DeInit();
1647 EXPECT_EQ(ret, SOFTBUS_OK);
1648 }
1649
1650 /**
1651 * @tc.name: WrapperScanStateChangeCb0001
1652 * @tc.desc: Test WrapperScanStateChangeCb
1653 * @tc.type: FUNC
1654 * @tc.require: NONE
1655 */
1656 HWTEST_F(SoftbusBleGattTest, WrapperScanStateChangeCb0001, TestSize.Level1)
1657 {
1658 DISC_LOGI(DISC_TEST, "WrapperScanStateChangeCb enter");
1659 MockBluetooth mocker;
1660 int32_t ret = MockBluetooth::interface->Init();
1661 EXPECT_EQ(ret, SOFTBUS_OK);
1662
1663 int32_t scannerld = 0;
1664
1665 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
1666 EXPECT_EQ(ret, SOFTBUS_OK);
1667
1668 MockBluetooth::bleScanCallback->scanStateChangeCb(scannerld, true);
1669 MockBluetooth::bleScanCallback->scanStateChangeCb(scannerld, false);
1670
1671 ret = MockBluetooth::interface->DeInit();
1672 EXPECT_EQ(ret, SOFTBUS_OK);
1673 }
1674
1675 /**
1676 * @tc.name: WrapperLpDeviceInfoCb001
1677 * @tc.desc: Test WrapperLpDeviceInfoCb
1678 * @tc.type: FUNC
1679 * @tc.require: NONE
1680 */
1681 HWTEST_F(SoftbusBleGattTest, WrapperLpDeviceInfoCb001, TestSize.Level1)
1682 {
1683 DISC_LOGI(DISC_TEST, "WrapperLpDeviceInfoCb enter");
1684 MockBluetooth mocker;
1685 int32_t ret = MockBluetooth::interface->Init();
1686 EXPECT_EQ(ret, SOFTBUS_OK);
1687
1688 int32_t scannerld = 0;
1689 BtUuid uuid = {};
1690 int32_t type = 0;
1691 uint8_t data = 0;
1692 uint32_t dataSize = 0;
1693
1694 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
1695 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_REGISTER_FAIL);
1696
1697 MockBluetooth::bleScanCallback->lpDeviceInfoCb(&uuid, type, &data, dataSize);
1698
1699 ret = MockBluetooth::interface->DeInit();
1700 EXPECT_EQ(ret, SOFTBUS_OK);
1701 }
1702
1703 /**
1704 * @tc.name: IsLpAvailable001
1705 * @tc.desc: Test IsLpAvailable
1706 * @tc.type: FUNC
1707 * @tc.require: NONE
1708 */
1709 HWTEST_F(SoftbusBleGattTest, IsLpAvailable001, TestSize.Level1)
1710 {
1711 MockBluetooth mocker;
1712 int32_t ret = MockBluetooth::interface->Init();
1713 EXPECT_EQ(ret, SOFTBUS_OK);
1714
1715 ret = MockBluetooth::interface->IsLpDeviceAvailable();
1716 EXPECT_EQ(ret, true);
1717
1718 ret = MockBluetooth::interface->DeInit();
1719 EXPECT_EQ(ret, SOFTBUS_OK);
1720 }
1721
1722 /**
1723 * @tc.name: SoftbusSetLpParam001
1724 * @tc.desc: Test SoftbusSetLpParam
1725 * @tc.type: FUNC
1726 * @tc.require: NONE
1727 */
1728 HWTEST_F(SoftbusBleGattTest, SoftbusSetLpParam001, TestSize.Level1)
1729 {
1730 MockBluetooth mocker;
1731 int32_t ret = MockBluetooth::interface->Init();
1732 EXPECT_EQ(ret, SOFTBUS_OK);
1733
1734 SoftBusLpBroadcastParam bcParam = {};
1735 SoftBusLpScanParam scanParam = {};
1736
1737 ret = MockBluetooth::interface->SetAdvFilterParam(SOFTBUS_BURST_TYPE, &bcParam, &scanParam);
1738 EXPECT_EQ(ret, false);
1739
1740 ret = MockBluetooth::interface->DeInit();
1741 EXPECT_EQ(ret, SOFTBUS_OK);
1742 }
1743
1744 /**
1745 * @tc.name: SoftbusSetLpParam002
1746 * @tc.desc: Test SoftbusSetLpParam when SetBtUuidByBroadCastType return error
1747 * @tc.type: FUNC
1748 * @tc.require: NONE
1749 */
1750 HWTEST_F(SoftbusBleGattTest, SoftbusSetLpParam002, TestSize.Level1)
1751 {
1752 MockBluetooth mocker;
1753 int32_t ret = MockBluetooth::interface->Init();
1754 EXPECT_EQ(ret, SOFTBUS_OK);
1755
1756 SoftBusLpBroadcastParam bcParam = {};
1757 SoftBusLpScanParam scanParam = {};
1758 scanParam.filterSize = 1;
1759
1760 ret = MockBluetooth::interface->SetAdvFilterParam(SOFTBUS_UNKNOW_TYPE, &bcParam, &scanParam);
1761 EXPECT_EQ(ret, false);
1762
1763 ret = MockBluetooth::interface->DeInit();
1764 EXPECT_EQ(ret, SOFTBUS_OK);
1765 }
1766
1767 /**
1768 * @tc.name: RegisterScanListener001
1769 * @tc.desc: test register scan listener
1770 * @tc.type: FUNC
1771 * @tc.require: NONE
1772 */
1773 HWTEST_F(SoftbusBleGattTest, RegisterScanListener001, TestSize.Level3)
1774 {
1775 MockBluetooth mocker;
1776 int32_t scannerId = -1;
1777 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, nullptr), SOFTBUS_INVALID_PARAM);
1778 int32_t scanListerIds[GATT_SCAN_MAX_NUM] = {};
1779 int32_t ret = SOFTBUS_ERR;
1780 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
1781 ret = MockBluetooth::interface->RegisterScanListener(&scanListerIds[i], GetStubScanListener());
1782 ASSERT_EQ(ret, SOFTBUS_LOCK_ERR);
1783 }
1784
1785 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, GetStubScanListener()), SOFTBUS_LOCK_ERR);
1786
1787 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
1788 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scanListerIds[i]), SOFTBUS_LOCK_ERR);
1789 }
1790 }
1791
1792 /**
1793 * @tc.name: UnRegisterScanListener001
1794 * @tc.desc: test unregister scan listener
1795 * @tc.type: FUNC
1796 * @tc.require: NONE
1797 */
1798 HWTEST_F(SoftbusBleGattTest, UnRegisterScanListener001, TestSize.Level3)
1799 {
1800 MockBluetooth mocker;
1801 int32_t scannerId = -1;
1802 auto result = PrepareScanListener(&scannerId);
1803
1804 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(-1), SOFTBUS_INVALID_PARAM);
1805 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(GATT_SCAN_MAX_NUM), SOFTBUS_INVALID_PARAM);
1806 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_INVALID_PARAM);
1807 }
1808
1809 /**
1810 * @tc.name: ScanLifecycle001
1811 * @tc.desc: test complete scan life cycle
1812 * @tc.type: FUNC
1813 * @tc.require: NONE
1814 */
1815 HWTEST_F(SoftbusBleGattTest, ScanLifecycle001, TestSize.Level3)
1816 {
1817 MockBluetooth mocker;
1818 int32_t scannerId = -1;
1819 auto result = PrepareScanListener(&scannerId);
1820
1821 auto filter = CreateScanFilter();
1822 ASSERT_NE(filter, nullptr);
1823
1824 SoftBusBcScanParams scanParam = {
1825 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
1826 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
1827 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
1828 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
1829 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
1830 };
1831
1832 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1833 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_LOCK_ERR);
1834
1835 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1836 ASSERT_EQ(MockBluetooth::interface->StopScan(scannerId), SOFTBUS_LOCK_ERR);
1837
1838 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_INVALID_PARAM);
1839 }
1840
1841 /**
1842 * @tc.name: ScanResultCb001
1843 * @tc.desc: test scan result callback
1844 * @tc.type: FUNC
1845 * @tc.require: NONE
1846 */
1847 HWTEST_F(SoftbusBleGattTest, ScanResultCb001, TestSize.Level3)
1848 {
1849 MockBluetooth mocker;
1850 int32_t scannerId = -1;
1851 auto result = PrepareScanListener(&scannerId);
1852
1853 auto filter = CreateScanFilter();
1854 ASSERT_NE(filter, nullptr);
1855
1856 SoftBusBcScanParams scanParam = {
1857 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
1858 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
1859 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
1860 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
1861 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
1862 };
1863
1864 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1865 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, nullptr, filter, 1), SOFTBUS_INVALID_PARAM);
1866 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, nullptr, 1), SOFTBUS_INVALID_PARAM);
1867 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 0), SOFTBUS_INVALID_PARAM);
1868 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_LOCK_ERR);
1869
1870 const unsigned char scanDataExample[] = { 0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00,
1871 0x04, 0x00, 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF, 0x03, 0xFF,
1872 0x7D, 0x02 };
1873 SoftBusBcScanResult expectScanResult = { 0 };
1874 expectScanResult.data.bcData.payloadLen = sizeof(scanDataExample);
1875 expectScanResult.data.bcData.payload = (unsigned char *)scanDataExample;
1876 BtScanResultData mockScanResult = { 0 };
1877 mockScanResult.advLen = sizeof(scanDataExample);
1878 mockScanResult.advData = (unsigned char *)scanDataExample;
1879
1880 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
1881 mockScanResult.dataStatus = OHOS_BLE_DATA_COMPLETE;
1882 mockScanResult.addrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
1883 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
1884 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
1885 mockScanResult.directAddrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
1886 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
1887
1888 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
1889 mockScanResult.dataStatus = OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
1890 mockScanResult.addrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
1891 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_1M;
1892 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_1M;
1893 mockScanResult.directAddrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
1894 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
1895 }
1896
1897 /**
1898 * @tc.name: RegisterBroadcaster001
1899 * @tc.desc: test register adv callback
1900 * @tc.type: FUNC
1901 * @tc.require: NONE
1902 */
1903 HWTEST_F(SoftbusBleGattTest, RegisterBroadcaster001, TestSize.Level3)
1904 {
1905 int32_t advId = -1;
1906 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, nullptr), SOFTBUS_INVALID_PARAM);
1907 int32_t advIds[GATT_ADV_MAX_NUM];
1908 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
1909 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advIds[i], GetStubAdvCallback()), SOFTBUS_LOCK_ERR);
1910 }
1911 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, GetStubAdvCallback()), SOFTBUS_LOCK_ERR);
1912 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
1913 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(advIds[i]), SOFTBUS_LOCK_ERR);
1914 }
1915 }
1916
ScanResultCtx(const char * identifier)1917 ScanResultCtx::ScanResultCtx(const char *identifier) : RecordCtx(identifier)
1918 {
1919 Reset();
1920 }
~ScanResultCtx()1921 ScanResultCtx::~ScanResultCtx()
1922 {
1923 Reset();
1924 }
1925
Reset()1926 void ScanResultCtx::Reset()
1927 {
1928 SoftBusFree(scanResult.data.bcData.payload);
1929 SoftBusFree(scanResult.data.rspData.payload);
1930 scanResult.data.bcData.payload = nullptr;
1931 scanResult.data.rspData.payload = nullptr;
1932 }
1933
Update(int32_t id,const SoftBusBcScanResult * scanResult)1934 bool ScanResultCtx::Update(int32_t id, const SoftBusBcScanResult *scanResult)
1935 {
1936 if (!RecordCtx::Update(id)) {
1937 return false;
1938 }
1939 this->scanResult = *scanResult;
1940 unsigned char *cpyAdvData = static_cast<unsigned char *>(SoftBusCalloc(this->scanResult.data.bcData.payloadLen));
1941 if (cpyAdvData == nullptr) {
1942 DISC_LOGE(DISC_TEST, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
1943 return false;
1944 }
1945
1946 if (memcpy_s(cpyAdvData, this->scanResult.data.bcData.payloadLen, scanResult->data.bcData.payload,
1947 scanResult->data.bcData.payloadLen) != EOK) {
1948 DISC_LOGE(DISC_TEST, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
1949 SoftBusFree(cpyAdvData);
1950 return false;
1951 }
1952 this->scanResult.data.bcData.payload = cpyAdvData;
1953 return true;
1954 }
1955
Expect(int32_t id,const SoftBusBcScanResult * scanResultParam)1956 testing::AssertionResult ScanResultCtx::Expect(int32_t id, const SoftBusBcScanResult *scanResultParam)
1957 {
1958 auto result = RecordCtx::Expect(id);
1959 if (!result) {
1960 goto ClEANUP;
1961 }
1962
1963 if (this->scanResult.data.bcData.payloadLen == scanResultParam->data.bcData.payloadLen &&
1964 memcmp(this->scanResult.data.bcData.payload, scanResultParam->data.bcData.payload,
1965 scanResultParam->data.bcData.payloadLen) == 0) {
1966 result = testing::AssertionSuccess();
1967 goto ClEANUP;
1968 }
1969 result = testing::AssertionFailure() << identifier << " is call by unexpectedly scan result.";
1970 ClEANUP:
1971 Reset();
1972 return result;
1973 }
1974
1975 /**
1976 * @tc.name: SoftbusSetAdvParamterTest001
1977 * @tc.desc: Test SoftbusSetAdvParamter when param == NULL
1978 * @tc.type: FUNC
1979 * @tc.require: NONE
1980 */
1981 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest001, TestSize.Level1)
1982 {
1983 int32_t advId = 0;
1984 int32_t ret = MockBluetooth::interface->SetBroadcastingParam(advId, nullptr);
1985 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1986 }
1987
1988 /**
1989 * @tc.name: SoftbusSetAdvParamterTest002
1990 * @tc.desc: Test SoftbusSetAdvParamter when CheckAdvChanInUsed return false
1991 * @tc.type: FUNC
1992 * @tc.require: NONE
1993 */
1994 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest002, TestSize.Level1)
1995 {
1996 int32_t advId = GATT_ADV_MAX_NUM;
1997 SoftbusBroadcastParam params = {};
1998 MockBluetooth mocker;
1999 int32_t ret = MockBluetooth::interface->Init();
2000 EXPECT_EQ(ret, SOFTBUS_OK);
2001
2002 ret = MockBluetooth::interface->SetBroadcastingParam(advId, ¶ms);
2003 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
2004
2005 ret = MockBluetooth::interface->DeInit();
2006 EXPECT_EQ(ret, SOFTBUS_OK);
2007 }
2008
2009 /**
2010 * @tc.name: SoftbusSetAdvParamterTest003
2011 * @tc.desc: Test SoftbusSetAdvParamter when isAdvertising is false
2012 * @tc.type: FUNC
2013 * @tc.require: NONE
2014 */
2015 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest003, TestSize.Level1)
2016 {
2017 MockBluetooth mocker;
2018 int32_t ret = MockBluetooth::interface->Init();
2019 EXPECT_EQ(ret, SOFTBUS_OK);
2020
2021 int32_t advId = 0;
2022 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
2023 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
2024 EXPECT_EQ(ret, SOFTBUS_OK);
2025
2026 SoftbusBroadcastParam params = {};
2027
2028 ret = MockBluetooth::interface->SetBroadcastingParam(advId, ¶ms);
2029 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
2030
2031 ret = MockBluetooth::interface->DeInit();
2032 EXPECT_EQ(ret, SOFTBUS_OK);
2033 }
2034
2035 /**
2036 * @tc.name: SoftbusEnableBroadcasting001
2037 * @tc.desc: Test SoftbusEnableBroadcasting when CheckAdvChanInUsed return false
2038 * @tc.type: FUNC
2039 * @tc.require: NONE
2040 */
2041 HWTEST_F(SoftbusBleGattTest, SoftbusEnableBroadcasting001, TestSize.Level1)
2042 {
2043 int32_t advId = GATT_ADV_MAX_NUM;
2044 MockBluetooth mocker;
2045 int32_t ret = MockBluetooth::interface->Init();
2046 EXPECT_EQ(ret, SOFTBUS_OK);
2047
2048 ret = MockBluetooth::interface->EnableBroadcasting(advId);
2049 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
2050
2051 ret = MockBluetooth::interface->DeInit();
2052 EXPECT_EQ(ret, SOFTBUS_OK);
2053 }
2054
2055 /**
2056 * @tc.name: SoftbusEnableBroadcastingTest002
2057 * @tc.desc: Test SoftbusEnableBroadcasting when isAdvertising is false
2058 * @tc.type: FUNC
2059 * @tc.require: NONE
2060 */
2061 HWTEST_F(SoftbusBleGattTest, SoftbusEnableBroadcastingTest002, TestSize.Level1)
2062 {
2063 MockBluetooth mocker;
2064 int32_t ret = MockBluetooth::interface->Init();
2065 EXPECT_EQ(ret, SOFTBUS_OK);
2066
2067 int32_t advId = 0;
2068 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
2069 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
2070 EXPECT_EQ(ret, SOFTBUS_OK);
2071
2072 ret = MockBluetooth::interface->EnableBroadcasting(advId);
2073 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
2074
2075 ret = MockBluetooth::interface->DeInit();
2076 EXPECT_EQ(ret, SOFTBUS_OK);
2077 }
2078
2079 /**
2080 * @tc.name: SoftbusDisableBroadcasting001
2081 * @tc.desc: Test SoftbusDisableBroadcasting when CheckAdvChanInUsed return false
2082 * @tc.type: FUNC
2083 * @tc.require: NONE
2084 */
2085 HWTEST_F(SoftbusBleGattTest, SoftbusDisableBroadcasting001, TestSize.Level1)
2086 {
2087 int32_t advId = GATT_ADV_MAX_NUM;
2088 MockBluetooth mocker;
2089 int32_t ret = MockBluetooth::interface->Init();
2090 EXPECT_EQ(ret, SOFTBUS_OK);
2091
2092 ret = MockBluetooth::interface->DisableBroadcasting(advId);
2093 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
2094
2095 ret = MockBluetooth::interface->DeInit();
2096 EXPECT_EQ(ret, SOFTBUS_OK);
2097 }
2098
2099 /**
2100 * @tc.name: SoftbusDisableBroadcastingTest002
2101 * @tc.desc: Test SoftbusDisableBroadcasting when isAdvertising is false
2102 * @tc.type: FUNC
2103 * @tc.require: NONE
2104 */
2105 HWTEST_F(SoftbusBleGattTest, SoftbusDisableBroadcastingTest002, TestSize.Level1)
2106 {
2107 MockBluetooth mocker;
2108 int32_t ret = MockBluetooth::interface->Init();
2109 EXPECT_EQ(ret, SOFTBUS_OK);
2110
2111 int32_t advId = 0;
2112 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
2113 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
2114 EXPECT_EQ(ret, SOFTBUS_OK);
2115
2116 ret = MockBluetooth::interface->DisableBroadcasting(advId);
2117 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
2118
2119 ret = MockBluetooth::interface->DeInit();
2120 EXPECT_EQ(ret, SOFTBUS_OK);
2121 }
2122
2123 /**
2124 * @tc.name: SoftbusSetScanParamsTest001
2125 * @tc.desc: Test SoftbusSetScanParams when param is nullptr
2126 * @tc.type: FUNC
2127 * @tc.require: NONE
2128 */
2129 HWTEST_F(SoftbusBleGattTest, SoftbusSetScanParamsTest001, TestSize.Level1)
2130 {
2131 int32_t scannerId = 0;
2132 SoftBusBcScanFilter scanFilter = {};
2133 int32_t filterSize = 0;
2134 SoftbusSetFilterCmd cmdId = {};
2135 int32_t ret = MockBluetooth::interface->SetScanParams(scannerId, nullptr, &scanFilter, filterSize, cmdId);
2136 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2137 }
2138 } // namespace OHOS