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 "bluetooth_mock.h"
20 #include "c_header/ohos_bt_def.h"
21 #include "c_header/ohos_bt_gatt_server.h"
22 #include "softbus_adapter_ble_gatt_server.h"
23 #include "softbus_error_code.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
35 namespace OHOS {
36
37 class BtUuidRecordCtx : public StRecordCtx {
38 public:
39 explicit BtUuidRecordCtx(const char *identifier);
40 ~BtUuidRecordCtx();
41 bool Update(int id, int st, SoftBusBtUuid *param);
42 testing::AssertionResult Expect(int id, int st, SoftBusBtUuid *param);
43
44 private:
45 SoftBusBtUuid uuid;
46 void Reset();
47 };
48
49 class BtGattRecordCtx : public BtUuidRecordCtx {
50 public:
51 explicit BtGattRecordCtx(const char *identifier);
52 bool Update(int id, int st, int handle, SoftBusBtUuid *param);
53 testing::AssertionResult Expect(int id, int st, int handle, SoftBusBtUuid *param);
54
55 private:
56 int handle;
57 };
58
59 class AdapterBleGattServerTest : public testing::Test {
60 public:
61 static BtGattServerCallbacks *gattServerCallback;
62 static BtUuidRecordCtx serviceAddCtx;
63 static BtGattRecordCtx characteristicAddCtx;
64 static BtGattRecordCtx descriptorAddCtx;
65 static StRecordCtx serviceStartCtx;
66 static StRecordCtx serviceStopCtx;
67 static StRecordCtx serviceDeleteCtx;
68 static BtAddrRecordCtx connectServerCtx;
69 static BtAddrRecordCtx disconnectServerCtx;
70 static SoftBusGattReadRequest requestReadCtx;
71 static SoftBusGattWriteRequest requestWriteCtx;
72 static StRecordCtx responseConfirmationCtx;
73 static StRecordCtx notifySentCtx;
74 static StRecordCtx mtuChangeCtx;
75 };
76
77 static SoftBusGattsCallback *GetStubGattsCallback();
78 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want);
79 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want);
80
ActionBleGattsRegisterCallbacks(BtGattServerCallbacks * func)81 int ActionBleGattsRegisterCallbacks(BtGattServerCallbacks *func)
82 {
83 AdapterBleGattServerTest::gattServerCallback = func;
84 return OHOS_BT_STATUS_SUCCESS;
85 }
86
87 // 回绕到注册通知中
ActionBleGattsRegister(BtUuid appUuid)88 int ActionBleGattsRegister(BtUuid appUuid)
89 {
90 AdapterBleGattServerTest::gattServerCallback->registerServerCb(0, MOCK_GATT_SERVER_HANDLE, &appUuid);
91 return OHOS_BT_STATUS_SUCCESS;
92 }
93
MockAll(MockBluetooth & mocker)94 static void MockAll(MockBluetooth &mocker)
95 {
96 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
97 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
98 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
99 EXPECT_CALL(mocker, BleGattsUnRegister).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
100 EXPECT_CALL(mocker, BleGattsAddCharacteristic).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
101 EXPECT_CALL(mocker, BleGattsAddDescriptor).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
102 EXPECT_CALL(mocker, BleGattsStartService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
103 EXPECT_CALL(mocker, BleGattsStopService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
104 EXPECT_CALL(mocker, BleGattsDeleteService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
105 EXPECT_CALL(mocker, BleGattsDisconnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
106 EXPECT_CALL(mocker, BleGattsSendResponse).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
107 EXPECT_CALL(mocker, BleGattsSendIndication).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
108 }
109
110 /**
111 * @tc.name: AdapterBleGattServerTest_SoftBusRegisterGattsCallbacks
112 * @tc.desc: test register gatt server callbacks
113 * @tc.type: FUNC
114 * @tc.require: NONE
115 */
116 HWTEST_F(AdapterBleGattServerTest, SoftBusRegisterGattsCallbacks, TestSize.Level3)
117 {
118 InitSoftbusAdapterServer();
119 MockBluetooth mocker;
120 MockAll(mocker);
121 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
122 SoftBusBtUuid service = {
123 .uuidLen = strlen(serviceUuid),
124 .uuid = (char *)serviceUuid,
125 };
126
127 ASSERT_EQ(SoftBusRegisterGattsCallbacks(nullptr, service),
128 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
129 << "nullptr gatts callback scenor";
130 // 清空状态，允许重入
131 SoftBusUnRegisterGattsCallbacks(service);
132 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
133 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service),
134 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
135 << "BleGattsRegisterCallbacks fail scenor";
136
137 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
138 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
139 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service),
140 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
141 << "BleGattsRegister fail scenor";
142
143 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
144 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
145 // 清空状态
146 SoftBusUnRegisterGattsCallbacks(service);
147 }
148
149 /**
150 * @tc.name: AdapterBleGattServerTest_SoftBusUnRegisterGattsCallbacks
151 * @tc.desc: test unregister gatt server callbacks
152 * @tc.type: FUNC
153 * @tc.require: NONE
154 */
155 HWTEST_F(AdapterBleGattServerTest, SoftBusUnRegisterGattsCallbacks, TestSize.Level3)
156 {
157 InitSoftbusAdapterServer();
158 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
159 SoftBusBtUuid service = {
160 .uuidLen = strlen(serviceUuid),
161 .uuid = (char *)serviceUuid,
162 };
163 MockBluetooth mocker;
164 MockAll(mocker);
165 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
166 SoftBusUnRegisterGattsCallbacks(service);
167 }
168
169 /**
170 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddService
171 * @tc.desc: test add gatt service
172 * @tc.type: FUNC
173 * @tc.require: NONE
174 */
175 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddService, TestSize.Level3)
176 {
177 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
178 SoftBusBtUuid service1 = {
179 .uuidLen = strlen(serviceUuid),
180 .uuid = (char *)serviceUuid,
181 };
182 MockBluetooth mocker;
183 MockAll(mocker);
184 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service1), SOFTBUS_OK);
185
186 // 注册service
187 SoftBusBtUuid service = {
188 .uuidLen = 0,
189 .uuid = nullptr,
190 };
191 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_INVALID_PARAM);
192
193 EXPECT_CALL(mocker, BleGattsAddService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
194 service.uuid = (char *)serviceUuid;
195 service.uuidLen = strlen(serviceUuid);
196 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR);
197
198 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
199 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_OK);
200 }
201
202 /**
203 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddCharacteristic
204 * @tc.desc: test add gatt characteristic
205 * @tc.type: FUNC
206 * @tc.require: NONE
207 */
208 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddCharacteristic, TestSize.Level3)
209 {
210 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
211 SoftBusBtUuid service = {
212 .uuidLen = strlen(serviceUuid),
213 .uuid = (char *)serviceUuid,
214 };
215 MockBluetooth mocker;
216 MockAll(mocker);
217 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
218
219 SoftBusBtUuid characteristic = {
220 .uuidLen = 0,
221 .uuid = nullptr,
222 };
223 int properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
224 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
225 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
226 int permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
227 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
228 SOFTBUS_INVALID_PARAM);
229
230 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
231 characteristic.uuid = (char *)netCharacteristic;
232 characteristic.uuidLen = strlen(netCharacteristic);
233 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
234 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
235 SOFTBUS_CONN_BLE_UNDERLAY_CHARACTERISTIC_ADD_ERR);
236
237 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
238 ASSERT_EQ(
239 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_OK);
240 }
241
242 /**
243 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddDescriptor
244 * @tc.desc: test add gatt descriptor
245 * @tc.type: FUNC
246 * @tc.require: NONE
247 */
248 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddDescriptor, TestSize.Level3)
249 {
250 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
251 SoftBusBtUuid service = {
252 .uuidLen = strlen(serviceUuid),
253 .uuid = (char *)serviceUuid,
254 };
255 MockBluetooth mocker;
256 MockAll(mocker);
257 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
258
259 SoftBusBtUuid desciptor = {
260 .uuidLen = 0,
261 .uuid = nullptr,
262 };
263 int permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
264 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_INVALID_PARAM);
265
266 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
267 desciptor.uuid = (char *)connDesciptor;
268 desciptor.uuidLen = strlen(connDesciptor);
269
270 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
271 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions),
272 SOFTBUS_CONN_BLE_UNDERLAY_DESCRIPTOR_ADD_ERR);
273 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
274 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_OK);
275 }
276
277 /**
278 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStartService
279 * @tc.desc: test start gatt service
280 * @tc.type: FUNC
281 * @tc.require: NONE
282 */
283 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStartService, TestSize.Level3)
284 {
285 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
286 SoftBusBtUuid service = {
287 .uuidLen = strlen(serviceUuid),
288 .uuid = (char *)serviceUuid,
289 };
290 MockBluetooth mocker;
291 MockAll(mocker);
292 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
293
294 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
295 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_START_ERR);
296
297 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
298 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
299 }
300
301 /**
302 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStopService
303 * @tc.desc: test stop gatt service
304 * @tc.type: FUNC
305 * @tc.require: NONE
306 */
307 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStopService, TestSize.Level3)
308 {
309 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
310 SoftBusBtUuid service = {
311 .uuidLen = strlen(serviceUuid),
312 .uuid = (char *)serviceUuid,
313 };
314 MockBluetooth mocker;
315 MockAll(mocker);
316 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
317
318 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
319 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_STOP_ERR);
320
321 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
322 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
323 }
324
325 /**
326 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDeleteService
327 * @tc.desc: test delete gatt service
328 * @tc.type: FUNC
329 * @tc.require: NONE
330 */
331 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDeleteService, TestSize.Level3)
332 {
333 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
334 SoftBusBtUuid service = {
335 .uuidLen = strlen(serviceUuid),
336 .uuid = (char *)serviceUuid,
337 };
338 MockBluetooth mocker;
339 MockAll(mocker);
340 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
341
342 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
343 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_DELETE_ERR);
344
345 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
346 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
347 }
348
349 /**
350 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDisconnect
351 * @tc.desc: test disconnect gatt connection
352 * @tc.type: FUNC
353 * @tc.require: NONE
354 */
355 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDisconnect, TestSize.Level3)
356 {
357 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
358 SoftBusBtUuid service = {
359 .uuidLen = strlen(serviceUuid),
360 .uuid = (char *)serviceUuid,
361 };
362 MockBluetooth mocker;
363 MockAll(mocker);
364 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
365
366 int connId = 1;
367 SoftBusBtAddr addr = {
368 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
369 };
370 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
371 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_DISCONNECT_ERR);
372
373 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
374 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_OK);
375 }
376
377 /**
378 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendResponse
379 * @tc.desc: test send gatt response
380 * @tc.type: FUNC
381 * @tc.require: NONE
382 */
383 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendResponse, TestSize.Level3)
384 {
385 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
386 SoftBusBtUuid service = {
387 .uuidLen = strlen(serviceUuid),
388 .uuid = (char *)serviceUuid,
389 };
390 MockBluetooth mocker;
391 MockAll(mocker);
392 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
393
394 SoftBusGattsResponse resp = {0};
395 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
396 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_RESPONSE_ERR);
397
398 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
399 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
400 }
401
402 /**
403 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendNotify
404 * @tc.desc: test send gatt notify
405 * @tc.type: FUNC
406 * @tc.require: NONE
407 */
408 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendNotify, TestSize.Level3)
409 {
410 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
411 SoftBusBtUuid service = {
412 .uuidLen = strlen(serviceUuid),
413 .uuid = (char *)serviceUuid,
414 };
415 MockBluetooth mocker;
416 MockAll(mocker);
417 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
418
419 SoftBusGattsNotify notify = {0};
420 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
421 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_INDICATION_ERR);
422
423 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
424 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
425 }
426
427 /**
428 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
429 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
430 * @tc.type: FUNC
431 * @tc.require: NONE
432 */
433 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle1, TestSize.Level3)
434 {
435 //注册service
436 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
437 SoftBusBtUuid service = {
438 .uuidLen = strlen(serviceUuid),
439 .uuid = (char *)serviceUuid,
440 };
441 MockBluetooth mocker;
442 MockAll(mocker);
443 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
444
445 ASSERT_EQ(SoftBusGattsAddService(service, true, 8), SOFTBUS_OK);
446 BtUuid btService = {
447 .uuidLen = strlen(serviceUuid),
448 .uuid = (char *)serviceUuid,
449 };
450 gattServerCallback->serviceAddCb(
451 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btService, MOCK_GATT_SERVICE_HANDLE);
452 ASSERT_TRUE(serviceAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, &service));
453
454 // 注册charateristic
455 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
456 SoftBusBtUuid characteristic = {
457 .uuidLen = strlen(netCharacteristic),
458 .uuid = (char *)netCharacteristic,
459 };
460 int properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
461 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
462 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
463 int charaPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
464 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, charaPermissions),
465 SOFTBUS_OK);
466 BtUuid btCharacteristic = {
467 .uuidLen = strlen(netCharacteristic),
468 .uuid = (char *)netCharacteristic,
469 };
470 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS,
471 MOCK_GATT_SERVER_HANDLE,
472 &btCharacteristic,
473 MOCK_GATT_SERVICE_HANDLE,
474 MOCK_GATT_CHARA_HANDLE);
475 ASSERT_TRUE(
476 characteristicAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_CHARA_HANDLE, &characteristic));
477 }
478
479 /**
480 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
481 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
482 * @tc.type: FUNC
483 * @tc.require: NONE
484 */
485 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle2, TestSize.Level3)
486 {
487 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
488 SoftBusBtUuid service = {
489 .uuidLen = strlen(serviceUuid),
490 .uuid = (char *)serviceUuid,
491 };
492 MockBluetooth mocker;
493 MockAll(mocker);
494 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
495
496 // 注册desciptor
497 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
498 int descriptorPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
499 SoftBusBtUuid descriptor = {
500 .uuidLen = strlen(connDesciptor),
501 .uuid = (char *)connDesciptor,
502 };
503 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, descriptor, descriptorPermissions), SOFTBUS_OK);
504 BtUuid btDescriptor = {
505 .uuidLen = strlen(connDesciptor),
506 .uuid = (char *)connDesciptor,
507 };
508 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS,
509 MOCK_GATT_SERVER_HANDLE,
510 &btDescriptor,
511 MOCK_GATT_SERVICE_HANDLE,
512 MOCK_GATT_DESCRIPTOR_HANDLE);
513 ASSERT_TRUE(
514 descriptorAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_DESCRIPTOR_HANDLE, &descriptor));
515
516 // 启动Listen
517 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
518 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
519 ASSERT_TRUE(serviceStartCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
520 }
521
522 /**
523 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
524 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
525 * @tc.type: FUNC
526 * @tc.require: NONE
527 */
528 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle3, TestSize.Level3)
529 {
530 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
531 SoftBusBtUuid service = {
532 .uuidLen = strlen(serviceUuid),
533 .uuid = (char *)serviceUuid,
534 };
535 MockBluetooth mocker;
536 MockAll(mocker);
537 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
538 // server建链
539 BdAddr bdAddr = {
540 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
541 };
542 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
543 SoftBusBtAddr addr = {
544 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
545 };
546 GetStubGattsCallback()->ConnectServerCallback(1, &addr);
547 ASSERT_TRUE(connectServerCtx.Expect(1, &addr));
548 // 读写数据，及响应回复
549 const char *valueExample = "hello gatt server, this is client";
550 BtReqWriteCbPara btWriteParam = {
551 .connId = 1,
552 .transId = 0,
553 .bdAddr = &bdAddr,
554 .attrHandle = MOCK_GATT_CHARA_HANDLE,
555 .offset = 0,
556 .length = strlen(valueExample),
557 .needRsp = true,
558 .isPrep = false,
559 .value = (unsigned char *)valueExample,
560 };
561 gattServerCallback->requestWriteCb(btWriteParam);
562 SoftBusGattWriteRequest writeParam = {
563 .connId = 1,
564 .transId = 0,
565 .btAddr = &addr,
566 .attrHandle = MOCK_GATT_CHARA_HANDLE,
567 .offset = 0,
568 .length = strlen(valueExample),
569 .needRsp = true,
570 .isPrep = false,
571 .value = (unsigned char *)valueExample,
572 };
573 GetStubGattsCallback()->RequestWriteCallback(writeParam);
574 ASSERT_TRUE(ExpectGattWriteRequest(requestWriteCtx, writeParam));
575 SoftBusGattsResponse resp = {0};
576 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
577 }
578
579 /**
580 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
581 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
582 * @tc.type: FUNC
583 * @tc.require: NONE
584 */
585 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle4, TestSize.Level3)
586 {
587 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
588 SoftBusBtUuid service = {
589 .uuidLen = strlen(serviceUuid),
590 .uuid = (char *)serviceUuid,
591 };
592 MockBluetooth mocker;
593 MockAll(mocker);
594 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
595 BdAddr bdAddr = {
596 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
597 };
598 SoftBusBtAddr addr = {
599 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
600 };
601 BtReqReadCbPara btReadParam = {
602 .connId = 1,
603 .transId = 0,
604 .bdAddr = &bdAddr,
605 .attrHandle = MOCK_GATT_CHARA_HANDLE,
606 .offset = 0,
607 .isLong = false,
608 };
609 gattServerCallback->requestReadCb(btReadParam);
610 SoftBusGattReadRequest readParam = {
611 .connId = 1,
612 .transId = 0,
613 .btAddr = &addr,
614 .attrHandle = MOCK_GATT_CHARA_HANDLE,
615 .offset = 0,
616 .isLong = false,
617 };
618 GetStubGattsCallback()->RequestReadCallback(readParam);
619 ASSERT_TRUE(ExpectGattReadRequest(requestReadCtx, readParam));
620 SoftBusGattsNotify notify = {0};
621 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
622
623 // server断链
624 ASSERT_EQ(SoftBusGattsDisconnect(addr, 1), SOFTBUS_OK);
625 gattServerCallback->disconnectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
626
627 // 停止GATT service
628 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
629 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
630 ASSERT_TRUE(serviceStopCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
631
632 // 删除GATT service
633 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
634 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
635 ASSERT_TRUE(serviceDeleteCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
636 }
637
BtUuidRecordCtx(const char * identifier)638 BtUuidRecordCtx::BtUuidRecordCtx(const char *identifier) : StRecordCtx(identifier)
639 {
640 Reset();
641 }
~BtUuidRecordCtx()642 BtUuidRecordCtx::~BtUuidRecordCtx()
643 {
644 Reset();
645 }
646
Reset()647 void BtUuidRecordCtx::Reset()
648 {
649 SoftBusFree(uuid.uuid);
650 uuid.uuid = nullptr;
651 uuid.uuidLen = 0;
652 }
653
Update(int id,int st,SoftBusBtUuid * param)654 bool BtUuidRecordCtx::Update(int id, int st, SoftBusBtUuid *param)
655 {
656 if (!StRecordCtx::Update(id, st)) {
657 return false;
658 }
659 uuid.uuid = (char *)SoftBusCalloc(param->uuidLen);
660 if (uuid.uuid == nullptr) {
661 return false;
662 }
663 if (memcpy_s(uuid.uuid, param->uuidLen, param->uuid, param->uuidLen) != EOK) {
664 return false;
665 }
666 uuid.uuidLen = param->uuidLen;
667 return true;
668 }
669
Expect(int id,int st,SoftBusBtUuid * param)670 testing::AssertionResult BtUuidRecordCtx::Expect(int id, int st, SoftBusBtUuid *param)
671 {
672 auto result = StRecordCtx::Expect(id, st);
673 if (!result) {
674 goto ClEANUP;
675 }
676 if (uuid.uuidLen != param->uuidLen || memcmp(uuid.uuid, param->uuid, uuid.uuidLen) != 0) {
677 result = testing::AssertionFailure() << identifier << " is call by unexpectedly uuid";
678 goto ClEANUP;
679 }
680 result = testing::AssertionSuccess();
681 ClEANUP:
682 Reset();
683 return result;
684 }
685
BtGattRecordCtx(const char * identifier)686 BtGattRecordCtx::BtGattRecordCtx(const char *identifier) : BtUuidRecordCtx(identifier)
687 {
688 handle = -1;
689 }
690
Update(int id,int st,int handleParam,SoftBusBtUuid * param)691 bool BtGattRecordCtx::Update(int id, int st, int handleParam, SoftBusBtUuid *param)
692 {
693 if (!BtUuidRecordCtx::Update(id, st, param)) {
694 return false;
695 }
696 this->handle = handleParam;
697 return true;
698 }
699
Expect(int id,int st,int handleParam,SoftBusBtUuid * param)700 testing::AssertionResult BtGattRecordCtx::Expect(int id, int st, int handleParam, SoftBusBtUuid *param)
701 {
702 auto result = BtUuidRecordCtx::Expect(id, st, param);
703 if (!result) {
704 goto ClEANUP;
705 }
706 if (this->handle != handleParam) {
707 result = testing::AssertionFailure() << identifier << " is call by unexpectedly state,"
708 << "want: " << handleParam << ", actual: " << this->handle;
709 goto ClEANUP;
710 }
711 result = testing::AssertionSuccess();
712 ClEANUP:
713 this->handle = -1;
714 return result;
715 }
716
717 BtGattServerCallbacks *AdapterBleGattServerTest::gattServerCallback = nullptr;
718 BtUuidRecordCtx AdapterBleGattServerTest::serviceAddCtx("ServiceAddCallback");
719 BtGattRecordCtx AdapterBleGattServerTest::characteristicAddCtx("CharacteristicAddCallback");
720 BtGattRecordCtx AdapterBleGattServerTest::descriptorAddCtx("DescriptorAddCallback");
721 StRecordCtx AdapterBleGattServerTest::serviceStartCtx("ServiceStartCallback");
722 StRecordCtx AdapterBleGattServerTest::serviceStopCtx("ServiceStopCallback");
723 StRecordCtx AdapterBleGattServerTest::serviceDeleteCtx("ServiceDeleteCallback");
724 BtAddrRecordCtx AdapterBleGattServerTest::connectServerCtx("ConnectServerCallback");
725 BtAddrRecordCtx AdapterBleGattServerTest::disconnectServerCtx("DisconnectServerCallback");
726 SoftBusGattReadRequest AdapterBleGattServerTest::requestReadCtx = {0};
727 SoftBusGattWriteRequest AdapterBleGattServerTest::requestWriteCtx = {0};
728 StRecordCtx AdapterBleGattServerTest::responseConfirmationCtx("ResponseConfirmationCallback");
729 StRecordCtx AdapterBleGattServerTest::notifySentCtx("NotifySentCallback");
730 StRecordCtx AdapterBleGattServerTest::mtuChangeCtx("MtuChangeCallback");
731
StubServiceAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle)732 static void StubServiceAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle)
733 {
734 AdapterBleGattServerTest::serviceAddCtx.Update(srvcHandle, status, uuid);
735 }
736
StubCharacteristicAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle,int characteristicHandle)737 static void StubCharacteristicAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle, int characteristicHandle)
738 {
739 AdapterBleGattServerTest::characteristicAddCtx.Update(srvcHandle, status, characteristicHandle, uuid);
740 }
741
StubDescriptorAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle,int descriptorHandle)742 static void StubDescriptorAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle, int descriptorHandle)
743 {
744 AdapterBleGattServerTest::descriptorAddCtx.Update(srvcHandle, status, descriptorHandle, uuid);
745 }
746
StubServiceStartCallback(int status,int srvcHandle)747 static void StubServiceStartCallback(int status, int srvcHandle)
748 {
749 AdapterBleGattServerTest::serviceStartCtx.Update(srvcHandle, status);
750 }
751
StubServiceStopCallback(int status,int srvcHandle)752 static void StubServiceStopCallback(int status, int srvcHandle)
753 {
754 AdapterBleGattServerTest::serviceStopCtx.Update(srvcHandle, status);
755 }
756
StubServiceDeleteCallback(int status,int srvcHandle)757 static void StubServiceDeleteCallback(int status, int srvcHandle)
758 {
759 AdapterBleGattServerTest::serviceDeleteCtx.Update(srvcHandle, status);
760 }
761
StubConnectServerCallback(int connId,const SoftBusBtAddr * btAddr)762 static void StubConnectServerCallback(int connId, const SoftBusBtAddr *btAddr)
763 {
764 AdapterBleGattServerTest::connectServerCtx.Update(connId, btAddr);
765 }
766
StubDisconnectServerCallback(int connId,const SoftBusBtAddr * btAddr)767 static void StubDisconnectServerCallback(int connId, const SoftBusBtAddr *btAddr)
768 {
769 AdapterBleGattServerTest::disconnectServerCtx.Update(connId, btAddr);
770 }
771
StubRequestReadCallback(SoftBusGattReadRequest readCbPara)772 static void StubRequestReadCallback(SoftBusGattReadRequest readCbPara)
773 {
774 AdapterBleGattServerTest::requestReadCtx = readCbPara;
775 }
776
StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)777 static void StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)
778 {
779 AdapterBleGattServerTest::requestWriteCtx = writeCbPara;
780 }
781
StubResponseConfirmationCallback(int status,int handle)782 static void StubResponseConfirmationCallback(int status, int handle)
783 {
784 AdapterBleGattServerTest::responseConfirmationCtx.Update(handle, status);
785 }
StubNotifySentCallback(int connId,int status)786 static void StubNotifySentCallback(int connId, int status)
787 {
788 AdapterBleGattServerTest::notifySentCtx.Update(connId, status);
789 }
StubMtuChangeCallback(int connId,int mtu)790 static void StubMtuChangeCallback(int connId, int mtu)
791 {
792 AdapterBleGattServerTest::mtuChangeCtx.Update(connId, mtu);
793 }
794
GetStubGattsCallback()795 static SoftBusGattsCallback *GetStubGattsCallback()
796 {
797 static SoftBusGattsCallback callbacks = {
798 .ServiceAddCallback = StubServiceAddCallback,
799 .CharacteristicAddCallback = StubCharacteristicAddCallback,
800 .DescriptorAddCallback = StubDescriptorAddCallback,
801 .ServiceStartCallback = StubServiceStartCallback,
802 .ServiceStopCallback = StubServiceStopCallback,
803 .ServiceDeleteCallback = StubServiceDeleteCallback,
804 .ConnectServerCallback = StubConnectServerCallback,
805 .DisconnectServerCallback = StubDisconnectServerCallback,
806 .RequestReadCallback = StubRequestReadCallback,
807 .RequestWriteCallback = StubRequestWriteCallback,
808 .ResponseConfirmationCallback = StubResponseConfirmationCallback,
809 .NotifySentCallback = StubNotifySentCallback,
810 .MtuChangeCallback = StubMtuChangeCallback,
811 };
812 return &callbacks;
813 }
814
ExpectGattWriteRequest(SoftBusGattWriteRequest actual,SoftBusGattWriteRequest want)815 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want)
816 {
817 if (want.connId != actual.connId || want.transId != actual.transId ||
818 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 || want.attrHandle != actual.attrHandle ||
819 want.offset != actual.offset || want.length != actual.length ||
820 !(want.needRsp ? actual.needRsp : !actual.needRsp) || !(want.isPrep ? actual.isPrep : !actual.isPrep) ||
821 memcmp(want.value, actual.value, want.length) != 0) {
822 return testing::AssertionFailure() << "SoftBusGattWriteRequest is unexpected";
823 }
824 return testing::AssertionSuccess();
825 }
826
ExpectGattReadRequest(SoftBusGattReadRequest actual,SoftBusGattReadRequest want)827 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want)
828 {
829 if (want.connId != actual.connId || want.transId != actual.transId ||
830 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 || want.attrHandle != actual.attrHandle ||
831 want.offset != actual.offset || !(want.isLong ? actual.isLong : !actual.isLong)) {
832 return testing::AssertionFailure() << "SoftBusGattReadRequest is unexpected";
833 }
834 return testing::AssertionSuccess();
835 }
836
837 } // namespace OHOS