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 "bluetooth_mock.h"
17 #include "c_header/ohos_bt_def.h"
18 #include "c_header/ohos_bt_gatt_server.h"
19 #include "conn_log.h"
20 #include "softbus_adapter_ble_gatt_server.h"
21 #include "softbus_error_code.h"
22 #include "gmock/gmock.h"
23 #include "gtest/gtest.h"
24
25 #include "assert_helper.h"
26
27 using namespace testing::ext;
28 using ::testing::Return;
29
30 #define MOCK_GATT_SERVER_HANDLE 0
31 #define MOCK_GATT_SERVICE_HANDLE 1
32 #define MOCK_GATT_CHARA_HANDLE 2
33 #define MOCK_GATT_DESCRIPTOR_HANDLE 3
34 #define MOCK_GATT_INCLUDE_SERVICE_HANDLE 4
35 #define SOFTBUS_TEST_MTU_SIZE 512
36
37 namespace OHOS {
38
39 class BtUuidRecordCtx : public StRecordCtx {
40 public:
41 explicit BtUuidRecordCtx(const char *identifier);
42 ~BtUuidRecordCtx();
43 bool Update(int32_t id, int32_t st, SoftBusBtUuid *param);
44 testing::AssertionResult Expect(int32_t id, int32_t st, SoftBusBtUuid *param);
45
46 private:
47 SoftBusBtUuid uuid;
48 void Reset();
49 };
50
51 class BtGattRecordCtx : public BtUuidRecordCtx {
52 public:
53 explicit BtGattRecordCtx(const char *identifier);
54 bool Update(int32_t id, int32_t st, int32_t handle, SoftBusBtUuid *param);
55 testing::AssertionResult Expect(int32_t id, int32_t st, int32_t handle, SoftBusBtUuid *param);
56
57 private:
58 int32_t handle;
59 };
60
61 class AdapterBleGattServerTest : public testing::Test {
62 public:
63 static BtGattServerCallbacks *gattServerCallback;
64 static BtUuidRecordCtx serviceAddCtx;
65 static BtGattRecordCtx characteristicAddCtx;
66 static BtGattRecordCtx descriptorAddCtx;
67 static StRecordCtx serviceStartCtx;
68 static StRecordCtx serviceStopCtx;
69 static StRecordCtx serviceDeleteCtx;
70 static BtAddrRecordCtx connectServerCtx;
71 static BtAddrRecordCtx disconnectServerCtx;
72 static SoftBusGattReadRequest requestReadCtx;
73 static SoftBusGattWriteRequest requestWriteCtx;
74 static StRecordCtx responseConfirmationCtx;
75 static StRecordCtx notifySentCtx;
76 static StRecordCtx mtuChangeCtx;
77 static StRecordCtx isConcernedAttrHandleCtx;
78 };
79
80 static SoftBusGattsCallback *GetStubGattsCallback();
81 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want);
82 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want);
83
ActionBleGattsRegisterCallbacks(BtGattServerCallbacks * func)84 int32_t ActionBleGattsRegisterCallbacks(BtGattServerCallbacks *func)
85 {
86 AdapterBleGattServerTest::gattServerCallback = func;
87 return OHOS_BT_STATUS_SUCCESS;
88 }
89
90 // 回绕到注册通知中
ActionBleGattsRegister(BtUuid appUuid)91 int32_t ActionBleGattsRegister(BtUuid appUuid)
92 {
93 AdapterBleGattServerTest::gattServerCallback->registerServerCb(0, MOCK_GATT_SERVER_HANDLE, &appUuid);
94 return OHOS_BT_STATUS_SUCCESS;
95 }
96
97 // 回绕到注册通知中
ActionBleGattsRegisterErrNull(BtUuid appUuid)98 int32_t ActionBleGattsRegisterErrNull(BtUuid appUuid)
99 {
100 appUuid.uuid = nullptr;
101 AdapterBleGattServerTest::gattServerCallback->registerServerCb(0, MOCK_GATT_SERVER_HANDLE, &appUuid);
102 return OHOS_BT_STATUS_SUCCESS;
103 }
104
105 // 回绕到注册通知中
ActionBleGattsRegisterErrLen(BtUuid appUuid)106 int32_t ActionBleGattsRegisterErrLen(BtUuid appUuid)
107 {
108 appUuid.uuid = (char *)"abc";
109 AdapterBleGattServerTest::gattServerCallback->registerServerCb(0, MOCK_GATT_SERVER_HANDLE, &appUuid);
110 return OHOS_BT_STATUS_SUCCESS;
111 }
112
113 // 回绕到注册通知中
ActionBleGattsRegisterErrStatus(BtUuid appUuid)114 int32_t ActionBleGattsRegisterErrStatus(BtUuid appUuid)
115 {
116 AdapterBleGattServerTest::gattServerCallback->registerServerCb(-1, MOCK_GATT_SERVER_HANDLE, &appUuid);
117 return OHOS_BT_STATUS_SUCCESS;
118 }
119
MockAll(MockBluetooth & mocker)120 static void MockAll(MockBluetooth &mocker)
121 {
122 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
123 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
124 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
125 EXPECT_CALL(mocker, BleGattsUnRegister).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
126 EXPECT_CALL(mocker, BleGattsAddCharacteristic).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
127 EXPECT_CALL(mocker, BleGattsAddDescriptor).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
128 EXPECT_CALL(mocker, BleGattsStartService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
129 EXPECT_CALL(mocker, BleGattsStopService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
130 EXPECT_CALL(mocker, BleGattsDeleteService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
131 EXPECT_CALL(mocker, BleGattsConnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
132 EXPECT_CALL(mocker, BleGattsDisconnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
133 EXPECT_CALL(mocker, BleGattsSendResponse).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
134 EXPECT_CALL(mocker, BleGattsSendIndication).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
135 }
136
137 /**
138 * @tc.name: AdapterBleGattServerTest_SoftBusRegisterGattsCallbacks
139 * @tc.desc: test register gatt server callbacks
140 * @tc.type: FUNC
141 * @tc.require: NONE
142 */
143 HWTEST_F(AdapterBleGattServerTest, SoftBusRegisterGattsCallbacks, TestSize.Level3)
144 {
145 InitSoftbusAdapterServer();
146 MockBluetooth mocker;
147 MockAll(mocker);
148 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
149 SoftBusBtUuid service = {
150 .uuidLen = strlen(serviceUuid),
151 .uuid = (char *)serviceUuid,
152 };
153
154 ASSERT_EQ(SoftBusRegisterGattsCallbacks(nullptr, service), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
155 << "nullptr gatts callback scenor";
156 // 清空状态，允许重入
157 SoftBusUnRegisterGattsCallbacks(service);
158 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
159 ASSERT_EQ(
160 SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
161 << "BleGattsRegisterCallbacks fail scenor";
162
163 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
164 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
165 ASSERT_EQ(
166 SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
167 << "BleGattsRegister fail scenor";
168
169 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
170 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
171
172 EXPECT_CALL(mocker, BleGattsUnRegister).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
173 SoftBusUnRegisterGattsCallbacks(service);
174
175 // 清空状态
176 EXPECT_CALL(mocker, BleGattsUnRegister).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
177 SoftBusUnRegisterGattsCallbacks(service);
178 }
179
180 /**
181 * @tc.name: AdapterBleGattServerTest_SoftBusUnRegisterGattsCallbacks
182 * @tc.desc: test unregister gatt server callbacks
183 * @tc.type: FUNC
184 * @tc.require: NONE
185 */
186 HWTEST_F(AdapterBleGattServerTest, SoftBusUnRegisterGattsCallbacks, TestSize.Level3)
187 {
188 InitSoftbusAdapterServer();
189 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
190 SoftBusBtUuid service = {
191 .uuidLen = strlen(serviceUuid),
192 .uuid = (char *)serviceUuid,
193 };
194 MockBluetooth mocker;
195 MockAll(mocker);
196 EXPECT_CALL(mocker, BleGattsRegister).WillOnce(ActionBleGattsRegisterErrNull);
197 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
198 SoftBusUnRegisterGattsCallbacks(service);
199
200 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegisterErrLen);
201 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
202 SoftBusUnRegisterGattsCallbacks(service);
203
204 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegisterErrStatus);
205 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
206 SoftBusUnRegisterGattsCallbacks(service);
207
208 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
209 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
210 SoftBusUnRegisterGattsCallbacks(service);
211 }
212
213 /**
214 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddService
215 * @tc.desc: test add gatt service
216 * @tc.type: FUNC
217 * @tc.require: NONE
218 */
219 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddService, TestSize.Level3)
220 {
221 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
222 SoftBusBtUuid service1 = {
223 .uuidLen = strlen(serviceUuid),
224 .uuid = (char *)serviceUuid,
225 };
226 ASSERT_EQ(SoftBusGattsAddService(service1, true, 1), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
227
228 MockBluetooth mocker;
229 MockAll(mocker);
230 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service1), SOFTBUS_OK);
231
232 // 注册service
233 SoftBusBtUuid service = {
234 .uuidLen = 0,
235 .uuid = nullptr,
236 };
237 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_INVALID_PARAM);
238
239 EXPECT_CALL(mocker, BleGattsAddService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
240 service.uuid = (char *)serviceUuid;
241 service.uuidLen = strlen(serviceUuid);
242 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR);
243
244 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
245 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_OK);
246 SoftBusUnRegisterGattsCallbacks(service);
247 }
248
249 /**
250 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddCharacteristic
251 * @tc.desc: test add gatt characteristic
252 * @tc.type: FUNC
253 * @tc.require: NONE
254 */
255 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddCharacteristic, TestSize.Level3)
256 {
257 SoftBusBtUuid characteristic = {
258 .uuidLen = 0,
259 .uuid = nullptr,
260 };
261 MockBluetooth mocker;
262 MockAll(mocker);
263 int32_t properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
264 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
265 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
266 int32_t permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
267 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
268 SOFTBUS_INVALID_PARAM);
269
270 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
271 characteristic.uuid = (char *)netCharacteristic;
272 characteristic.uuidLen = strlen(netCharacteristic);
273 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
274 SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
275
276 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
277 SoftBusBtUuid service = {
278 .uuidLen = strlen(serviceUuid),
279 .uuid = (char *)serviceUuid,
280 };
281
282 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
283 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
284 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
285 SOFTBUS_CONN_BLE_UNDERLAY_CHARACTERISTIC_ADD_ERR);
286
287 EXPECT_CALL(mocker, BleGattsAddCharacteristic).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
288 ASSERT_EQ(
289 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_OK);
290 SoftBusUnRegisterGattsCallbacks(service);
291 }
292
293 /**
294 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddDescriptor
295 * @tc.desc: test add gatt descriptor
296 * @tc.type: FUNC
297 * @tc.require: NONE
298 */
299 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddDescriptor, TestSize.Level3)
300 {
301 SoftBusBtUuid desciptor = {
302 .uuidLen = 0,
303 .uuid = nullptr,
304 };
305 MockBluetooth mocker;
306 MockAll(mocker);
307 int32_t permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
308 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_INVALID_PARAM);
309
310 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
311 desciptor.uuid = (char *)connDesciptor;
312 desciptor.uuidLen = strlen(connDesciptor);
313 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE,
314 desciptor, permissions), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
315
316 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
317 SoftBusBtUuid service = {
318 .uuidLen = strlen(serviceUuid),
319 .uuid = (char *)serviceUuid,
320 };
321
322 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
323
324 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
325 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions),
326 SOFTBUS_CONN_BLE_UNDERLAY_DESCRIPTOR_ADD_ERR);
327 EXPECT_CALL(mocker, BleGattsAddDescriptor).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
328 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_OK);
329 SoftBusUnRegisterGattsCallbacks(service);
330 }
331
332 /**
333 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStartService
334 * @tc.desc: test start gatt service
335 * @tc.type: FUNC
336 * @tc.require: NONE
337 */
338 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStartService, TestSize.Level3)
339 {
340 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
341 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
342 SoftBusBtUuid service = {
343 .uuidLen = strlen(serviceUuid),
344 .uuid = (char *)serviceUuid,
345 };
346 MockBluetooth mocker;
347 MockAll(mocker);
348 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
349
350 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
351 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_START_ERR);
352
353 EXPECT_CALL(mocker, BleGattsStartService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
354 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
355 SoftBusUnRegisterGattsCallbacks(service);
356 }
357
358 /**
359 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStopService
360 * @tc.desc: test stop gatt service
361 * @tc.type: FUNC
362 * @tc.require: NONE
363 */
364 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStopService, TestSize.Level3)
365 {
366 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
367 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
368 SoftBusBtUuid service = {
369 .uuidLen = strlen(serviceUuid),
370 .uuid = (char *)serviceUuid,
371 };
372 MockBluetooth mocker;
373 MockAll(mocker);
374 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
375
376 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
377 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_STOP_ERR);
378
379 EXPECT_CALL(mocker, BleGattsStopService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
380 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
381 SoftBusUnRegisterGattsCallbacks(service);
382 }
383
384 /**
385 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDeleteService
386 * @tc.desc: test delete gatt service
387 * @tc.type: FUNC
388 * @tc.require: NONE
389 */
390 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDeleteService, TestSize.Level3)
391 {
392 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
393 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
394 SoftBusBtUuid service = {
395 .uuidLen = strlen(serviceUuid),
396 .uuid = (char *)serviceUuid,
397 };
398 MockBluetooth mocker;
399 MockAll(mocker);
400 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
401
402 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
403 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_DELETE_ERR);
404
405 EXPECT_CALL(mocker, BleGattsDeleteService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
406 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
407 SoftBusUnRegisterGattsCallbacks(service);
408 }
409
410 /**
411 * @tc.name: AdapterBleGattServerTest_SoftBusGattsConnect
412 * @tc.desc: test connect gatt connection
413 * @tc.type: FUNC
414 * @tc.require: NONE
415 */
416 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsConnect, TestSize.Level3)
417 {
418 SoftBusBtAddr addr = {
419 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
420 };
421 ASSERT_EQ(SoftBusGattsConnect(addr), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
422 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
423 SoftBusBtUuid service = {
424 .uuidLen = strlen(serviceUuid),
425 .uuid = (char *)serviceUuid,
426 };
427 MockBluetooth mocker;
428 MockAll(mocker);
429 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
430 EXPECT_CALL(mocker, BleGattsConnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
431 ASSERT_EQ(SoftBusGattsConnect(addr), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_CONNECT_ERR);
432
433 EXPECT_CALL(mocker, BleGattsConnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
434 ASSERT_EQ(SoftBusGattsConnect(addr), SOFTBUS_OK);
435 SoftBusUnRegisterGattsCallbacks(service);
436 }
437
438 /**
439 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDisconnect
440 * @tc.desc: test disconnect gatt connection
441 * @tc.type: FUNC
442 * @tc.require: NONE
443 */
444 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDisconnect, TestSize.Level3)
445 {
446 int32_t connId = 1;
447 SoftBusBtAddr addr = {
448 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
449 };
450 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
451 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
452 SoftBusBtUuid service = {
453 .uuidLen = strlen(serviceUuid),
454 .uuid = (char *)serviceUuid,
455 };
456 MockBluetooth mocker;
457 MockAll(mocker);
458 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
459
460 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
461 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_DISCONNECT_ERR);
462
463 EXPECT_CALL(mocker, BleGattsDisconnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
464 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_OK);
465 SoftBusUnRegisterGattsCallbacks(service);
466 }
467
468 /**
469 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendResponse
470 * @tc.desc: test send gatt response
471 * @tc.type: FUNC
472 * @tc.require: NONE
473 */
474 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendResponse, TestSize.Level3)
475 {
476 ASSERT_EQ(SoftBusGattsSendResponse(nullptr), SOFTBUS_INVALID_PARAM);
477 SoftBusGattsResponse resp = { 0 };
478 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
479 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
480 SoftBusBtUuid service = {
481 .uuidLen = strlen(serviceUuid),
482 .uuid = (char *)serviceUuid,
483 };
484 MockBluetooth mocker;
485 MockAll(mocker);
486 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
487
488 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
489 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_RESPONSE_ERR);
490
491 EXPECT_CALL(mocker, BleGattsSendResponse).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
492 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
493 SoftBusUnRegisterGattsCallbacks(service);
494 }
495
496 /**
497 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendNotify
498 * @tc.desc: test send gatt notify
499 * @tc.type: FUNC
500 * @tc.require: NONE
501 */
502 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendNotify, TestSize.Level3)
503 {
504 ASSERT_EQ(SoftBusGattsSendNotify(nullptr), SOFTBUS_INVALID_PARAM);
505 SoftBusGattsNotify notify = { 0 };
506 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_CONN_BLE_CHECK_STATUS_ERR);
507 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
508 SoftBusBtUuid service = {
509 .uuidLen = strlen(serviceUuid),
510 .uuid = (char *)serviceUuid,
511 };
512 MockBluetooth mocker;
513 MockAll(mocker);
514 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
515
516 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
517 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_INDICATION_ERR);
518
519 EXPECT_CALL(mocker, BleGattsSendIndication).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
520 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
521 SoftBusUnRegisterGattsCallbacks(service);
522 }
523
524 /**
525 * @tc.name: AdapterBleGattServerTest_BleConnectServerCallback
526 * @tc.desc: test gatt connect server callback
527 * @tc.type: FUNC
528 * @tc.require: NONE
529 */
530 HWTEST_F(AdapterBleGattServerTest, BleConnectServerCallback, TestSize.Level3)
531 {
532 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
533 SoftBusBtUuid service = {
534 .uuidLen = strlen(serviceUuid),
535 .uuid = (char *)serviceUuid,
536 };
537 MockBluetooth mocker;
538 MockAll(mocker);
539 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
540
541 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, nullptr);
542
543 BdAddr bdAddr = {
544 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
545 };
546
547 gattServerCallback->connectServerCb(1, 1, &bdAddr);
548 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
549 SoftBusBtAddr addr = {
550 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
551 };
552 GetStubGattsCallback()->connectServerCallback(1, &addr);
553 ASSERT_TRUE(connectServerCtx.Expect(1, &addr));
554 SoftBusUnRegisterGattsCallbacks(service);
555 }
556
557 /**
558 * @tc.name: AdapterBleGattServerTest_BleDisconnectServerCallback
559 * @tc.desc: test gatt disconnect server callback
560 * @tc.type: FUNC
561 * @tc.require: NONE
562 */
563 HWTEST_F(AdapterBleGattServerTest, BleDisconnectServerCallback, TestSize.Level3)
564 {
565 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
566 SoftBusBtUuid service = {
567 .uuidLen = strlen(serviceUuid),
568 .uuid = (char *)serviceUuid,
569 };
570 MockBluetooth mocker;
571 MockAll(mocker);
572 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
573
574 BdAddr bdAddr = {
575 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
576 };
577 gattServerCallback->disconnectServerCb(1, 1, &bdAddr);
578
579 SoftBusBtAddr addr = {
580 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
581 };
582 ASSERT_EQ(SoftBusGattsDisconnect(addr, 1), SOFTBUS_OK);
583 gattServerCallback->disconnectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
584
585 GetStubGattsCallback()->disconnectServerCallback(1, &addr);
586 ASSERT_TRUE(disconnectServerCtx.Expect(1, &addr));
587 SoftBusUnRegisterGattsCallbacks(service);
588 }
589
590 /**
591 * @tc.name: AdapterBleGattServerTest_BleServiceAddCallback
592 * @tc.desc: test gatt server add callback
593 * @tc.type: FUNC
594 * @tc.require: NONE
595 */
596 HWTEST_F(AdapterBleGattServerTest, BleServiceAddCallback, TestSize.Level3)
597 {
598 // 注册service
599 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
600 SoftBusBtUuid service = {
601 .uuidLen = strlen(serviceUuid),
602 .uuid = (char *)serviceUuid,
603 };
604 MockBluetooth mocker;
605 MockAll(mocker);
606 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
607
608 gattServerCallback->serviceAddCb(
609 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, nullptr, MOCK_GATT_SERVICE_HANDLE);
610
611 BtUuid btService = {
612 .uuidLen = strlen(serviceUuid),
613 .uuid = (char *)serviceUuid,
614 };
615 gattServerCallback->serviceAddCb(
616 OHOS_BT_STATUS_SUCCESS, 1, &btService, MOCK_GATT_SERVICE_HANDLE);
617 gattServerCallback->serviceAddCb(
618 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btService, MOCK_GATT_SERVICE_HANDLE);
619 ASSERT_TRUE(serviceAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, &service));
620 SoftBusUnRegisterGattsCallbacks(service);
621 }
622
623 /**
624 * @tc.name: AdapterBleGattServerTest_BleDescriptorAddCallback
625 * @tc.desc: test descriptor add callback
626 * @tc.type: FUNC
627 * @tc.require: NONE
628 */
629 HWTEST_F(AdapterBleGattServerTest, BleDescriptorAddCallback, TestSize.Level3)
630 {
631 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS, SOFTBUS_INVALID_PARAM, nullptr,
632 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_CHARA_HANDLE);
633
634 // 注册service
635 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
636 SoftBusBtUuid service = {
637 .uuidLen = strlen(serviceUuid),
638 .uuid = (char *)serviceUuid,
639 };
640 MockBluetooth mocker;
641 MockAll(mocker);
642 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
643 gattServerCallback->includeServiceAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE,
644 MOCK_GATT_INCLUDE_SERVICE_HANDLE);
645
646 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
647 BtUuid btCharacteristic = {
648 .uuidLen = strlen(netCharacteristic),
649 .uuid = (char *)netCharacteristic,
650 };
651 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btCharacteristic,
652 SOFTBUS_INVALID_PARAM, MOCK_GATT_CHARA_HANDLE);
653
654 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, nullptr,
655 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_DESCRIPTOR_HANDLE);
656
657 // 注册desciptor
658 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
659 BtUuid btDescriptor = {
660 .uuidLen = strlen(connDesciptor),
661 .uuid = (char *)connDesciptor,
662 };
663 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, SOFTBUS_INVALID_PARAM, &btDescriptor,
664 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_DESCRIPTOR_HANDLE);
665 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btDescriptor,
666 SOFTBUS_INVALID_PARAM, MOCK_GATT_DESCRIPTOR_HANDLE);
667 SoftBusBtUuid descriptor = {
668 .uuidLen = strlen(connDesciptor),
669 .uuid = (char *)connDesciptor,
670 };
671 ASSERT_FALSE(
672 descriptorAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_DESCRIPTOR_HANDLE, &descriptor));
673 SoftBusUnRegisterGattsCallbacks(service);
674 }
675
676 /**
677 * @tc.name: AdapterBleGattServerTest_BleRequestReadCallback
678 * @tc.desc: test ble request read callback
679 * @tc.type: FUNC
680 * @tc.require: NONE
681 */
682 HWTEST_F(AdapterBleGattServerTest, BleRequestReadCallback, TestSize.Level3)
683 {
684 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, SOFTBUS_INVALID_PARAM, MOCK_GATT_SERVICE_HANDLE);
685 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, SOFTBUS_INVALID_PARAM, MOCK_GATT_SERVICE_HANDLE);
686 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, SOFTBUS_INVALID_PARAM, MOCK_GATT_SERVICE_HANDLE);
687
688 // 注册service
689 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
690 SoftBusBtUuid service = {
691 .uuidLen = strlen(serviceUuid),
692 .uuid = (char *)serviceUuid,
693 };
694 MockBluetooth mocker;
695 MockAll(mocker);
696 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
697
698 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, SOFTBUS_INVALID_PARAM);
699 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, SOFTBUS_INVALID_PARAM);
700 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, SOFTBUS_INVALID_PARAM);
701 gattServerCallback->responseConfirmationCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE);
702 gattServerCallback->indicationSentCb(1, OHOS_BT_STATUS_SUCCESS);
703
704 // server建链
705 BdAddr bdAddr = {
706 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
707 };
708 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
709 BtReqReadCbPara btReadParam = {
710 .connId = -1,
711 .transId = 0,
712 .bdAddr = &bdAddr,
713 .attrHandle = MOCK_GATT_CHARA_HANDLE,
714 .offset = 0,
715 .isLong = false,
716 };
717 gattServerCallback->requestReadCb(btReadParam);
718 gattServerCallback->indicationSentCb(1, OHOS_BT_STATUS_SUCCESS);
719 SoftBusBtAddr addr = {
720 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
721 };
722 SoftBusGattReadRequest readParam = {
723 .connId = 1,
724 .transId = 0,
725 .btAddr = &addr,
726 .attrHandle = MOCK_GATT_CHARA_HANDLE,
727 .offset = 0,
728 .isLong = false,
729 };
730 GetStubGattsCallback()->requestReadCallback(readParam);
731 ASSERT_TRUE(ExpectGattReadRequest(requestReadCtx, readParam));
732 SoftBusUnRegisterGattsCallbacks(service);
733 }
734
735 /**
736 * @tc.name: AdapterBleGattServerTest_BleRequestWriteCallback
737 * @tc.desc: test ble request write callback
738 * @tc.type: FUNC
739 * @tc.require: NONE
740 */
741 HWTEST_F(AdapterBleGattServerTest, BleRequestWriteCallback, TestSize.Level3)
742 {
743 // 注册service
744 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
745 SoftBusBtUuid service = {
746 .uuidLen = strlen(serviceUuid),
747 .uuid = (char *)serviceUuid,
748 };
749 MockBluetooth mocker;
750 MockAll(mocker);
751 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
752
753 // server建链
754 BdAddr bdAddr = {
755 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
756 };
757 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
758 SoftBusBtAddr addr = {
759 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
760 };
761 GetStubGattsCallback()->connectServerCallback(1, &addr);
762 ASSERT_TRUE(connectServerCtx.Expect(1, &addr));
763
764 const char *valueExample = "hello gatt server, this is client";
765 BtReqWriteCbPara btWriteParam = {
766 .connId = -1,
767 .transId = 0,
768 .bdAddr = &bdAddr,
769 .attrHandle = MOCK_GATT_CHARA_HANDLE,
770 .offset = 0,
771 .length = strlen(valueExample),
772 .needRsp = true,
773 .isPrep = false,
774 .value = (unsigned char *)valueExample,
775 };
776 gattServerCallback->mtuChangeCb(-1, 0);
777 gattServerCallback->mtuChangeCb(1, SOFTBUS_TEST_MTU_SIZE);
778 gattServerCallback->requestWriteCb(btWriteParam);
779 SoftBusGattWriteRequest writeParam = {
780 .connId = 1,
781 .transId = 0,
782 .btAddr = &addr,
783 .attrHandle = MOCK_GATT_CHARA_HANDLE,
784 .offset = 0,
785 .length = strlen(valueExample),
786 .needRsp = true,
787 .isPrep = false,
788 .value = (unsigned char *)valueExample,
789 };
790 GetStubGattsCallback()->requestWriteCallback(writeParam);
791 ASSERT_TRUE(ExpectGattWriteRequest(requestWriteCtx, writeParam));
792 SoftBusUnRegisterGattsCallbacks(service);
793 }
794
795 /**
796 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
797 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
798 * @tc.type: FUNC
799 * @tc.require: NONE
800 */
801 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle1, TestSize.Level3)
802 {
803 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
804 SoftBusBtUuid service = {
805 .uuidLen = strlen(serviceUuid),
806 .uuid = (char *)serviceUuid,
807 };
808 MockBluetooth mocker;
809 MockAll(mocker);
810 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
811
812 ASSERT_EQ(SoftBusGattsAddService(service, true, 8), SOFTBUS_OK);
813 BtUuid btService = {
814 .uuidLen = strlen(serviceUuid),
815 .uuid = (char *)serviceUuid,
816 };
817 gattServerCallback->serviceAddCb(
818 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btService, MOCK_GATT_SERVICE_HANDLE);
819 ASSERT_TRUE(serviceAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, &service));
820
821 // 注册charateristic
822 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
823 SoftBusBtUuid characteristic = {
824 .uuidLen = strlen(netCharacteristic),
825 .uuid = (char *)netCharacteristic,
826 };
827 int32_t properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
828 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
829 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
830 int32_t charaPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
831 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, charaPermissions),
832 SOFTBUS_OK);
833 BtUuid btCharacteristic = {
834 .uuidLen = strlen(netCharacteristic),
835 .uuid = (char *)netCharacteristic,
836 };
837 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btCharacteristic,
838 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_CHARA_HANDLE);
839 ASSERT_TRUE(
840 characteristicAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_CHARA_HANDLE, &characteristic));
841 }
842
843 /**
844 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
845 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
846 * @tc.type: FUNC
847 * @tc.require: NONE
848 */
849 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle2, TestSize.Level3)
850 {
851 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
852 SoftBusBtUuid service = {
853 .uuidLen = strlen(serviceUuid),
854 .uuid = (char *)serviceUuid,
855 };
856 MockBluetooth mocker;
857 MockAll(mocker);
858 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
859
860 // 注册desciptor
861 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
862 int32_t descriptorPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
863 SoftBusBtUuid descriptor = {
864 .uuidLen = strlen(connDesciptor),
865 .uuid = (char *)connDesciptor,
866 };
867 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, descriptor, descriptorPermissions), SOFTBUS_OK);
868 BtUuid btDescriptor = {
869 .uuidLen = strlen(connDesciptor),
870 .uuid = (char *)connDesciptor,
871 };
872 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btDescriptor,
873 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_DESCRIPTOR_HANDLE);
874 ASSERT_TRUE(
875 descriptorAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_DESCRIPTOR_HANDLE, &descriptor));
876 // 启动Listen
877 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
878 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
879 ASSERT_TRUE(serviceStartCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
880 }
881
882 /**
883 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
884 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
885 * @tc.type: FUNC
886 * @tc.require: NONE
887 */
888 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle3, TestSize.Level3)
889 {
890 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
891 SoftBusBtUuid service = {
892 .uuidLen = strlen(serviceUuid),
893 .uuid = (char *)serviceUuid,
894 };
895 MockBluetooth mocker;
896 MockAll(mocker);
897 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
898 // server建链
899 BdAddr bdAddr = {
900 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
901 };
902 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
903 SoftBusBtAddr addr = {
904 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
905 };
906 GetStubGattsCallback()->connectServerCallback(1, &addr);
907 ASSERT_TRUE(connectServerCtx.Expect(1, &addr));
908 // 读写数据，及响应回复
909 const char *valueExample = "hello gatt server, this is client";
910 BtReqWriteCbPara btWriteParam = {
911 .connId = 1,
912 .transId = 0,
913 .bdAddr = &bdAddr,
914 .attrHandle = MOCK_GATT_CHARA_HANDLE,
915 .offset = 0,
916 .length = strlen(valueExample),
917 .needRsp = true,
918 .isPrep = false,
919 .value = (unsigned char *)valueExample,
920 };
921 gattServerCallback->requestWriteCb(btWriteParam);
922 SoftBusGattWriteRequest writeParam = {
923 .connId = 1,
924 .transId = 0,
925 .btAddr = &addr,
926 .attrHandle = MOCK_GATT_CHARA_HANDLE,
927 .offset = 0,
928 .length = strlen(valueExample),
929 .needRsp = true,
930 .isPrep = false,
931 .value = (unsigned char *)valueExample,
932 };
933 GetStubGattsCallback()->requestWriteCallback(writeParam);
934 ASSERT_TRUE(ExpectGattWriteRequest(requestWriteCtx, writeParam));
935 SoftBusGattsResponse resp = { 0 };
936 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
937 }
938
939 /**
940 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
941 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
942 * @tc.type: FUNC
943 * @tc.require: NONE
944 */
945 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle4, TestSize.Level3)
946 {
947 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
948 SoftBusBtUuid service = {
949 .uuidLen = strlen(serviceUuid),
950 .uuid = (char *)serviceUuid,
951 };
952 MockBluetooth mocker;
953 MockAll(mocker);
954 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
955 BdAddr bdAddr = {
956 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
957 };
958 SoftBusBtAddr addr = {
959 .addr = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 },
960 };
961 BtReqReadCbPara btReadParam = {
962 .connId = 1,
963 .transId = 0,
964 .bdAddr = &bdAddr,
965 .attrHandle = MOCK_GATT_CHARA_HANDLE,
966 .offset = 0,
967 .isLong = false,
968 };
969 gattServerCallback->requestReadCb(btReadParam);
970 SoftBusGattReadRequest readParam = {
971 .connId = 1,
972 .transId = 0,
973 .btAddr = &addr,
974 .attrHandle = MOCK_GATT_CHARA_HANDLE,
975 .offset = 0,
976 .isLong = false,
977 };
978 GetStubGattsCallback()->requestReadCallback(readParam);
979 ASSERT_TRUE(ExpectGattReadRequest(requestReadCtx, readParam));
980 SoftBusGattsNotify notify = { 0 };
981 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
982 // server断链
983 ASSERT_EQ(SoftBusGattsDisconnect(addr, 1), SOFTBUS_OK);
984 gattServerCallback->disconnectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
985
986 // 停止GATT service
987 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
988 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
989 ASSERT_TRUE(serviceStopCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
990
991 // 删除GATT service
992 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
993 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
994 ASSERT_TRUE(serviceDeleteCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
995 }
996
BtUuidRecordCtx(const char * identifier)997 BtUuidRecordCtx::BtUuidRecordCtx(const char *identifier) : StRecordCtx(identifier)
998 {
999 Reset();
1000 }
~BtUuidRecordCtx()1001 BtUuidRecordCtx::~BtUuidRecordCtx()
1002 {
1003 Reset();
1004 }
1005
Reset()1006 void BtUuidRecordCtx::Reset()
1007 {
1008 SoftBusFree(uuid.uuid);
1009 uuid.uuid = nullptr;
1010 uuid.uuidLen = 0;
1011 }
1012
Update(int32_t id,int32_t st,SoftBusBtUuid * param)1013 bool BtUuidRecordCtx::Update(int32_t id, int32_t st, SoftBusBtUuid *param)
1014 {
1015 if (!StRecordCtx::Update(id, st)) {
1016 return false;
1017 }
1018 uuid.uuid = (char *)SoftBusCalloc(param->uuidLen);
1019 if (uuid.uuid == nullptr) {
1020 return false;
1021 }
1022 if (memcpy_s(uuid.uuid, param->uuidLen, param->uuid, param->uuidLen) != EOK) {
1023 return false;
1024 }
1025 uuid.uuidLen = param->uuidLen;
1026 return true;
1027 }
1028
Expect(int32_t id,int32_t st,SoftBusBtUuid * param)1029 testing::AssertionResult BtUuidRecordCtx::Expect(int32_t id, int32_t st, SoftBusBtUuid *param)
1030 {
1031 auto result = StRecordCtx::Expect(id, st);
1032 if (!result) {
1033 goto ClEANUP;
1034 }
1035 if (uuid.uuidLen != param->uuidLen || memcmp(uuid.uuid, param->uuid, uuid.uuidLen) != 0) {
1036 result = testing::AssertionFailure() << identifier << " is call by unexpectedly uuid";
1037 goto ClEANUP;
1038 }
1039 result = testing::AssertionSuccess();
1040 ClEANUP:
1041 Reset();
1042 return result;
1043 }
1044
BtGattRecordCtx(const char * identifier)1045 BtGattRecordCtx::BtGattRecordCtx(const char *identifier) : BtUuidRecordCtx(identifier)
1046 {
1047 handle = -1;
1048 }
1049
Update(int32_t id,int32_t st,int32_t handleParam,SoftBusBtUuid * param)1050 bool BtGattRecordCtx::Update(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)
1051 {
1052 if (!BtUuidRecordCtx::Update(id, st, param)) {
1053 return false;
1054 }
1055 this->handle = handleParam;
1056 return true;
1057 }
1058
Expect(int32_t id,int32_t st,int32_t handleParam,SoftBusBtUuid * param)1059 testing::AssertionResult BtGattRecordCtx::Expect(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)
1060 {
1061 auto result = BtUuidRecordCtx::Expect(id, st, param);
1062 if (!result) {
1063 goto ClEANUP;
1064 }
1065 if (this->handle != handleParam) {
1066 result = testing::AssertionFailure() << identifier << " is call by unexpectedly state,"
1067 << "want: " << handleParam << ", actual: " << this->handle;
1068 goto ClEANUP;
1069 }
1070 result = testing::AssertionSuccess();
1071 ClEANUP:
1072 this->handle = -1;
1073 return result;
1074 }
1075
1076 BtGattServerCallbacks *AdapterBleGattServerTest::gattServerCallback = nullptr;
1077 BtUuidRecordCtx AdapterBleGattServerTest::serviceAddCtx("ServiceAddCallback");
1078 BtGattRecordCtx AdapterBleGattServerTest::characteristicAddCtx("CharacteristicAddCallback");
1079 BtGattRecordCtx AdapterBleGattServerTest::descriptorAddCtx("DescriptorAddCallback");
1080 StRecordCtx AdapterBleGattServerTest::serviceStartCtx("ServiceStartCallback");
1081 StRecordCtx AdapterBleGattServerTest::serviceStopCtx("ServiceStopCallback");
1082 StRecordCtx AdapterBleGattServerTest::serviceDeleteCtx("ServiceDeleteCallback");
1083 BtAddrRecordCtx AdapterBleGattServerTest::connectServerCtx("ConnectServerCallback");
1084 BtAddrRecordCtx AdapterBleGattServerTest::disconnectServerCtx("DisconnectServerCallback");
1085 SoftBusGattReadRequest AdapterBleGattServerTest::requestReadCtx = { 0 };
1086 SoftBusGattWriteRequest AdapterBleGattServerTest::requestWriteCtx = { 0 };
1087 StRecordCtx AdapterBleGattServerTest::responseConfirmationCtx("ResponseConfirmationCallback");
1088 StRecordCtx AdapterBleGattServerTest::notifySentCtx("NotifySentCallback");
1089 StRecordCtx AdapterBleGattServerTest::mtuChangeCtx("MtuChangeCallback");
1090 StRecordCtx AdapterBleGattServerTest::isConcernedAttrHandleCtx("isConcernedAttrHandle");
1091
StubServiceAddCallback(int32_t status,SoftBusBtUuid * uuid,int32_t srvcHandle)1092 static void StubServiceAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle)
1093 {
1094 AdapterBleGattServerTest::serviceAddCtx.Update(srvcHandle, status, uuid);
1095 }
1096
StubCharacteristicAddCallback(int32_t status,SoftBusBtUuid * uuid,int32_t srvcHandle,int32_t characteristicHandle)1097 static void StubCharacteristicAddCallback(
1098 int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle, int32_t characteristicHandle)
1099 {
1100 AdapterBleGattServerTest::characteristicAddCtx.Update(srvcHandle, status, characteristicHandle, uuid);
1101 }
1102
StubDescriptorAddCallback(int32_t status,SoftBusBtUuid * uuid,int32_t srvcHandle,int32_t descriptorHandle)1103 static void StubDescriptorAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle, int32_t descriptorHandle)
1104 {
1105 AdapterBleGattServerTest::descriptorAddCtx.Update(srvcHandle, status, descriptorHandle, uuid);
1106 }
1107
StubServiceStartCallback(int32_t status,int32_t srvcHandle)1108 static void StubServiceStartCallback(int32_t status, int32_t srvcHandle)
1109 {
1110 AdapterBleGattServerTest::serviceStartCtx.Update(srvcHandle, status);
1111 }
1112
StubServiceStopCallback(int32_t status,int32_t srvcHandle)1113 static void StubServiceStopCallback(int32_t status, int32_t srvcHandle)
1114 {
1115 AdapterBleGattServerTest::serviceStopCtx.Update(srvcHandle, status);
1116 }
1117
StubServiceDeleteCallback(int32_t status,int32_t srvcHandle)1118 static void StubServiceDeleteCallback(int32_t status, int32_t srvcHandle)
1119 {
1120 AdapterBleGattServerTest::serviceDeleteCtx.Update(srvcHandle, status);
1121 }
1122
StubConnectServerCallback(int32_t connId,const SoftBusBtAddr * btAddr)1123 static void StubConnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)
1124 {
1125 AdapterBleGattServerTest::connectServerCtx.Update(connId, btAddr);
1126 }
1127
StubDisconnectServerCallback(int32_t connId,const SoftBusBtAddr * btAddr)1128 static void StubDisconnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)
1129 {
1130 AdapterBleGattServerTest::disconnectServerCtx.Update(connId, btAddr);
1131 }
1132
StubRequestReadCallback(SoftBusGattReadRequest readCbPara)1133 static void StubRequestReadCallback(SoftBusGattReadRequest readCbPara)
1134 {
1135 AdapterBleGattServerTest::requestReadCtx = readCbPara;
1136 }
1137
StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)1138 static void StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)
1139 {
1140 AdapterBleGattServerTest::requestWriteCtx = writeCbPara;
1141 }
1142
StubResponseConfirmationCallback(int32_t status,int32_t handle)1143 static void StubResponseConfirmationCallback(int32_t status, int32_t handle)
1144 {
1145 AdapterBleGattServerTest::responseConfirmationCtx.Update(handle, status);
1146 }
StubNotifySentCallback(int32_t connId,int32_t status)1147 static void StubNotifySentCallback(int32_t connId, int32_t status)
1148 {
1149 AdapterBleGattServerTest::notifySentCtx.Update(connId, status);
1150 }
StubMtuChangeCallback(int32_t connId,int32_t mtu)1151 static void StubMtuChangeCallback(int32_t connId, int32_t mtu)
1152 {
1153 AdapterBleGattServerTest::mtuChangeCtx.Update(connId, mtu);
1154 }
1155
StubIsConcernedAttrHandle(int32_t srvcHandle,int32_t attrHandle)1156 static bool StubIsConcernedAttrHandle(int32_t srvcHandle, int32_t attrHandle)
1157 {
1158 return AdapterBleGattServerTest::isConcernedAttrHandleCtx.Update(srvcHandle, attrHandle);
1159 }
1160
GetStubGattsCallback()1161 static SoftBusGattsCallback *GetStubGattsCallback()
1162 {
1163 static SoftBusGattsCallback callbacks = {
1164 .serviceAddCallback = StubServiceAddCallback,
1165 .characteristicAddCallback = StubCharacteristicAddCallback,
1166 .descriptorAddCallback = StubDescriptorAddCallback,
1167 .serviceStartCallback = StubServiceStartCallback,
1168 .serviceStopCallback = StubServiceStopCallback,
1169 .serviceDeleteCallback = StubServiceDeleteCallback,
1170 .connectServerCallback = StubConnectServerCallback,
1171 .disconnectServerCallback = StubDisconnectServerCallback,
1172 .requestReadCallback = StubRequestReadCallback,
1173 .requestWriteCallback = StubRequestWriteCallback,
1174 .responseConfirmationCallback = StubResponseConfirmationCallback,
1175 .notifySentCallback = StubNotifySentCallback,
1176 .mtuChangeCallback = StubMtuChangeCallback,
1177 .isConcernedAttrHandle = StubIsConcernedAttrHandle,
1178 };
1179 return &callbacks;
1180 }
1181
ExpectGattWriteRequest(SoftBusGattWriteRequest actual,SoftBusGattWriteRequest want)1182 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want)
1183 {
1184 if (want.connId != actual.connId || want.transId != actual.transId ||
1185 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 || want.attrHandle != actual.attrHandle ||
1186 want.offset != actual.offset || want.length != actual.length ||
1187 !(want.needRsp ? actual.needRsp : !actual.needRsp) || !(want.isPrep ? actual.isPrep : !actual.isPrep) ||
1188 memcmp(want.value, actual.value, want.length) != 0) {
1189 return testing::AssertionFailure() << "SoftBusGattWriteRequest is unexpected";
1190 }
1191 return testing::AssertionSuccess();
1192 }
1193
ExpectGattReadRequest(SoftBusGattReadRequest actual,SoftBusGattReadRequest want)1194 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want)
1195 {
1196 if (want.connId != actual.connId || want.transId != actual.transId ||
1197 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 || want.attrHandle != actual.attrHandle ||
1198 want.offset != actual.offset || !(want.isLong ? actual.isLong : !actual.isLong)) {
1199 return testing::AssertionFailure() << "SoftBusGattReadRequest is unexpected";
1200 }
1201 return testing::AssertionSuccess();
1202 }
1203
1204 } // namespace OHOS
1205