1 /*
2 * Copyright (c) 2021-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 "softbus_conn_ble_connection_mock.h"
17
18 #include <cstdio>
19 #include <cstring>
20
21 #include <gtest/gtest.h>
22 #include <securec.h>
23
24 #include "common_list.h"
25 #include "conn_log.h"
26 #include "softbus_conn_interface.h"
27 #include "softbus_conn_manager.h"
28 #include "softbus_adapter_ble_gatt_server.h"
29 #include "softbus_def.h"
30 #include "softbus_error_code.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_adapter_bt_common.h"
34 #include "softbus_conn_ble_server.h"
35 #include "softbus_conn_ble_client.h"
36 #include "softbus_conn_ble_manager.h"
37 #include "softbus_conn_ble_connection.h"
38 #include "softbus_utils.h"
39
40 using namespace testing::ext;
41 using namespace testing;
42 using namespace std;
43
44 namespace OHOS {
45
46 SoftBusGattsCallback *g_callback = nullptr;
47
48 extern "C" {
SoftBusRegisterGattsCallbacks(SoftBusGattsCallback * callback,SoftBusBtUuid serviceUuid)49 int32_t SoftBusRegisterGattsCallbacks(SoftBusGattsCallback *callback, SoftBusBtUuid serviceUuid)
50 {
51 (void)serviceUuid;
52 g_callback = callback;
53 return SOFTBUS_OK;
54 }
55 }
56
57 class ServiceConnectionTest : public testing::Test {
58 public:
59 static void SetUpTestCase();
TearDownTestCase()60 static void TearDownTestCase() {}
SetUp()61 void SetUp() override {}
TearDown()62 void TearDown() override {}
63 };
64
SetUpTestCase()65 void ServiceConnectionTest::SetUpTestCase()
66 {
67 LooperInit();
68 SoftbusConfigInit();
69 ConnServerInit();
70 }
71
72 /*
73 * @tc.name: ServiceConnection001
74 * @tc.desc: Test ConnGattServerStartService.
75 * @tc.in: Test module, Test number, Test Levels.
76 * @tc.out: Zero
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(ServiceConnectionTest, ServiceConnection001, TestSize.Level1)
81 {
82 int32_t ret;
83 NiceMock<ConnectionBleInterfaceMock> bleMock;
84 EXPECT_CALL(bleMock, SoftBusGattsAddService(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
85 ret = ConnGattServerStartService();
86 EXPECT_EQ(SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR, ret);
87 }
88
89 /*
90 * @tc.name: ServiceConnection002
91 * @tc.desc: Test ConnGattServerStopService.
92 * @tc.in: Test module, Test number, Test Levels.
93 * @tc.out: Zero
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(ServiceConnectionTest, ServiceConnection002, TestSize.Level1)
98 {
99 int32_t ret;
100 NiceMock<ConnectionBleInterfaceMock> bleMock;
101 EXPECT_CALL(bleMock, SoftBusGattsStopService).WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_STOP_ERR));
102 ret = ConnGattServerStopService();
103 EXPECT_EQ(SOFTBUS_OK, ret);
104 }
105
106 /*
107 * @tc.name: ServiceConnection003
108 * @tc.desc: Test ConnGattServerDisconnect.
109 * @tc.in: Test module, Test number, Test Levels.
110 * @tc.out: Zero
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(ServiceConnectionTest, ServiceConnection003, TestSize.Level1)
115 {
116 int32_t ret;
117 ConnBleConnection connection;
118 NiceMock<ConnectionBleInterfaceMock> bleMock;
119
120 ret = ConnGattServerDisconnect(nullptr);
121 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
122
123 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
124 connection.connectionId = 1;
125 SoftBusMutexInit(&connection.lock, nullptr);
126 ret = ConnGattServerDisconnect(&connection);
127 EXPECT_EQ(SOFTBUS_OK, ret);
128
129 connection.underlayerHandle = 1;
130 connection.connectionId = 1;
131 SoftBusMutexInit(&connection.lock, nullptr);
132 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
133 ret = ConnGattServerDisconnect(&connection);
134 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
135
136 SoftBusMutexInit(&connection.lock, nullptr);
137 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
138 EXPECT_CALL(bleMock, SoftBusGattsDisconnect).WillRepeatedly(Return(SOFTBUS_MEM_ERR));
139 ret = ConnGattServerDisconnect(&connection);
140 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
141
142 SoftBusMutexInit(&connection.lock, nullptr);
143 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
144 EXPECT_CALL(bleMock, SoftBusGattsDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
145 ret = ConnGattServerDisconnect(&connection);
146 EXPECT_EQ(SOFTBUS_OK, ret);
147 }
148
149 /*
150 * @tc.name: ServiceConnection004
151 * @tc.desc: Test ConnGattServerConnect.
152 * @tc.in: Test module, Test number, Test Levels.
153 * @tc.out: Zero
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(ServiceConnectionTest, ServiceConnection004, TestSize.Level1)
158 {
159 int32_t ret;
160 SoftBusGattWriteRequest writeCbPara;
161 ConnBleConnection connection;
162 (void)memset_s(&connection, sizeof(ConnBleConnection), 0, sizeof(ConnBleConnection));
163 writeCbPara.needRsp = true;
164 g_callback->requestWriteCallback(writeCbPara);
165 ret = ConnGattServerConnect(&connection);
166 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
167
168 writeCbPara.needRsp = false;
169 writeCbPara.attrHandle = -1;
170 g_callback->requestWriteCallback(writeCbPara);
171 ret = SoftBusMutexInit(&connection.lock, nullptr);
172 EXPECT_EQ(SOFTBUS_OK, ret);
173
174 writeCbPara.needRsp = false;
175 writeCbPara.attrHandle = 1;
176 writeCbPara.connId = 1;
177 g_callback->requestWriteCallback(writeCbPara);
178 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
179 ret = ConnGattServerConnect(&connection);
180 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
181 }
182
183 /*
184 * @tc.name: ClientConnection001
185 * @tc.desc: Test ConnGattClientConnect.
186 * @tc.in: Test module, Test number, Test Levels.
187 * @tc.out: Zero
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ServiceConnectionTest, ClientConnection001, TestSize.Level1)
192 {
193 int32_t ret;
194 ConnBleConnection connection;
195 NiceMock<ConnectionBleInterfaceMock> bleMock;
196
197 ret = ConnGattClientConnect(nullptr);
198 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
199
200 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
201 ret = ConnGattClientConnect(&connection);
202 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
203
204 connection.fastestConnectEnable = true;
205 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
206 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
207 ret = ConnGattClientConnect(&connection);
208 EXPECT_EQ(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR, ret);
209
210 SoftBusMutexInit(&connection.lock, nullptr);
211 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
212 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_OK));
213 ret = ConnGattClientConnect(&connection);
214 EXPECT_EQ(SOFTBUS_OK, ret);
215 }
216
217 /*
218 * @tc.name: ClientConnection002
219 * @tc.desc: Test SwitchNotifacatedHandler.
220 * @tc.in: Test module, Test number, Test Levels.
221 * @tc.out: Zero
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(ServiceConnectionTest, ClientConnection002, TestSize.Level1)
226 {
227 int32_t ret;
228 ConnBleConnection connection;
229 bool grace = true;
230 bool refreshGatt = true;
231 NiceMock<ConnectionBleInterfaceMock> bleMock;
232
233 ret = ConnGattClientDisconnect(nullptr, grace, refreshGatt);
234 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
235
236 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
237 connection.connectionId = 1;
238 SoftBusMutexInit(&connection.lock, nullptr);
239 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
240 EXPECT_EQ(SOFTBUS_OK, ret);
241
242 connection.underlayerHandle = 1;
243 connection.connectionId = 1;
244 SoftBusMutexInit(&connection.lock, nullptr);
245 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
246 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
247 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
248
249 connection.underlayerHandle = 1;
250 connection.connectionId = 1;
251 SoftBusMutexInit(&connection.lock, nullptr);
252 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
253 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
254 EXPECT_EQ(SOFTBUS_OK, ret);
255 }
256
257 /*
258 * @tc.name: ClientConnection003
259 * @tc.desc: Test ConnGattClientUpdatePriority.
260 * @tc.in: Test module, Test number, Test Levels.
261 * @tc.out: Zero
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(ServiceConnectionTest, ClientConnection003, TestSize.Level1)
266 {
267 int32_t underlayerHandle = 1;
268 const char *bleMac = "11:22:33:44:55:66";
269 ConnBleConnection *connection =
270 ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, underlayerHandle, false);
271 ASSERT_NE(nullptr, connection);
272 NiceMock<ConnectionBleInterfaceMock> bleMock;
273
274 ConnectBlePriority priority = CONN_BLE_PRIORITY_BALANCED;
275 int32_t ret = ConnGattClientUpdatePriority(nullptr, priority);
276 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
277
278 connection->connectionId = 1;
279 connection->state = BLE_CONNECTION_STATE_CONNECTING;
280 ret = ConnGattClientUpdatePriority(connection, priority);
281 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
282
283 connection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
284 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
285 ret = ConnGattClientUpdatePriority(connection, priority);
286 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
287
288 connection->state = BLE_CONNECTION_STATE_CONNECTED;
289 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
290 EXPECT_CALL(bleMock, BleGattcSetPriority).WillRepeatedly(Return(SOFTBUS_OK));
291 for (int32_t i = 0; i <= 3; i++) {
292 ret = ConnGattClientUpdatePriority(connection, (ConnectBlePriority)i);
293 if (i == 3) {
294 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
295 break;
296 }
297 EXPECT_EQ(SOFTBUS_OK, ret);
298 }
299 }
300
301 /*
302 * @tc.name: ConnGattClientDisconnect001
303 * @tc.desc: Test ConnGattClientDisconnect.
304 * @tc.in: Test module, Test number, Test Levels.
305 * @tc.out: Zero
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(ServiceConnectionTest, ConnGattClientDisconnect001, TestSize.Level1)
310 {
311 ConnBleConnection bleConnection = {{0}};
312 int32_t ret = ConnGattClientDisconnect(&bleConnection, false, false);
313 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
314
315 const char *bleMac = "11:22:33:44:55:66";
316
317 ConnBleConnection *connection =
318 ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
319 ASSERT_NE(nullptr, connection);
320
321 connection->featureBitSet = (false ? (1 << BLE_FEATURE_SUPPORT_SUPPORT_NETWORKID_BASICINFO_EXCAHNGE) : 0);
322 connection->psm = 10;
323
324 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
325 ret = ConnBleSaveConnection(connection);
326 ASSERT_EQ(SOFTBUS_OK, ret);
327 ret = ConnGattClientDisconnect(connection, false, false);
328 EXPECT_EQ(SOFTBUS_OK, ret);
329 SoftBusSleepMs(500);
330 }
331
332 /*
333 * @tc.name: ConnGattClientDisconnect002
334 * @tc.desc: Test ConnGattClientDisconnect.
335 * @tc.in: Test module, Test number, Test Levels.
336 * @tc.out: Zero
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(ServiceConnectionTest, ConnGattClientDisconnect002, TestSize.Level1)
341 {
342 ConnBleConnection bleConnection = {{0}};
343 int32_t ret = ConnGattClientDisconnect(&bleConnection, false, false);
344 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
345
346 const char *bleMac = "11:22:33:44:55:66";
347
348 ConnBleConnection *connection =
349 ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
350 ASSERT_NE(nullptr, connection);
351
352 connection->featureBitSet = (false ? (1 << BLE_FEATURE_SUPPORT_SUPPORT_NETWORKID_BASICINFO_EXCAHNGE) : 0);
353 connection->psm = 10;
354
355 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
356 connection->underlayerHandle = 1;
357 ret = ConnBleSaveConnection(connection);
358 ASSERT_EQ(SOFTBUS_OK, ret);
359
360 NiceMock<ConnectionBleInterfaceMock> bleMock;
361 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
362 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
363 ret = ConnGattClientDisconnect(connection, false, false);
364 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
365
366 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
367 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
368 ret = ConnGattClientDisconnect(connection, false, false);
369 EXPECT_EQ(SOFTBUS_OK, ret);
370
371 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
372 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
373 ret = ConnGattClientDisconnect(connection, true, false);
374 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
375
376 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
377 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
378 ret = ConnGattClientDisconnect(connection, true, false);
379 EXPECT_EQ(SOFTBUS_OK, ret);
380
381 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
382 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_OK));
383 ret = ConnGattClientDisconnect(connection, true, false);
384 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
385 }
386
387 /*
388 * @tc.name: ConnGattClientSend
389 * @tc.desc: Test ConnGattClientSend.
390 * @tc.in: Test module, Test number, Test Levels.
391 * @tc.out: Zero
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(ServiceConnectionTest, ConnGattClientSend, TestSize.Level1)
396 {
397 ConnBleConnection bleConnection = {{0}};
398
399 int32_t ret = SoftBusMutexInit(&bleConnection.lock, nullptr);
400 ASSERT_EQ(SOFTBUS_OK, ret);
401 bleConnection.connectionId = 10;
402 bleConnection.underlayerHandle = 0;
403 uint8_t data[] = "testdata";
404 uint32_t dataLen = sizeof(data);
405 ret = ConnGattClientSend(&bleConnection, data, dataLen, MODULE_BLE_NET);
406 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
407
408 ret = ConnGattClientSend(&bleConnection, data, dataLen, MODULE_BLE_CONN);
409 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
410 }
411
412 /*
413 * @tc.name: ServiceStopCallback 001
414 * @tc.desc: Test ServiceStopCallback.
415 * @tc.in: Test module, Test number, Test Levels.
416 * @tc.out: Zero
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(ServiceConnectionTest, ServiceStopCallback001, TestSize.Level1)
421 {
422 g_callback->serviceStopCallback(SOFTBUS_INVALID_PARAM, 1);
423 SoftBusSleepMs(500);
424 g_callback->serviceStopCallback(SOFTBUS_OK, 2);
425 SoftBusSleepMs(500);
426
427 SoftBusBtUuid uuid = {
428 .uuidLen = strlen(SOFTBUS_SERVICE_UUID),
429 };
430 uuid.uuid = (char *)SoftBusCalloc(uuid.uuidLen+1);
431 ASSERT_NE(nullptr, uuid.uuid);
432 int32_t ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
433 EXPECT_EQ(EOK, ret);
434 g_callback->serviceAddCallback(SOFTBUS_OK, &uuid, 10);
435 SoftBusSleepMs(500);
436
437 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
438 EXPECT_EQ(EOK, ret);
439 g_callback->serviceAddCallback(SOFTBUS_OK, &uuid, 10);
440 SoftBusSleepMs(500);
441
442 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_SERVICE_UUID);
443 EXPECT_EQ(EOK, ret);
444 g_callback->serviceAddCallback(SOFTBUS_INVALID_PARAM, &uuid, 10);
445 SoftBusSleepMs(500);
446
447 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_SERVICE_UUID);
448 EXPECT_EQ(EOK, ret);
449 g_callback->serviceAddCallback(SOFTBUS_OK, &uuid, 10);
450
451 g_callback->serviceAddCallback(SOFTBUS_OK, &uuid, 1);
452
453 g_callback->serviceStopCallback(SOFTBUS_OK, 3);
454
455 g_callback->serviceDeleteCallback(SOFTBUS_INVALID_PARAM, 1);
456 g_callback->serviceDeleteCallback(SOFTBUS_OK, 1);
457 const char *bleAddr = "12:22:33:44:55:66";
458
459 SoftBusBtAddr addr = {
460 .addr = {0x12, 0x22, 0x33, 0x44, 0x55, 0x66},
461 };
462 ConnBleConnection *connection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_SERVER, 1, false);
463 EXPECT_NE(nullptr, connection);
464 g_callback->connectServerCallback(connection->underlayerHandle, &addr);
465 SoftBusSleepMs(500);
466 }
467
468 /*
469 * @tc.name: ServiceStopCallback 001
470 * @tc.desc: Test ServiceStopCallback.
471 * @tc.in: Test module, Test number, Test Levels.
472 * @tc.out: Zero
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(ServiceConnectionTest, ServiceDeleteCallback, TestSize.Level1)
477 {
478 SoftBusBtAddr addr = {
479 .addr = {0x13, 0x23, 0x33, 0x43, 0x53, 0x63},
480 };
481 g_callback->disconnectServerCallback(20, &addr);
482
483 const char *bleAddr = "13:23:33:43:53:63";
484 ConnBleConnection *connection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_SERVER, 11, false);
485 EXPECT_NE(nullptr, connection);
486 int32_t ret = ConnBleSaveConnection(connection);
487 ASSERT_EQ(SOFTBUS_OK, ret);
488 g_callback->disconnectServerCallback(connection->underlayerHandle, &addr);
489 SoftBusGattReadRequest readCbPara = {
490 .connId = 1,
491 .transId = 1,
492 };
493 g_callback->requestReadCallback(readCbPara);
494 g_callback->responseConfirmationCallback(SOFTBUS_OK, 1);
495 g_callback->notifySentCallback(1, SOFTBUS_OK);
496 g_callback->mtuChangeCallback(4, 5);
497
498 const char *bleMac = "15:25:35:45:55:65";
499 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_SERVER, 20, false);
500 EXPECT_NE(nullptr, bleConnection);
501 ret = ConnBleSaveConnection(bleConnection);
502 ASSERT_EQ(SOFTBUS_OK, ret);
503 g_callback->mtuChangeCallback(bleConnection->underlayerHandle, 5);
504 SoftBusSleepMs(500);
505 }
506
507 /*
508 * @tc.name: ServiceStopCallback 001
509 * @tc.desc: Test ServiceStopCallback.
510 * @tc.in: Test module, Test number, Test Levels.
511 * @tc.out: Zero
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(ServiceConnectionTest, ServiceAttrHandleCallback, TestSize.Level1)
516 {
517 int32_t effectHandle = -1;
518 int32_t invalidAttrHandle = 11;
519 int32_t invalidSrvcHandle = 10;
520 bool ret = g_callback->isConcernedAttrHandle(invalidSrvcHandle, invalidAttrHandle);
521 EXPECT_EQ(false, ret);
522 ret = g_callback->isConcernedAttrHandle(effectHandle, invalidAttrHandle);
523 EXPECT_EQ(false, ret);
524 ret = g_callback->isConcernedAttrHandle(effectHandle, effectHandle);
525 EXPECT_EQ(true, ret);
526 SoftBusSleepMs(500);
527 }
528 }