1 /*
2 * Copyright (c) 2025 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 #include "ble_send_manager_test.h"
16 #include "bluetooth_errorcode.h"
17 #include "c_header/ohos_bt_gatt.h"
18 #include "mechbody_controller_log.h"
19 #include "test_log.h"
20 #include <chrono>
21 #include <thread>
22 #include <atomic>
23 #include "uuid.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS;
28
29 namespace OHOS {
30 namespace MechBodyController {
31 namespace {
32 constexpr int32_t BLE_REVEVICE_LISTENER_SIZE = 1;
33 constexpr size_t NOTIFY_DATA_MAX_SIZE = 1024 * 1024;
34 BleSendManager& bleSendManager_ = BleSendManager::GetInstance();
35 using namespace OHOS::Bluetooth;
36 constexpr int32_t ERROR_NO_LISTENERS = -10001;
37 constexpr int32_t ERROR_INVALID_PARAMETER = -10002;
38 constexpr int32_t MECHBODY_GATT_INVALID_PARAM = -10003;
39 static const int32_t ERROR_SIZE_TOO_LARGE = -10004;
40 constexpr int32_t MECHBODY_GATT_CONNECT_FAILED = -10005;
41 constexpr int32_t BUF_MIN_LEN = 8;
42 constexpr int32_t BUF_LESS_THAN_MIN_LEN = 5;
43 constexpr int32_t BUF_GREATER_THAN_MAX_LEN = 252;
44 constexpr int32_t ERROR_INVALID_PARAMETERS = 2901003;
45 UUID MECHBODY_CHARACTERISTIC_NOTIFY_UUID = UUID::FromString("15f1e603-a277-43fc-a484-dd39ef8a9100"); // notify uuid
46 }
47
48 class MyBleReceiveListener : public BleReceviceListener {
49 public:
MyBleReceiveListener()50 MyBleReceiveListener() {}
51
OnReceive(const uint8_t * data,uint32_t dataLen)52 int32_t OnReceive(const uint8_t *data, uint32_t dataLen) override
53 {
54 return ERR_OK;
55 }
~MyBleReceiveListener()56 virtual ~MyBleReceiveListener() {}
57 };
58
SetUpTestCase()59 void BleSendManagerTest::SetUpTestCase()
60 {
61 DTEST_LOG << "BleSendManagerTest::SetUpTestCase" << std::endl;
62 }
63
TearDownTestCase()64 void BleSendManagerTest::TearDownTestCase()
65 {
66 DTEST_LOG << "BleSendManagerTest::TearDownTestCase" << std::endl;
67 }
68
TearDown()69 void BleSendManagerTest::TearDown()
70 {
71 DTEST_LOG << "BleSendManagerTest::TearDown" << std::endl;
72 }
73
SetUp()74 void BleSendManagerTest::SetUp()
75 {
76 DTEST_LOG << "BleSendManagerTest::SetUp" << std::endl;
77 }
78
79 /**
80 * @tc.name : InitScanPara_001
81 * @tc.number: InitScanPara_001
82 * @tc.desc : InitScanPara is correctly initializes the scan parameters.
83 */
84 HWTEST_F(BleSendManagerTest, InitScanPara_001, TestSize.Level1)
85 {
86 DTEST_LOG << "BleSendManagerTest InitScanPara_001 begin" << std::endl;
87 bleSendManager_.InitScanPara();
88
89 EXPECT_EQ(bleSendManager_.scanParam_.settings.GetScanMode(), BleScanMode::OHOS_BLE_SCAN_MODE_LOW_POWER);
90
91 EXPECT_EQ(bleSendManager_.scanParam_.filters.size(), BLE_REVEVICE_LISTENER_SIZE);
92
93 EXPECT_NE(bleSendManager_.bleCentralManager_, nullptr);
94 DTEST_LOG << "BleSendManagerTest InitScanPara_001 end" << std::endl;
95 }
96
97 /**
98 * @tc.name : StartScan_001
99 * @tc.number: StartScan_001
100 * @tc.desc : StartScan when bleCentralManager_ is null.
101 */
102 HWTEST_F(BleSendManagerTest, StartScan_001, TestSize.Level1)
103 {
104 DTEST_LOG << "BleSendManagerTest StartScan_001 begin" << std::endl;
105 bleSendManager_.bleCentralManager_ = nullptr;
106 EXPECT_NO_FATAL_FAILURE(bleSendManager_.StartScan());
107 DTEST_LOG << "BleSendManagerTest StartScan_001 end" << std::endl;
108 }
109
110 /**
111 * @tc.name : StartScan_002
112 * @tc.number: StartScan_002
113 * @tc.desc : StartScan when bleCentralManager_ is not null.
114 */
115 HWTEST_F(BleSendManagerTest, StartScan_002, TestSize.Level1)
116 {
117 DTEST_LOG << "BleSendManagerTest StartScan_001 begin" << std::endl;
118 std::shared_ptr<BleCentralManagerCallbackImpl> bleCentralManagerCallback =
119 std::make_shared<BleCentralManagerCallbackImpl>();
120 bleSendManager_.bleCentralManager_ = std::make_shared<Bluetooth::BleCentralManager>(bleCentralManagerCallback);
121 EXPECT_NO_FATAL_FAILURE(bleSendManager_.StartScan());
122 DTEST_LOG << "BleSendManagerTest StartScan_002 end" << std::endl;
123 }
124
125 /**
126 * @tc.name : StopScan_001
127 * @tc.number: StopScan_001
128 * @tc.desc : StopScan when bleCentralManager_ is null.
129 */
130 HWTEST_F(BleSendManagerTest, StopScan_001, TestSize.Level1)
131 {
132 DTEST_LOG << "BleSendManagerTest StopScan_001 begin" << std::endl;
133 bleSendManager_.bleCentralManager_ = nullptr;
134 EXPECT_NO_FATAL_FAILURE(bleSendManager_.StopScan());
135 DTEST_LOG << "BleSendManagerTest StopScan_001 end" << std::endl;
136 }
137
138 /**
139 * @tc.name : StopScan_002
140 * @tc.number: StopScan_002
141 * @tc.desc : StopScan when bleCentralManager_ is not null.
142 */
143 HWTEST_F(BleSendManagerTest, StopScan_002, TestSize.Level1)
144 {
145 DTEST_LOG << "BleSendManagerTest StopScan_002 begin" << std::endl;
146 std::shared_ptr<BleCentralManagerCallbackImpl> bleCentralManagerCallback =
147 std::make_shared<BleCentralManagerCallbackImpl>();
148 bleSendManager_.bleCentralManager_ = std::make_shared<Bluetooth::BleCentralManager>(bleCentralManagerCallback);
149 EXPECT_NO_FATAL_FAILURE(bleSendManager_.StopScan());
150 DTEST_LOG << "BleSendManagerTest StopScan_002 end" << std::endl;
151 }
152
153 /**
154 * @tc.name : OnReceive_001
155 * @tc.number: OnReceive_001
156 * @tc.desc : OnReceive should return ERROR_INVALID_PARAMETER when data is nullptr.
157 */
158 HWTEST_F(BleSendManagerTest, OnReceive_001, TestSize.Level1)
159 {
160 DTEST_LOG << "BleSendManagerTest OnReceive_001 begin" << std::endl;
161 uint8_t* data = nullptr;
162 size_t size = 10;
163 EXPECT_EQ(bleSendManager_.OnReceive(data, size), ERROR_INVALID_PARAMETER);
164 DTEST_LOG << "BleSendManagerTest OnReceive_001 end" << std::endl;
165 }
166
167 /**
168 * @tc.name : OnReceive_002
169 * @tc.number: OnReceive_002
170 * @tc.desc : OnReceive should return ERROR_INVALID_PARAMETER when size is zero.
171 */
172 HWTEST_F(BleSendManagerTest, OnReceive_002, TestSize.Level1)
173 {
174 DTEST_LOG << "BleSendManagerTest OnReceive_002 begin" << std::endl;
175 uint8_t data[10] = {0};
176 size_t size = 0;
177 EXPECT_EQ(bleSendManager_.OnReceive(data, size), ERROR_INVALID_PARAMETER);
178 DTEST_LOG << "BleSendManagerTest OnReceive_002 end" << std::endl;
179 }
180
181 /**
182 * @tc.name : OnReceive_003
183 * @tc.number: OnReceive_003
184 * @tc.desc : OnReceive should return ERROR_SIZE_TOO_LARGE when size exceeds NOTIFY_DATA_MAX_SIZE.
185 */
186 HWTEST_F(BleSendManagerTest, OnReceive_003, TestSize.Level1)
187 {
188 DTEST_LOG << "BleSendManagerTest OnReceive_003 begin" << std::endl;
189 uint8_t data[NOTIFY_DATA_MAX_SIZE + 1] = {0};
190 size_t size = NOTIFY_DATA_MAX_SIZE + 1;
191 EXPECT_EQ(bleSendManager_.OnReceive(data, size), ERROR_SIZE_TOO_LARGE);
192 DTEST_LOG << "BleSendManagerTest OnReceive_003 end" << std::endl;
193 }
194
195
196 /**
197 * @tc.name : OnReceive_004
198 * @tc.number: OnReceive_004
199 * @tc.desc : Test when bleReceviceListeners_ is empty, OnReceive should return ERROR_NO_LISTENERS
200 */
201 HWTEST_F(BleSendManagerTest, OnReceive_004, TestSize.Level1)
202 {
203 DTEST_LOG << "BleSendManagerTest OnReceive_004 begin" << std::endl;
204 uint8_t data[10] = {0};
205 size_t size = 10;
206 EXPECT_EQ(bleSendManager_.OnReceive(data, size), ERROR_NO_LISTENERS);
207 DTEST_LOG << "BleSendManagerTest OnReceive_004 end" << std::endl;
208 }
209
210 /**
211 * @tc.name : OnReceive_005
212 * @tc.number: OnReceive_005
213 * @tc.desc : Test when bleReceviceListeners_ contains nullptr, OnReceive should return ERROR_NO_LISTENERS
214 */
215 HWTEST_F(BleSendManagerTest, OnReceive_005, TestSize.Level1)
216 {
217 DTEST_LOG << "BleSendManagerTest OnReceive_005 begin" << std::endl;
218 uint8_t data[10] = {0};
219 size_t size = 10;
220 bleSendManager_.bleReceviceListeners_.push_back(nullptr);
221 EXPECT_EQ(bleSendManager_.OnReceive(data, size), ERROR_NO_LISTENERS);
222 DTEST_LOG << "BleSendManagerTest OnReceive_005 end" << std::endl;
223 }
224
225 /**
226 * @tc.name : CheckGattcIsReady_001
227 * @tc.number: CheckGattcIsReady_001
228 * @tc.desc : CheckGattcIsReady when isGattReady_ is true.
229 */
230 HWTEST_F(BleSendManagerTest, CheckGattcIsReady_001, TestSize.Level1)
231 {
232 DTEST_LOG << "BleSendManagerTest CheckGattcIsReady_001 begin" << std::endl;
233 bleSendManager_.isGattReady_ = true;
234 EXPECT_TRUE(bleSendManager_.CheckGattcIsReady());
235 DTEST_LOG << "BleSendManagerTest CheckGattcIsReady_001 end" << std::endl;
236 }
237
238 /**
239 * @tc.name : CheckGattcIsReady_002
240 * @tc.number: CheckGattcIsReady_002
241 * @tc.desc : CheckGattcIsReady when isGattReady_ is false.
242 */
243 HWTEST_F(BleSendManagerTest, CheckGattcIsReady_002, TestSize.Level1)
244 {
245 DTEST_LOG << "BleSendManagerTest CheckGattcIsReady_002 begin" << std::endl;
246 bleSendManager_.isGattReady_ = false;
247 EXPECT_FALSE(bleSendManager_.CheckGattcIsReady());
248 DTEST_LOG << "BleSendManagerTest CheckGattcIsReady_002 end" << std::endl;
249 }
250
251 /**
252 * @tc.name : RegisterTransportSendAdapter_001
253 * @tc.number: RegisterTransportSendAdapter_001
254 * @tc.desc : RegisterTransportSendAdapter registering a listener that already exists in the list.
255 */
256 HWTEST_F(BleSendManagerTest, RegisterTransportSendAdapter_001, TestSize.Level1)
257 {
258 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_001 begin" << std::endl;
259 auto listener = std::make_shared<MyBleReceiveListener>();
260 bleSendManager_.bleReceviceListeners_.push_back(listener);
261 int32_t result = bleSendManager_.RegisterTransportSendAdapter(listener);
262 EXPECT_EQ(result, ERR_OK);
263 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_001 end" << std::endl;
264 }
265
266 /**
267 * @tc.name : RegisterTransportSendAdapter_002
268 * @tc.number: RegisterTransportSendAdapter_002
269 * @tc.desc : RegisterTransportSendAdapter registering a listener that does not exist in the list.
270 */
271 HWTEST_F(BleSendManagerTest, RegisterTransportSendAdapter_002, TestSize.Level1)
272 {
273 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_002 begin" << std::endl;
274 auto listener = std::make_shared<MyBleReceiveListener>();
275 int32_t result = bleSendManager_.RegisterTransportSendAdapter(listener);
276 EXPECT_EQ(result, ERR_OK);
277 EXPECT_NE(std::find(bleSendManager_.bleReceviceListeners_.begin(),
278 bleSendManager_.bleReceviceListeners_.end(), listener), bleSendManager_.bleReceviceListeners_.end());
279 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_002 end" << std::endl;
280 }
281
282 /**
283 * @tc.name : RegisterTransportSendAdapter_003
284 * @tc.number: RegisterTransportSendAdapter_003
285 * @tc.desc : RegisterTransportSendAdapter listener is null.
286 */
287 HWTEST_F(BleSendManagerTest, RegisterTransportSendAdapter_003, TestSize.Level1)
288 {
289 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_002 begin" << std::endl;
290 int32_t result = bleSendManager_.RegisterTransportSendAdapter(nullptr);
291 EXPECT_EQ(result, ERROR_NO_LISTENERS);
292 DTEST_LOG << "BleSendManagerTest RegisterTransportSendAdapter_002 end" << std::endl;
293 }
294
295 /**
296 * @tc.name : UnRegisterTransportSendAdapter_001
297 * @tc.number: UnRegisterTransportSendAdapter_001
298 * @tc.desc : UnRegisterTransportSendAdapter when the listeners list is empty.
299 */
300 HWTEST_F(BleSendManagerTest, UnRegisterTransportSendAdapter_001, TestSize.Level1)
301 {
302 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_001 begin" << std::endl;
303 auto listener = std::make_shared<MyBleReceiveListener>();
304 EXPECT_EQ(bleSendManager_.UnRegisterTransportSendAdapter(listener), ERROR_NO_LISTENERS);
305 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_001 end" << std::endl;
306 }
307
308 /**
309 * @tc.name : UnRegisterTransportSendAdapter_002
310 * @tc.number: UnRegisterTransportSendAdapter_002
311 * @tc.desc : UnRegisterTransportSendAdapter when the listener is not found in the list.
312 */
313 HWTEST_F(BleSendManagerTest, UnRegisterTransportSendAdapter_002, TestSize.Level1)
314 {
315 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_002 begin" << std::endl;
316 auto listener1 = std::make_shared<MyBleReceiveListener>();
317 auto listener2 = std::make_shared<MyBleReceiveListener>();
318 bleSendManager_.bleReceviceListeners_.push_back(listener1);
319 EXPECT_EQ(bleSendManager_.UnRegisterTransportSendAdapter(listener2), ERROR_NO_LISTENERS);
320 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_002 end" << std::endl;
321 }
322
323 /**
324 * @tc.name : UnRegisterTransportSendAdapter_003
325 * @tc.number: UnRegisterTransportSendAdapter_003
326 * @tc.desc : UnRegisterTransportSendAdapter when the listener is found.
327 */
328
329 HWTEST_F(BleSendManagerTest, UnRegisterTransportSendAdapter_003, TestSize.Level1)
330 {
331 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_003 begin" << std::endl;
332 auto listener = std::make_shared<MyBleReceiveListener>();
333 bleSendManager_.bleReceviceListeners_.clear();
334 bleSendManager_.bleReceviceListeners_.push_back(listener);
335 EXPECT_EQ(bleSendManager_.UnRegisterTransportSendAdapter(listener), ERR_OK);
336 EXPECT_EQ(bleSendManager_.bleReceviceListeners_.size(), 0);
337 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_003 end" << std::endl;
338 }
339
340 /**
341 * @tc.name : UnRegisterTransportSendAdapter_004
342 * @tc.number: UnRegisterTransportSendAdapter_004
343 * @tc.desc : UnRegisterTransportSendAdapter when bleReceviceListeners_ is null.
344 */
345
346 HWTEST_F(BleSendManagerTest, UnRegisterTransportSendAdapter_004, TestSize.Level1)
347 {
348 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_004 begin" << std::endl;
349 auto listener = std::make_shared<MyBleReceiveListener>();
350 bleSendManager_.bleReceviceListeners_.clear();
351 EXPECT_EQ(bleSendManager_.UnRegisterTransportSendAdapter(listener), ERROR_NO_LISTENERS);
352 DTEST_LOG << "BleSendManagerTest UnRegisterTransportSendAdapter_004 end" << std::endl;
353 }
354
355 /**
356 * @tc.name : OnGattReady_001
357 * @tc.number: OnGattReady_001
358 * @tc.desc : OnGattReady when it is called.
359 */
360
361 HWTEST_F(BleSendManagerTest, OnGattReady_001, TestSize.Level1)
362 {
363 DTEST_LOG << "BleSendManagerTest OnGattReady_001 begin" << std::endl;
364 MechInfo mechInfo;
365 bleSendManager_.OnGattReady(mechInfo);
366 DTEST_LOG << "BleSendManagerTest OnGattReady_001 end" << std::endl;
367 }
368
369 /**
370 * @tc.name : MechbodyGattcDisconnect_001
371 * @tc.number: MechbodyGattcDisconnect_001
372 * @tc.desc : Test MechbodyGattcDisconnect function.
373 */
374
375 HWTEST_F(BleSendManagerTest, MechbodyGattcDisconnect_001, TestSize.Level1)
376 {
377 DTEST_LOG << "BleSendManagerTest MechbodyGattcDisconnect_001 begin" << std::endl;
378 std::string mac = "mac";
379 bleSendManager_.address_ = mac;
380 BluetoothRemoteDevice device(bleSendManager_.address_, 1);
381 bleSendManager_.gattClient_ = nullptr;
382 MechInfo mechInfo;
383 int32_t result = bleSendManager_.MechbodyGattcDisconnect(mechInfo);
384 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
385
386 bleSendManager_.gattClient_ = std::make_shared<OHOS::Bluetooth::GattClient>(device);
387 result = bleSendManager_.MechbodyGattcDisconnect(mechInfo);
388 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
389 DTEST_LOG << "BleSendManagerTest MechbodyGattcDisconnect_001 end" << std::endl;
390 }
391
392 /**
393 * @tc.name : MechbodyGattcWriteCharacteristic_001
394 * @tc.number: MechbodyGattcWriteCharacteristic_001
395 * @tc.desc : MechbodyGattcWriteCharacteristic when data is nullptr.
396 */
397
398 HWTEST_F(BleSendManagerTest, MechbodyGattcWriteCharacteristic_001, TestSize.Level1)
399 {
400 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_001 begin" << std::endl;
401 uint8_t* data = nullptr;
402 uint32_t dataLen = 0;
403 int32_t result = bleSendManager_.MechbodyGattcWriteCharacteristic(data, dataLen);
404 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
405 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_001 end" << std::endl;
406 }
407
408 /**
409 * @tc.name : MechbodyGattcWriteCharacteristic_002
410 * @tc.number: MechbodyGattcWriteCharacteristic_002
411 * @tc.desc : MechbodyGattcWriteCharacteristic when gattClient_ is nullptr.
412 */
413
414 HWTEST_F(BleSendManagerTest, MechbodyGattcWriteCharacteristic_002, TestSize.Level1)
415 {
416 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_002 begin" << std::endl;
417 uint8_t data[BUF_MIN_LEN + 1] = {0};
418 uint32_t dataLen = BUF_MIN_LEN + 1;
419 bleSendManager_.gattClient_ = nullptr;
420 int32_t result = bleSendManager_.MechbodyGattcWriteCharacteristic(data, dataLen);
421 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
422 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_002 end" << std::endl;
423 }
424
425 /**
426 * @tc.name : MechbodyGattcWriteCharacteristic_003
427 * @tc.number: MechbodyGattcWriteCharacteristic_003
428 * @tc.desc : MechbodyGattcWriteCharacteristic when gattClient_ is not nullptr.
429 */
430
431 HWTEST_F(BleSendManagerTest, MechbodyGattcWriteCharacteristic_003, TestSize.Level1)
432 {
433 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_003 begin" << std::endl;
434 uint8_t data[BUF_MIN_LEN + 1] = {0};
435 uint32_t dataLen = BUF_MIN_LEN + 1;
436 std::string mac = "mac";
437 bleSendManager_.address_ = mac;
438 BluetoothRemoteDevice device(bleSendManager_.address_, 1);
439 bleSendManager_.gattClient_ = std::make_shared<OHOS::Bluetooth::GattClient>(device);
440 int32_t result = bleSendManager_.MechbodyGattcWriteCharacteristic(data, dataLen);
441 EXPECT_EQ(result, ERROR_INVALID_PARAMETERS);
442 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_003 end" << std::endl;
443 }
444
445 /**
446 * @tc.name : MechbodyGattcWriteCharacteristic_004
447 * @tc.number: MechbodyGattcWriteCharacteristic_004
448 * @tc.desc : MechbodyGattcWriteCharacteristic when gattClient_ is nullptr.
449 */
450 HWTEST_F(BleSendManagerTest, MechbodyGattcWriteCharacteristic_004, TestSize.Level1)
451 {
452 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_004 begin" << std::endl;
453 uint8_t data[BUF_MIN_LEN + 1] = {0};
454 uint32_t dataLen = BUF_MIN_LEN - 1;
455 int32_t result = bleSendManager_.MechbodyGattcWriteCharacteristic(data, dataLen);
456 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
457 DTEST_LOG << "BleSendManagerTest MechbodyGattcWriteCharacteristic_004 end" << std::endl;
458 }
459
460 /**
461 * @tc.name : SendData_001
462 * @tc.number: SendData_001
463 * @tc.desc : SendData when data is nullptr.
464 */
465
466 HWTEST_F(BleSendManagerTest, SendData_001, TestSize.Level1)
467 {
468 DTEST_LOG << "BleSendManagerTest SendData_001 begin" << std::endl;
469 uint8_t* data = nullptr;
470 uint32_t dataLen = 0;
471 int32_t result = bleSendManager_.SendData(data, dataLen);
472 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
473 DTEST_LOG << "BleSendManagerTest SendData_001 end" << std::endl;
474 }
475
476 /**
477 * @tc.name : SendData_002
478 * @tc.number: SendData_002
479 * @tc.desc : SendData when dataLen is less than BUF_MIN_LEN.
480 */
481
482 HWTEST_F(BleSendManagerTest, SendData_002, TestSize.Level1)
483 {
484 DTEST_LOG << "BleSendManagerTest SendData_002 begin" << std::endl;
485 uint8_t data[BUF_LESS_THAN_MIN_LEN];
486 uint32_t dataLen = BUF_LESS_THAN_MIN_LEN;
487 int32_t result = bleSendManager_.SendData(data, dataLen);
488 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
489 DTEST_LOG << "BleSendManagerTest SendData_002 end" << std::endl;
490 }
491
492 /**
493 * @tc.name : SendData_003
494 * @tc.number: SendData_003
495 * @tc.desc : SendData when dataLen is less than BUF_MIN_LEN.
496 */
497
498 HWTEST_F(BleSendManagerTest, SendData_003, TestSize.Level1)
499 {
500 DTEST_LOG << "BleSendManagerTest SendData_003 begin" << std::endl;
501 uint8_t data[BUF_GREATER_THAN_MAX_LEN];
502 uint32_t dataLen = BUF_GREATER_THAN_MAX_LEN;
503 int32_t result = bleSendManager_.SendData(data, dataLen);
504 EXPECT_EQ(result, MECHBODY_GATT_INVALID_PARAM);
505 DTEST_LOG << "BleSendManagerTest SendData_003 end" << std::endl;
506 }
507
508 /**
509 * @tc.name : OnScanCallback_001`
510 * @tc.number: OnScanCallback_001
511 * @tc.desc : SendData when dataLen is less than BUF_MIN_LEN.
512 */
513
514 HWTEST_F(BleSendManagerTest, OnScanCallback_001, TestSize.Level1)
515 {
516 DTEST_LOG << "BleSendManagerTest OnScanCallback_001 begin" << std::endl;
517 Bluetooth::BleScanResult result;
518 BleCentralManagerCallbackImpl callbackImpl;
519 EXPECT_NO_FATAL_FAILURE(callbackImpl.OnScanCallback(result));
520 DTEST_LOG << "BleSendManagerTest OnScanCallback_001 end" << std::endl;
521 }
522
523 /**
524 * @tc.name : OnConnectionStateChanged_001
525 * @tc.number: OnConnectionStateChanged_001
526 * @tc.desc : Test OnConnectionStateChanged function.
527 */
528
529 HWTEST_F(BleSendManagerTest, OnConnectionStateChanged_001, TestSize.Level1)
530 {
531 DTEST_LOG << "BleSendManagerTest OnConnectionStateChanged_001 begin" << std::endl;
532 bleSendManager_.gattClient_ = nullptr;
533 int connectionState = 2;
534 int ret = 0;
535 MechInfo mechInfo;
536 EXPECT_NO_FATAL_FAILURE(bleSendManager_.OnConnectionStateChanged(connectionState, ret, mechInfo));
537
538 connectionState = 3;
539 EXPECT_NO_FATAL_FAILURE(bleSendManager_.OnConnectionStateChanged(connectionState, ret, mechInfo));
540
541 connectionState = 1;
542 std::string mac = "mac";
543 bleSendManager_.address_ = mac;
544 BluetoothRemoteDevice device(bleSendManager_.address_, 1);
545 bleSendManager_.gattClient_ = std::make_shared<OHOS::Bluetooth::GattClient>(device);
546 EXPECT_NO_FATAL_FAILURE(bleSendManager_.OnConnectionStateChanged(connectionState, ret, mechInfo));
547 DTEST_LOG << "BleSendManagerTest OnConnectionStateChanged_001 end" << std::endl;
548 }
549
550 /**
551 * @tc.name : OnServicesDiscovered_001
552 * @tc.number: OnServicesDiscovered_001
553 * @tc.desc : Test OnServicesDiscovered function.
554 */
555
556 HWTEST_F(BleSendManagerTest, OnServicesDiscovered_001, TestSize.Level1)
557 {
558 DTEST_LOG << "BleSendManagerTest OnServicesDiscovered_001 begin" << std::endl;
559 std::string mac = "mac";
560 bleSendManager_.address_ = mac;
561 BluetoothRemoteDevice device(bleSendManager_.address_, 1);
562 bleSendManager_.gattClient_ = nullptr;
563 auto callback = std::make_shared<BleGattClientCallback>();
564 int status = -1;
565 EXPECT_NO_FATAL_FAILURE(callback->OnServicesDiscovered(status));
566
567 status = OHOS::Bluetooth::GattStatus::GATT_SUCCESS;
568 EXPECT_NO_FATAL_FAILURE(callback->OnServicesDiscovered(status));
569
570 bleSendManager_.gattClient_ = std::make_shared<OHOS::Bluetooth::GattClient>(device);
571 EXPECT_NO_FATAL_FAILURE(callback->OnServicesDiscovered(status));
572 DTEST_LOG << "BleSendManagerTest OnServicesDiscovered_001 end" << std::endl;
573 }
574
575 /**
576 * @tc.name : OnCharacteristicWriteResult_001
577 * @tc.number: OnCharacteristicWriteResult_001
578 * @tc.desc : Test OnCharacteristicWriteResult function.
579 */
580
581 HWTEST_F(BleSendManagerTest, OnCharacteristicWriteResult_001, TestSize.Level1)
582 {
583 DTEST_LOG << "BleSendManagerTest OnCharacteristicWriteResult_001 begin" << std::endl;
584 auto callback = std::make_shared<BleGattClientCallback>();
585 GattCharacteristic characteristic = GattCharacteristic(MECHBODY_CHARACTERISTIC_NOTIFY_UUID, 0, 0, 0);
586 int ret = OHOS::Bluetooth::GattStatus::GATT_SUCCESS;
587 EXPECT_NO_FATAL_FAILURE(callback->OnCharacteristicWriteResult(characteristic, ret));
588
589 ret = OHOS::Bluetooth::GattStatus::GATT_FAILURE;
590 EXPECT_NO_FATAL_FAILURE(callback->OnCharacteristicWriteResult(characteristic, ret));
591
592 ret = OHOS::Bluetooth::GattStatus::WRITE_NOT_PERMITTED;
593 EXPECT_NO_FATAL_FAILURE(callback->OnCharacteristicWriteResult(characteristic, ret));
594 DTEST_LOG << "BleSendManagerTest OnCharacteristicWriteResult_001 end" << std::endl;
595 }
596
597 /**
598 * @tc.name : MechbodyGattcConnect_001
599 * @tc.number: MechbodyGattcConnect_001
600 * @tc.desc : Test MechbodyGattcConnect function.
601 */
602
603 HWTEST_F(BleSendManagerTest, MechbodyGattcConnect_001, TestSize.Level1)
604 {
605 DTEST_LOG << "BleSendManagerTest MechbodyGattcConnect_001 begin" << std::endl;
606 std::string mac = "mac";
607 std::string deviceName = "deviceName";
608 int ret = bleSendManager_.MechbodyGattcConnect(mac, deviceName);
609 EXPECT_EQ(ret, MECHBODY_GATT_CONNECT_FAILED);
610 DTEST_LOG << "BleSendManagerTest MechbodyGattcConnect_001 end" << std::endl;
611 }
612
613 /**
614 * @tc.name : UnInit_001
615 * @tc.number: UnInit_001
616 * @tc.desc : Test UnInit function.
617 */
618
619 HWTEST_F(BleSendManagerTest, UnInit_001, TestSize.Level1)
620 {
621 DTEST_LOG << "BleSendManagerTest UnInit_001 begin" << std::endl;
622 std::string mac = "mac";
623 bleSendManager_.address_ = mac;
624 BluetoothRemoteDevice device(bleSendManager_.address_, 1);
625 auto callback = std::make_shared<BleGattClientCallback>();
626 bleSendManager_.gattClient_ = std::make_shared<OHOS::Bluetooth::GattClient>(device);
627 bleSendManager_.bleGattClientCallBack_ = callback;
628
629 EXPECT_NO_FATAL_FAILURE(bleSendManager_.UnInit());
630 DTEST_LOG << "BleSendManagerTest UnInit_001 end" << std::endl;
631 }
632 }
633 }