1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gmock/gmock.h"
17 #include "gtest/gtest.h"
18
19 #include "softbus_ble_gatt.h"
20 #include "softbus_broadcast_type.h"
21 #include "disc_log.h"
22 #include "c_header/ohos_bt_gatt.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_errcode.h"
25 #include "assert_helper.h"
26 #include "bluetooth_mock.h"
27
28 #define GATT_ADV_MAX_NUM 16
29 #define GATT_SCAN_MAX_NUM 2
30
31 using namespace testing::ext;
32 using ::testing::AtMost;
33 using ::testing::Return;
34
35 namespace OHOS {
36
37 class ScanResultCtx : public RecordCtx {
38 public:
39 explicit ScanResultCtx(const char *identifier);
40 ~ScanResultCtx();
41 bool Update(int32_t scannerId, const SoftBusBcScanResult *reportData);
42 testing::AssertionResult Expect(int32_t scannerId, const SoftBusBcScanResult *reportData);
43 private:
44 SoftBusBcScanResult scanResult;
45 void Reset();
46 };
47
48 class SoftbusBleGattTest : public testing::Test {
49 public:
50 static ScanResultCtx scanResultCtx;
51
52 static StRecordCtx advEnableCtx;
53 static StRecordCtx advDisableCtx;
54 static StRecordCtx advDataCtx;
55 static StRecordCtx advUpdateCtx;
56 static int btInnerAdvId;
57
58 static void SetUpTestCase(void);
59 };
60
61 ScanResultCtx SoftbusBleGattTest::scanResultCtx("OnReportScanDataCallback");
62
63 StRecordCtx SoftbusBleGattTest::advEnableCtx("AdvEnableCallback");
64 StRecordCtx SoftbusBleGattTest::advDisableCtx("AdvDisableCallback");
65 StRecordCtx SoftbusBleGattTest::advDataCtx("AdvDataCallback");
66 StRecordCtx SoftbusBleGattTest::advUpdateCtx("AdvUpdateCallback");
67 int SoftbusBleGattTest::btInnerAdvId = -1;
68
SetUpTestCase()69 void SoftbusBleGattTest::SetUpTestCase()
70 {
71 MockBluetooth mocker;
72 SoftbusBleAdapterInit();
73 MockBluetooth::interface->Init();
74 }
75
StubOnScanResult(int32_t scannerId,const SoftBusBcScanResult * reportData)76 static void StubOnScanResult(int32_t scannerId, const SoftBusBcScanResult *reportData)
77 {
78 SoftbusBleGattTest::scanResultCtx.Update(scannerId, reportData);
79 }
80
GetStubScanListener()81 static SoftbusScanCallback *GetStubScanListener()
82 {
83 static SoftbusScanCallback listener = {
84 .OnStartScanCallback = nullptr,
85 .OnStopScanCallback = nullptr,
86 .OnReportScanDataCallback = StubOnScanResult,
87 .OnScanStateChanged = nullptr
88 };
89 return &listener;
90 }
91
StubAdvEnableCallback(int advId,int status)92 static void StubAdvEnableCallback(int advId, int status)
93 {
94 SoftbusBleGattTest::advEnableCtx.Update(advId, status);
95 }
96
StubAdvDisableCallback(int advId,int status)97 static void StubAdvDisableCallback(int advId, int status)
98 {
99 SoftbusBleGattTest::advDisableCtx.Update(advId, status);
100 }
101
StubAdvUpdateCallback(int advId,int status)102 static void StubAdvUpdateCallback(int advId, int status)
103 {
104 SoftbusBleGattTest::advUpdateCtx.Update(advId, status);
105 }
106
StubAdvDataCallback(int advId,int status)107 static void StubAdvDataCallback(int advId, int status)
108 {
109 SoftbusBleGattTest::advDataCtx.Update(advId, status);
110 }
111
ActionSuccessBleStartAdvEx(int * advId,const StartAdvRawData rawData,BleAdvParams advParam)112 static int ActionSuccessBleStartAdvEx(int *advId, const StartAdvRawData rawData, BleAdvParams advParam)
113 {
114 static int advIdGenerator = 0;
115 *advId = advIdGenerator++;
116 SoftbusBleGattTest::btInnerAdvId = *advId;
117 return OHOS_BT_STATUS_SUCCESS;
118 }
119
ActionSuccessBleStopAdv(int advId)120 static int ActionSuccessBleStopAdv(int advId)
121 {
122 DISC_LOGI(DISC_BLE_ADAPTER, "ActionSuccessBleStopAdv, advId=%{public}d", advId);
123 MockBluetooth::btGattCallback->advDisableCb(advId, OHOS_BT_STATUS_SUCCESS);
124 DISC_LOGI(DISC_BLE_ADAPTER, "ActionSuccessBleStopAdv, advId=%{public}d", advId);
125 return OHOS_BT_STATUS_SUCCESS;
126 }
127
GetStubAdvCallback()128 SoftbusBroadcastCallback *GetStubAdvCallback()
129 {
130 static SoftbusBroadcastCallback callback = {
131 .OnStartBroadcastingCallback = StubAdvEnableCallback,
132 .OnStopBroadcastingCallback = StubAdvDisableCallback,
133 .OnUpdateBroadcastingCallback = StubAdvUpdateCallback,
134 .OnSetBroadcastingCallback = StubAdvDataCallback,
135 };
136 return &callback;
137 }
138
PrepareScanListener(int * scannerId)139 static testing::AssertionResult PrepareScanListener(int *scannerId)
140 {
141 int32_t ret = MockBluetooth::interface->RegisterScanListener(scannerId, GetStubScanListener());
142 if (ret == SOFTBUS_ERR) {
143 return testing::AssertionFailure() << "RegisterScanListener failed";
144 }
145 if (MockBluetooth::bleScanCallback == nullptr) {
146 return testing::AssertionFailure() << "RegisterScanListener is not invoke";
147 }
148 return testing::AssertionSuccess();
149 }
150
PrepareAdvCallback(int * advId)151 static testing::AssertionResult PrepareAdvCallback(int *advId)
152 {
153 auto ret = MockBluetooth::interface->RegisterBroadcaster(advId, GetStubAdvCallback());
154 if (ret == SOFTBUS_ERR) {
155 return testing::AssertionFailure() << "RegisterBroadcaster failed";
156 }
157 if (MockBluetooth::btGattCallback == nullptr) {
158 return testing::AssertionFailure() << "RegisterBroadcaster is not invoke";
159 }
160 return testing::AssertionSuccess();
161 }
162
CreateScanFilter()163 static SoftBusBcScanFilter *CreateScanFilter()
164 {
165 unsigned char serviceData[] = {0xE, 0xE, 0xF, 0xF, 0x04, 0x05};
166 int len = sizeof(serviceData);
167
168 SoftBusBcScanFilter *filter = static_cast<SoftBusBcScanFilter *>(SoftBusCalloc(sizeof(SoftBusBcScanFilter)));
169 unsigned char *serviceDataPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
170 unsigned char *serviceDataMaskPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
171 if (filter == nullptr || serviceDataPtr == nullptr || serviceDataMaskPtr == nullptr) {
172 goto EXIT;
173 }
174 if (memcpy_s(serviceDataPtr, len, serviceData, len) != EOK) {
175 goto EXIT;
176 }
177 if (memset_s(serviceDataMaskPtr, len, 0xFF, len) != EOK) {
178 goto EXIT;
179 }
180 filter->serviceData = serviceDataPtr;
181 filter->serviceDataMask = serviceDataMaskPtr;
182 filter->serviceDataLength = len;
183 return filter;
184 EXIT:
185 SoftBusFree(filter);
186 SoftBusFree(serviceDataPtr);
187 SoftBusFree(serviceDataMaskPtr);
188 return nullptr;
189 }
190
191 /**
192 * @tc.name: AdapterBleGattTest_RegisterScanListener
193 * @tc.desc: test register scan listener
194 * @tc.type: FUNC
195 * @tc.require: NONE
196 */
197 HWTEST_F(SoftbusBleGattTest, RegisterScanListener, TestSize.Level3)
198 {
199 MockBluetooth mocker;
200 int scannerId = -1;
201 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, nullptr), SOFTBUS_ERR);
202 int32_t scanListerIds[GATT_SCAN_MAX_NUM] = {};
203 int32_t ret = SOFTBUS_ERR;
204 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
205 ret = MockBluetooth::interface->RegisterScanListener(&scanListerIds[i], GetStubScanListener());
206 ASSERT_EQ(ret, SOFTBUS_OK);
207 }
208
209 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, GetStubScanListener()), SOFTBUS_ERR);
210
211 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
212 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scanListerIds[i]), SOFTBUS_OK);
213 }
214 }
215
216 /**
217 * @tc.name: AdapterBleGattTest_UnRegisterScanListener
218 * @tc.desc: test unregister scan listener
219 * @tc.type: FUNC
220 * @tc.require: NONE
221 */
222 HWTEST_F(SoftbusBleGattTest, UnRegisterScanListener, TestSize.Level3)
223 {
224 MockBluetooth mocker;
225 int scannerId = -1;
226 auto result = PrepareScanListener(&scannerId);
227 ASSERT_TRUE(result);
228
229 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(-1), SOFTBUS_INVALID_PARAM);
230 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(GATT_SCAN_MAX_NUM), SOFTBUS_INVALID_PARAM);
231 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_OK);
232 }
233
234 /**
235 * @tc.name: AdapterBleGattTest_ScanLifecycle
236 * @tc.desc: test complete scan life cycle
237 * @tc.type: FUNC
238 * @tc.require: NONE
239 */
240 HWTEST_F(SoftbusBleGattTest, ScanLifecycle, TestSize.Level3)
241 {
242 MockBluetooth mocker;
243 int scannerId = -1;
244 auto result = PrepareScanListener(&scannerId);
245 ASSERT_TRUE(result);
246
247 auto filter = CreateScanFilter();
248 ASSERT_NE(filter, nullptr);
249
250 SoftBusBcScanParams scanParam = {
251 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
252 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
253 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
254 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
255 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
256 };
257
258 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
259 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_OK);
260
261 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
262 ASSERT_EQ(MockBluetooth::interface->StopScan(scannerId), SOFTBUS_OK);
263
264 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_OK);
265 }
266
267 /**
268 * @tc.name: AdapterBleGattTest_ScanResultCb
269 * @tc.desc: test scan result callback
270 * @tc.type: FUNC
271 * @tc.require: NONE
272 */
273 HWTEST_F(SoftbusBleGattTest, ScanResultCb, TestSize.Level3)
274 {
275 MockBluetooth mocker;
276 int scannerId = -1;
277 auto result = PrepareScanListener(&scannerId);
278 ASSERT_TRUE(result);
279
280 auto filter = CreateScanFilter();
281 ASSERT_NE(filter, nullptr);
282
283 SoftBusBcScanParams scanParam = {
284 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
285 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
286 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
287 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
288 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
289 };
290
291 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
292 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, nullptr, filter, 1), SOFTBUS_INVALID_PARAM);
293 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, nullptr, 1), SOFTBUS_INVALID_PARAM);
294 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 0), SOFTBUS_INVALID_PARAM);
295 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_OK);
296
297 const unsigned char scanDataExample[] = {0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00,
298 0x04, 0x00, 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF, 0x03, 0xFF,
299 0x7D, 0x02};
300 SoftBusBcScanResult expectScanResult = {0};
301 expectScanResult.data.bcData.payloadLen = sizeof(scanDataExample);
302 expectScanResult.data.bcData.payload = (unsigned char *)scanDataExample;
303 BtScanResultData mockScanResult = {0};
304 mockScanResult.advLen = sizeof(scanDataExample);
305 mockScanResult.advData = (unsigned char *)scanDataExample;
306
307 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
308 mockScanResult.dataStatus = OHOS_BLE_DATA_COMPLETE;
309 mockScanResult.addrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
310 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
311 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
312 mockScanResult.directAddrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
313 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
314
315 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
316 mockScanResult.dataStatus = OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
317 mockScanResult.addrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
318 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_1M;
319 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_1M;
320 mockScanResult.directAddrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
321 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
322 }
323
324 /**
325 * @tc.name: AdapterBleGattTest_AdvertiseLifecycle
326 * @tc.desc: test complete Advertisement life cycle
327 * @tc.type: FUNC
328 * @tc.require: NONE
329 */
330 HWTEST_F(SoftbusBleGattTest, AdvertiseLifecycle, TestSize.Level3)
331 {
332 MockBluetooth mocker;
333 int advId = 0;
334 auto result = PrepareAdvCallback(&advId);
335 ASSERT_TRUE(result);
336
337 EXPECT_CALL(mocker, BleStartAdvEx).WillRepeatedly(ActionSuccessBleStartAdvEx);
338 ON_CALL(mocker, BleStopAdv).WillByDefault(ActionSuccessBleStopAdv);
339 const char advDataExample[] = {0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00, 0x04, 0x00,
340 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF};
341 const unsigned char scanRspDataExample[] = {0x03, 0xFF, 0x7D, 0x02};
342 SoftbusBroadcastData data = {};
343 data.bcData.payloadLen = sizeof(advDataExample);
344 data.bcData.payload = (uint8_t *)advDataExample;
345 data.rspData.payloadLen = sizeof(scanRspDataExample);
346 data.rspData.payload = (uint8_t *)scanRspDataExample;
347
348 SoftbusBroadcastParam params = {};
349 DISC_LOGI(DISC_BLE_ADAPTER, "start to StartBroadcasting");
350 ASSERT_EQ(MockBluetooth::interface->StartBroadcasting(advId, ¶ms, &data), SOFTBUS_OK);
351 ASSERT_FALSE(advEnableCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
352 DISC_LOGI(DISC_BLE_ADAPTER, "start to advEnableCb");
353 MockBluetooth::btGattCallback->advEnableCb(btInnerAdvId, OHOS_BT_STATUS_SUCCESS);
354 ASSERT_TRUE(advEnableCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
355
356 DISC_LOGI(DISC_BLE_ADAPTER, "start to advDataCb");
357 MockBluetooth::btGattCallback->advDataCb(btInnerAdvId, OHOS_BT_STATUS_SUCCESS);
358 ASSERT_TRUE(advDataCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
359
360 DISC_LOGI(DISC_BLE_ADAPTER, "start to UpdateBroadcasting");
361 ASSERT_EQ(MockBluetooth::interface->UpdateBroadcasting(advId, ¶ms, nullptr), SOFTBUS_INVALID_PARAM);
362 ASSERT_EQ(MockBluetooth::interface->UpdateBroadcasting(advId, nullptr, &data), SOFTBUS_INVALID_PARAM);
363 ASSERT_EQ(MockBluetooth::interface->UpdateBroadcasting(advId, ¶ms, &data), SOFTBUS_OK);
364 ASSERT_FALSE(advEnableCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
365 DISC_LOGI(DISC_BLE_ADAPTER, "start to advEnableCb");
366 MockBluetooth::btGattCallback->advEnableCb(btInnerAdvId, OHOS_BT_STATUS_SUCCESS);
367 ASSERT_TRUE(advEnableCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
368
369 DISC_LOGI(DISC_BLE_ADAPTER, "start to advUpdateCb");
370 MockBluetooth::btGattCallback->advUpdateCb(btInnerAdvId, OHOS_BT_STATUS_SUCCESS);
371 ASSERT_TRUE(advUpdateCtx.Expect(advId, OHOS_BT_STATUS_SUCCESS));
372
373 DISC_LOGI(DISC_BLE_ADAPTER, "start to StopBroadcasting");
374 ASSERT_EQ(MockBluetooth::interface->StopBroadcasting(advId), SOFTBUS_OK);
375
376 DISC_LOGI(DISC_BLE_ADAPTER, "start to UnRegisterBroadcaster");
377 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(-1), SOFTBUS_INVALID_PARAM);
378 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(GATT_ADV_MAX_NUM), SOFTBUS_INVALID_PARAM);
379 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(advId), SOFTBUS_OK);
380 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(advId), SOFTBUS_OK);
381 }
382
383 /**
384 * @tc.name: AdapterBleGattTest_RegisterBroadcaster
385 * @tc.desc: test register adv callback
386 * @tc.type: FUNC
387 * @tc.require: NONE
388 */
389 HWTEST_F(SoftbusBleGattTest, RegisterBroadcaster, TestSize.Level3)
390 {
391 int advId = -1;
392 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, nullptr), SOFTBUS_INVALID_PARAM);
393 int advIds[GATT_ADV_MAX_NUM];
394 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
395 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advIds[i], GetStubAdvCallback()), SOFTBUS_OK);
396 }
397 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, GetStubAdvCallback()), SOFTBUS_ERR);
398 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
399 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(advIds[i]), SOFTBUS_OK);
400 }
401 }
402
ScanResultCtx(const char * identifier)403 ScanResultCtx::ScanResultCtx(const char *identifier) : RecordCtx(identifier)
404 {
405 Reset();
406 }
~ScanResultCtx()407 ScanResultCtx::~ScanResultCtx()
408 {
409 Reset();
410 }
411
Reset()412 void ScanResultCtx::Reset()
413 {
414 SoftBusFree(scanResult.data.bcData.payload);
415 SoftBusFree(scanResult.data.rspData.payload);
416 scanResult.data.bcData.payload = nullptr;
417 scanResult.data.rspData.payload = nullptr;
418 }
419
Update(int id,const SoftBusBcScanResult * scanResult)420 bool ScanResultCtx::Update(int id, const SoftBusBcScanResult *scanResult)
421 {
422 if (!RecordCtx::Update(id)) {
423 return false;
424 }
425 this->scanResult = *scanResult;
426 unsigned char *cpyAdvData = static_cast<unsigned char *>(SoftBusCalloc(this->scanResult.data.bcData.payloadLen));
427 if (cpyAdvData == nullptr) {
428 DISC_LOGE(DISC_BLE_ADAPTER, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
429 return false;
430 }
431
432 if (memcpy_s(cpyAdvData, this->scanResult.data.bcData.payloadLen, scanResult->data.bcData.payload,
433 scanResult->data.bcData.payloadLen) != EOK) {
434 DISC_LOGE(DISC_BLE_ADAPTER, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
435 SoftBusFree(cpyAdvData);
436 return false;
437 }
438 this->scanResult.data.bcData.payload = cpyAdvData;
439 return true;
440 }
441
Expect(int id,const SoftBusBcScanResult * scanResultParam)442 testing::AssertionResult ScanResultCtx::Expect(int id, const SoftBusBcScanResult *scanResultParam)
443 {
444 auto result = RecordCtx::Expect(id);
445 if (!result) {
446 goto ClEANUP;
447 }
448
449 if (this->scanResult.data.bcData.payloadLen == scanResultParam->data.bcData.payloadLen &&
450 memcmp(this->scanResult.data.bcData.payload, scanResultParam->data.bcData.payload,
451 scanResultParam->data.bcData.payloadLen) == 0) {
452 result = testing::AssertionSuccess();
453 goto ClEANUP;
454 }
455 result = testing::AssertionFailure() << identifier << " is call by unexpectedly scan result.";
456 ClEANUP:
457 Reset();
458 return result;
459 }
460
461 } // namespace OHOS
462