1 /*
2 * Copyright (c) 2022 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 "gmock/gmock.h"
17 #include "gtest/gtest.h"
18
19 #include "c_header/ohos_bt_gatt.h"
20 #include "softbus_adapter_ble_gatt.h"
21 #include "softbus_errcode.h"
22 #include "softbus_log.h"
23
24 #include "assert_helper.h"
25 #include "bluetooth_mock.h"
26
27 using namespace testing::ext;
28 using ::testing::AtMost;
29 using ::testing::Return;
30
31 namespace OHOS {
32
33 class ScanResultCtx : public RecordCtx {
34 public:
35 explicit ScanResultCtx(const char *identifier);
36 ~ScanResultCtx();
37 bool Update(int id, const SoftBusBleScanResult *scanResult);
38 testing::AssertionResult Expect(int id, const SoftBusBleScanResult *scanResult);
39 private:
40 SoftBusBleScanResult scanResult;
41 void Reset();
42 };
43
44 class AdapterBleGattTest : public testing::Test {
45 public:
46 static StRecordCtx scanStartCtx;
47 static StRecordCtx scanStopCtx;
48 static ScanResultCtx scanResultCtx;
49
50 static StRecordCtx advEnableCtx;
51 static StRecordCtx advDisableCtx;
52 static StRecordCtx advDataCtx;
53 static StRecordCtx advUpdateCtx;
54 // btInnerAdvId 模拟蓝牙生成的广播id
55 static int btInnerAdvId;
56
57 static void SetUpTestCase(void);
58 };
59
60 StRecordCtx AdapterBleGattTest::scanStartCtx("OnScanStart");
61 StRecordCtx AdapterBleGattTest::scanStopCtx("OnScanStop");
62 ScanResultCtx AdapterBleGattTest::scanResultCtx("OnScanResult");
63
64 StRecordCtx AdapterBleGattTest::advEnableCtx("AdvEnableCallback");
65 StRecordCtx AdapterBleGattTest::advDisableCtx("AdvDisableCallback");
66 StRecordCtx AdapterBleGattTest::advDataCtx("AdvDataCallback");
67 StRecordCtx AdapterBleGattTest::advUpdateCtx("AdvUpdateCallback");
68 int AdapterBleGattTest::btInnerAdvId = -1;
69
SetUpTestCase()70 void AdapterBleGattTest::SetUpTestCase()
71 {
72 BleGattLockInit();
73 }
74
StubOnScanStart(int listenerId,int status)75 static void StubOnScanStart(int listenerId, int status)
76 {
77 AdapterBleGattTest::scanStartCtx.Update(listenerId, status);
78 }
79
StubOnScanStop(int listenerId,int status)80 static void StubOnScanStop(int listenerId, int status)
81 {
82 AdapterBleGattTest::scanStopCtx.Update(listenerId, status);
83 }
84
StubOnScanResult(int listenerId,const SoftBusBleScanResult * scanResultdata)85 static void StubOnScanResult(int listenerId, const SoftBusBleScanResult *scanResultdata)
86 {
87 AdapterBleGattTest::scanResultCtx.Update(listenerId, scanResultdata);
88 }
89
GetStubScanListener()90 SoftBusScanListener *GetStubScanListener()
91 {
92 static SoftBusScanListener listener = {
93 .OnScanStart = StubOnScanStart,
94 .OnScanStop = StubOnScanStop,
95 .OnScanResult = StubOnScanResult,
96 .OnScanStateChanged = NULL
97 };
98 return &listener;
99 }
100
StubAdvEnableCallback(int advId,int status)101 static void StubAdvEnableCallback(int advId, int status)
102 {
103 AdapterBleGattTest::advEnableCtx.Update(advId, status);
104 }
105
StubAdvDisableCallback(int advId,int status)106 static void StubAdvDisableCallback(int advId, int status)
107 {
108 AdapterBleGattTest::advDisableCtx.Update(advId, status);
109 }
110
StubAdvDataCallback(int advId,int status)111 static void StubAdvDataCallback(int advId, int status)
112 {
113 AdapterBleGattTest::advDataCtx.Update(advId, status);
114 }
115
StubAdvUpdateCallback(int advId,int status)116 static void StubAdvUpdateCallback(int advId, int status)
117 {
118 AdapterBleGattTest::advUpdateCtx.Update(advId, status);
119 }
120
121 // Notice：考虑到BleStartAdvEx的回调需要异步触发，实现会导致专注点不在用来本身。这里不手动mock，
122 // ！！！IMPORANT: 一定需要手动触发成功回调，否则回导致adapter状态异常！！！
ActionSuccessBleStartAdvEx(int * advId,const StartAdvRawData rawData,BleAdvParams advParam)123 static int ActionSuccessBleStartAdvEx(int *advId, const StartAdvRawData rawData, BleAdvParams advParam)
124 {
125 static int advIdGenerator = 0;
126 *advId = advIdGenerator++;
127 AdapterBleGattTest::btInnerAdvId = *advId;
128 return OHOS_BT_STATUS_SUCCESS;
129 }
130
ActionSuccessBleStopAdv(int advId)131 static int ActionSuccessBleStopAdv(int advId)
132 {
133 MockBluetooth::btGattCallback->advDisableCb(advId, SOFTBUS_BT_STATUS_SUCCESS);
134 return OHOS_BT_STATUS_SUCCESS;
135 }
136
GetStubAdvCallback()137 SoftBusAdvCallback *GetStubAdvCallback()
138 {
139 static SoftBusAdvCallback callback = {.AdvEnableCallback = StubAdvEnableCallback,
140 .AdvDisableCallback = StubAdvDisableCallback,
141 .AdvDataCallback = StubAdvDataCallback,
142 .AdvUpdateCallback = StubAdvUpdateCallback,
143 .LpDeviceInfoCallback = NULL};
144 return &callback;
145 }
146
PrepareScanListener(MockBluetooth & mocker,int * outId,int * scannerId)147 static testing::AssertionResult PrepareScanListener(MockBluetooth &mocker, int *outId, int *scannerId)
148 {
149 auto id = SoftBusAddScanListener(GetStubScanListener(), scannerId, false);
150 if (id == SOFTBUS_ERR) {
151 return testing::AssertionFailure() << "SoftBusAddScanListener failed";
152 }
153 if (MockBluetooth::btGattCallback == nullptr) {
154 return testing::AssertionFailure() << "BleGattRegisterCallbacks is not invoke";
155 }
156 *outId = id;
157 return testing::AssertionSuccess();
158 }
159
PrepareAdvCallback(MockBluetooth & mocker,int * outId,int * scannerId)160 static testing::AssertionResult PrepareAdvCallback(MockBluetooth &mocker, int *outId, int *scannerId)
161 {
162 EXPECT_CALL(mocker, BleStartAdvEx).WillRepeatedly(ActionSuccessBleStartAdvEx);
163 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(ActionSuccessBleStopAdv);
164 auto id = SoftBusGetAdvChannel(GetStubAdvCallback(), scannerId, false);
165 if (id == SOFTBUS_ERR) {
166 return testing::AssertionFailure() << "GetStubAdvCallback failed";
167 }
168 if (MockBluetooth::btGattCallback == nullptr) {
169 return testing::AssertionFailure() << "BleGattRegisterCallbacks is not invoke";
170 }
171 *outId = id;
172 return testing::AssertionSuccess();
173 }
174
CreateScanFilter()175 static SoftBusBleScanFilter *CreateScanFilter()
176 {
177 unsigned char serviceData[] = {0xE, 0xE, 0xF, 0xF, 0x04, 0x05};
178 int len = sizeof(serviceData);
179
180 SoftBusBleScanFilter *filter = (SoftBusBleScanFilter *)SoftBusCalloc(sizeof(SoftBusBleScanFilter));
181 unsigned char *serviceDataPtr = (unsigned char *)SoftBusCalloc(len);
182 unsigned char *serviceDataMaskPtr = (unsigned char *)SoftBusCalloc(len);
183 if (filter == nullptr || serviceDataPtr == nullptr || serviceDataMaskPtr == nullptr) {
184 goto EXIT;
185 }
186 if (memcpy_s(serviceDataPtr, len, serviceData, len) != EOK) {
187 goto EXIT;
188 }
189 if (memset_s(serviceDataMaskPtr, len, 0xFF, len) != EOK) {
190 goto EXIT;
191 }
192 filter->serviceData = serviceDataPtr;
193 filter->serviceDataMask = serviceDataMaskPtr;
194 filter->serviceDataLength = len;
195 return filter;
196 EXIT:
197 SoftBusFree(filter);
198 SoftBusFree(serviceDataPtr);
199 SoftBusFree(serviceDataMaskPtr);
200 return nullptr;
201 }
202
203 /**
204 * @tc.name: AdapterBleGattTest_SoftBusAddScanListener
205 * @tc.desc: test add scan listener
206 * @tc.type: FUNC
207 * @tc.require: NONE
208 */
209 HWTEST_F(AdapterBleGattTest, SoftBusAddScanListener, TestSize.Level3)
210 {
211 MockBluetooth mocker;
212 int scannerId = -1;
213 ASSERT_EQ(SoftBusAddScanListener(nullptr, &scannerId, false), SOFTBUS_ERR);
214
215 int scanListerIds[SCAN_MAX_NUM];
216 for (size_t i = 0; i < SCAN_MAX_NUM; i++) {
217 scanListerIds[i] = SoftBusAddScanListener(GetStubScanListener(), &scannerId, false);
218 ASSERT_NE(scanListerIds[i], SOFTBUS_ERR);
219 }
220
221 ASSERT_EQ(SoftBusAddScanListener(GetStubScanListener(), &scannerId, false), SOFTBUS_ERR);
222
223 for (size_t i = 0; i < SCAN_MAX_NUM; i++) {
224 ASSERT_EQ(SoftBusRemoveScanListener(scanListerIds[i]), SOFTBUS_OK);
225 }
226 }
227
228 /**
229 * @tc.name: AdapterBleGattTest_SoftBusRemoveScanListener
230 * @tc.desc: test remove scan listener
231 * @tc.type: FUNC
232 * @tc.require: NONE
233 */
234 HWTEST_F(AdapterBleGattTest, SoftBusRemoveScanListener, TestSize.Level3)
235 {
236 MockBluetooth mocker;
237 int listenerId = -1;
238 int scannerId = -1;
239 auto result = PrepareScanListener(mocker, &listenerId, &scannerId);
240 ASSERT_TRUE(result);
241
242 ASSERT_EQ(SoftBusRemoveScanListener(-1), SOFTBUS_INVALID_PARAM);
243 ASSERT_EQ(SoftBusRemoveScanListener(SCAN_MAX_NUM), SOFTBUS_INVALID_PARAM);
244 ASSERT_EQ(SoftBusRemoveScanListener(listenerId), SOFTBUS_OK);
245 }
246
247 /**
248 * @tc.name: AdapterBleGattTest_SoftBusSetScanFilter
249 * @tc.desc: test set scan filter
250 * @tc.type: FUNC
251 * @tc.require: NONE
252 */
253 HWTEST_F(AdapterBleGattTest, SoftBusSetScanFilter, TestSize.Level3)
254 {
255 MockBluetooth mocker;
256 int listenerId = -1;
257 int scannerId = -1;
258 auto result = PrepareScanListener(mocker, &listenerId, &scannerId);
259 ASSERT_TRUE(result);
260
261 auto filter = CreateScanFilter();
262 ASSERT_NE(filter, nullptr);
263
264 ASSERT_EQ(SoftBusSetScanFilter(listenerId, nullptr, 0), SOFTBUS_INVALID_PARAM);
265 ASSERT_EQ(SoftBusSetScanFilter(listenerId, filter, 0), SOFTBUS_INVALID_PARAM);
266
267 // not exist scaner
268 ASSERT_EQ(SoftBusSetScanFilter(SCAN_MAX_NUM - 1, filter, 1), SOFTBUS_ERR);
269 ASSERT_EQ(SoftBusSetScanFilter(listenerId, filter, 1), SOFTBUS_OK);
270 ASSERT_EQ(SoftBusRemoveScanListener(listenerId), SOFTBUS_OK);
271 }
272
273 /**
274 * @tc.name: AdapterBleGattTest_ScanLifecycle
275 * @tc.desc: test complete scan life cycle
276 * @tc.type: FUNC
277 * @tc.require: NONE
278 */
279 HWTEST_F(AdapterBleGattTest, ScanLifecycle, TestSize.Level3)
280 {
281 MockBluetooth mocker;
282 int listenerId = -1;
283 int scannerId = -1;
284 auto result = PrepareScanListener(mocker, &listenerId, &scannerId);
285 ASSERT_TRUE(result);
286
287 auto filter = CreateScanFilter();
288 ASSERT_NE(filter, nullptr);
289 auto ret = SoftBusSetScanFilter(listenerId, filter, 1);
290 ASSERT_EQ(ret, SOFTBUS_OK);
291
292 SoftBusBleScanParams scanParam = {
293 .scanInterval = 60,
294 .scanWindow = 600,
295 .scanType = 1,
296 .scanPhy = 1,
297 .scanFilterPolicy = 0,
298 };
299
300 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
301 ret = SoftBusStartScan(listenerId, scannerId, &scanParam);
302 ASSERT_EQ(ret, SOFTBUS_OK);
303 ASSERT_TRUE(scanStartCtx.Expect(listenerId, SOFTBUS_BT_STATUS_SUCCESS));
304
305 const unsigned char scanDataExample[] = {0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00,
306 0x04, 0x00, 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF, 0x03, 0xFF,
307 0x7D, 0x02};
308 BtScanResultData mockScanResult = {0};
309 mockScanResult.advLen = sizeof(scanDataExample);
310 mockScanResult.advData = (unsigned char *)scanDataExample;
311
312
313 SoftBusBleScanResult expectScanResult = {0};
314 expectScanResult.advLen = sizeof(scanDataExample);
315 expectScanResult.advData = (unsigned char *)scanDataExample;
316 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
317
318 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
319 ret = SoftBusStopScan(listenerId, scannerId);
320 ASSERT_EQ(ret, SOFTBUS_OK);
321 ASSERT_TRUE(scanStopCtx.Expect(listenerId, SOFTBUS_BT_STATUS_SUCCESS));
322
323 ASSERT_EQ(SoftBusRemoveScanListener(listenerId), SOFTBUS_OK);
324 }
325
326 /**
327 * @tc.name: AdapterBleGattTest_ScanResultCb
328 * @tc.desc: test scan result callback
329 * @tc.type: FUNC
330 * @tc.require: NONE
331 */
332 HWTEST_F(AdapterBleGattTest, ScanResultCb, TestSize.Level3)
333 {
334 MockBluetooth mocker;
335 int listenerId = -1;
336 int scannerId = -1;
337 auto result = PrepareScanListener(mocker, &listenerId, &scannerId);
338 ASSERT_TRUE(result);
339
340 auto filter = CreateScanFilter();
341 ASSERT_NE(filter, nullptr);
342 auto ret = SoftBusSetScanFilter(listenerId, filter, 1);
343 ASSERT_EQ(ret, SOFTBUS_OK);
344
345 SoftBusBleScanParams scanParam = {
346 .scanInterval = 60,
347 .scanWindow = 600,
348 .scanType = 1,
349 .scanPhy = 1,
350 .scanFilterPolicy = 0,
351 };
352 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
353 ASSERT_EQ(SoftBusStartScan(listenerId, scannerId, nullptr), SOFTBUS_INVALID_PARAM);
354 ASSERT_EQ(SoftBusStartScan(listenerId, scannerId, &scanParam), SOFTBUS_OK);
355 ASSERT_TRUE(scanStartCtx.Expect(listenerId, SOFTBUS_BT_STATUS_SUCCESS));
356
357 const unsigned char scanDataExample[] = {0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00,
358 0x04, 0x00, 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF, 0x03, 0xFF,
359 0x7D, 0x02};
360 SoftBusBleScanResult expectScanResult = {0};
361 expectScanResult.advLen = sizeof(scanDataExample);
362 expectScanResult.advData = (unsigned char *)scanDataExample;
363 BtScanResultData mockScanResult = {0};
364 mockScanResult.advLen = sizeof(scanDataExample);
365 mockScanResult.advData = (unsigned char *)scanDataExample;
366
367 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
368 mockScanResult.dataStatus = OHOS_BLE_DATA_COMPLETE;
369 mockScanResult.addrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
370 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
371 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
372 mockScanResult.directAddrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
373 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
374
375 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
376 mockScanResult.dataStatus = OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
377 mockScanResult.addrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
378 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_1M;
379 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_1M;
380 mockScanResult.directAddrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
381 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
382
383 mockScanResult.eventType = OHOS_BLE_EVT_CONNECTABLE;
384 mockScanResult.dataStatus = OHOS_BLE_DATA_INCOMPLETE_TRUNCATED;
385 mockScanResult.addrType = OHOS_BLE_PUBLIC_IDENTITY_ADDRESS;
386 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_2M;
387 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_2M;
388 mockScanResult.directAddrType = OHOS_BLE_PUBLIC_IDENTITY_ADDRESS;
389 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
390
391 mockScanResult.eventType = OHOS_BLE_EVT_CONNECTABLE_DIRECTED;
392 mockScanResult.dataStatus = UINT8_MAX;
393 mockScanResult.addrType = OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS;
394 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_CODED;
395 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_CODED;
396 mockScanResult.directAddrType = OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS;
397 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
398
399 mockScanResult.eventType = OHOS_BLE_EVT_SCANNABLE;
400 mockScanResult.addrType = OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
401 mockScanResult.primaryPhy = UINT8_MAX;
402 mockScanResult.secondaryPhy = UINT8_MAX;
403 mockScanResult.directAddrType = OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
404 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
405
406 mockScanResult.eventType = OHOS_BLE_EVT_SCANNABLE_DIRECTED;
407 mockScanResult.addrType = OHOS_BLE_NO_ADDRESS;
408 mockScanResult.directAddrType = OHOS_BLE_NO_ADDRESS;
409 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
410
411 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE;
412 mockScanResult.addrType = UINT8_MAX;
413 mockScanResult.directAddrType = UINT8_MAX;
414 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
415
416 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_SCANNABLE;
417 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
418
419 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_CONNECTABLE;
420 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
421
422 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED;
423 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
424
425 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
426 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
427
428 mockScanResult.eventType = OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV;
429 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
430
431 mockScanResult.eventType = UINT8_MAX;
432 ASSERT_FALSE(scanResultCtx.Expect(listenerId, &expectScanResult));
433 }
434
435 /**
436 * @tc.name: AdapterBleGattTest_AdvertiseLifecycle
437 * @tc.desc: test complete Advertisement life cycle
438 * @tc.type: FUNC
439 * @tc.require: NONE
440 */
441 HWTEST_F(AdapterBleGattTest, AdvertiseLifecycle, TestSize.Level3)
442 {
443 MockBluetooth mocker;
444 int advId = 0;
445 int scannerId = -1;
446 auto result = PrepareAdvCallback(mocker, &advId, &scannerId);
447 ASSERT_TRUE(result);
448
449 const char advDataExample[] = {0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00, 0x04, 0x00,
450 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF};
451 const unsigned char scanRspDataExample[] = {0x03, 0xFF, 0x7D, 0x02};
452 SoftBusBleAdvData data = {.advLength = sizeof(advDataExample),
453 .advData = (char *)advDataExample,
454 .scanRspLength = sizeof(scanRspDataExample),
455 .scanRspData = (char *)scanRspDataExample};
456 ASSERT_EQ(SoftBusSetAdvData(advId, &data), SOFTBUS_OK);
457 ASSERT_TRUE(advDataCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
458
459 SoftBusBleAdvParams params = {0};
460 ASSERT_EQ(SoftBusStartAdv(advId, ¶ms), SOFTBUS_OK);
461 ASSERT_FALSE(advEnableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
462 // 模拟蓝牙广播成功回调, 广播成功会被再次回调, adapter状态才能恢复正常
463 MockBluetooth::btGattCallback->advEnableCb(btInnerAdvId, SOFTBUS_BT_STATUS_SUCCESS);
464 ASSERT_TRUE(advEnableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
465
466 MockBluetooth::btGattCallback->advDataCb(btInnerAdvId, SOFTBUS_BT_STATUS_SUCCESS);
467 ASSERT_TRUE(advDataCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
468
469 ASSERT_EQ(SoftBusUpdateAdv(advId, nullptr, ¶ms), SOFTBUS_INVALID_PARAM);
470 ASSERT_EQ(SoftBusUpdateAdv(advId, &data, nullptr), SOFTBUS_INVALID_PARAM);
471 ASSERT_EQ(SoftBusUpdateAdv(advId, &data, ¶ms), SOFTBUS_OK);
472 ASSERT_FALSE(advEnableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
473 ASSERT_TRUE(advDisableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
474 // 模拟蓝牙广播成功回调, 广播成功会被再次回调, adapter状态才能恢复正常
475 MockBluetooth::btGattCallback->advEnableCb(btInnerAdvId, SOFTBUS_BT_STATUS_SUCCESS);
476 ASSERT_TRUE(advEnableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
477
478 MockBluetooth::btGattCallback->advUpdateCb(btInnerAdvId, SOFTBUS_BT_STATUS_SUCCESS);
479 ASSERT_TRUE(advUpdateCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
480
481 MockBluetooth::btGattCallback->securityRespondCb(nullptr);
482
483 ASSERT_EQ(SoftBusStopAdv(advId), SOFTBUS_OK);
484 ASSERT_TRUE(advDisableCtx.Expect(advId, SOFTBUS_BT_STATUS_SUCCESS));
485
486 ASSERT_EQ(SoftBusReleaseAdvChannel(advId), SOFTBUS_OK);
487 ASSERT_EQ(SoftBusReleaseAdvChannel(advId), SOFTBUS_ERR);
488 ASSERT_EQ(SoftBusReleaseAdvChannel(-1), SOFTBUS_ERR);
489 ASSERT_EQ(SoftBusReleaseAdvChannel(ADV_MAX_NUM), SOFTBUS_ERR);
490 }
491
492 /**
493 * @tc.name: AdapterBleGattTest_SoftBusGetAdvChannel
494 * @tc.desc: test get adv channel
495 * @tc.type: FUNC
496 * @tc.require: NONE
497 */
498 HWTEST_F(AdapterBleGattTest, SoftBusGetAdvChannel, TestSize.Level3)
499 {
500 int scannerId = -1;
501 ASSERT_EQ(SoftBusGetAdvChannel(nullptr, &scannerId, false), SOFTBUS_INVALID_PARAM);
502 MockBluetooth mocker;
503 int advIds[ADV_MAX_NUM];
504 for (size_t i = 0; i < ADV_MAX_NUM; i++) {
505 advIds[i] = SoftBusGetAdvChannel(GetStubAdvCallback(), &scannerId, false);
506 ASSERT_NE(advIds[i], SOFTBUS_ERR);
507 }
508 ASSERT_EQ(SoftBusGetAdvChannel(GetStubAdvCallback(), &scannerId, false), SOFTBUS_ERR);
509 for (size_t i = 0; i < ADV_MAX_NUM; i++) {
510 ASSERT_EQ(SoftBusReleaseAdvChannel(advIds[i]), SOFTBUS_OK);
511 }
512 }
513
ScanResultCtx(const char * identifier)514 ScanResultCtx::ScanResultCtx(const char *identifier) : RecordCtx(identifier)
515 {
516 Reset();
517 }
~ScanResultCtx()518 ScanResultCtx::~ScanResultCtx()
519 {
520 Reset();
521 }
522
Reset()523 void ScanResultCtx::Reset()
524 {
525 SoftBusFree(scanResult.advData);
526 scanResult.advData = nullptr;
527 memset_s(&scanResult, sizeof(SoftBusBtAddr), 0, sizeof(SoftBusBtAddr));
528 }
529
Update(int id,const SoftBusBleScanResult * scanResult)530 bool ScanResultCtx::Update(int id, const SoftBusBleScanResult *scanResult)
531 {
532 if (!RecordCtx::Update(id)) {
533 return false;
534 }
535 this->scanResult = *scanResult;
536 unsigned char *cpyAdvData = (unsigned char *)SoftBusCalloc(this->scanResult.advLen);
537 if (cpyAdvData == nullptr) {
538 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "malloc failed in OnScanResult, can not save ctx, id: %d", id);
539 return false;
540 }
541
542 if (memcpy_s(cpyAdvData, this->scanResult.advLen, scanResult->advData, scanResult->advLen) != EOK) {
543 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc failed in OnScanResult, can not save ctx, id: %d", id);
544 SoftBusFree(cpyAdvData);
545 return false;
546 }
547 this->scanResult.advData = cpyAdvData;
548 return true;
549 }
550
Expect(int id,const SoftBusBleScanResult * scanResultParam)551 testing::AssertionResult ScanResultCtx::Expect(int id, const SoftBusBleScanResult *scanResultParam)
552 {
553 auto result = RecordCtx::Expect(id);
554 if (!result) {
555 goto ClEANUP;
556 }
557
558 if (this->scanResult.advLen == scanResultParam->advLen &&
559 memcmp(this->scanResult.advData, scanResultParam->advData, scanResultParam->advLen) == 0) {
560 result = testing::AssertionSuccess();
561 goto ClEANUP;
562 }
563 result = testing::AssertionFailure() << identifier << " is call by unexpectedly scan result.";
564 ClEANUP:
565 Reset();
566 return result;
567 }
568
569 } // namespace OHOS