1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <cstring>
18 #include "conn_log.h"
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include "softbus_error_code.h"
22 #include "softbus_conn_ble_trans.h"
23 #include "softbus_conn_ble_trans_mock.h"
24 #include "softbus_conn_ble_send_queue.h"
25 #include "softbus_conn_ble_connection.h"
26 #include "softbus_adapter_mem.h"
27 #include <arpa/inet.h>
28
29 using namespace testing::ext;
30 using namespace testing;
31 static ConnBleTransEventListener g_transEventListener = { 0 };
32 static const size_t BLE_TRANS_HEADER_SIZE = sizeof(BleTransHeader);
OnPostBytesFinished(uint32_t connectionId,uint32_t len,int32_t pid,int32_t flag,int32_t module,int64_t seq,int32_t error)33 void OnPostBytesFinished(
34 uint32_t connectionId, uint32_t len, int32_t pid, int32_t flag, int32_t module, int64_t seq, int32_t error)
35 {
36 (void)connectionId;
37 (void)len;
38 (void)pid;
39 (void)flag;
40 (void)module;
41 (void)seq;
42 (void)error;
43 }
44
45 extern "C" {
ConnBleReturnConnection(ConnBleConnection ** connection)46 void ConnBleReturnConnection(ConnBleConnection **connection)
47 {
48 (void)connection;
49 }
50
cJSON_Delete(cJSON * json)51 void cJSON_Delete(cJSON *json)
52 {
53 (void)json;
54 }
55
cJSON_free(void * object)56 void cJSON_free(void *object)
57 {
58 (void)object;
59 }
60
ConnBleRefreshIdleTimeout(ConnBleConnection * connection)61 void ConnBleRefreshIdleTimeout(ConnBleConnection *connection)
62 {
63 (void)connection;
64 }
65 }
66 namespace OHOS {
67 class ConnectionBleTransTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
SetUp()71 void SetUp() override {}
TearDown()72 void TearDown() override {}
73 };
74
SetUpTestCase()75 void ConnectionBleTransTest::SetUpTestCase()
76 {
77 LooperInit();
78 g_transEventListener.onPostBytesFinished = OnPostBytesFinished;
79 int32_t ret = ConnBleInitTransModule(&g_transEventListener);
80 EXPECT_EQ(SOFTBUS_OK, ret);
81 }
82
TearDownTestCase()83 void ConnectionBleTransTest::TearDownTestCase()
84 {
85 LooperDeinit();
86 }
87
88 /*
89 * @tc.name: TransRecv
90 * @tc.desc: Test ConnCocTransRecv.
91 * @tc.in: Test module, Test number, Test Levels.
92 * @tc.out: Zero
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(ConnectionBleTransTest, TransRecv, TestSize.Level1)
97 {
98 uint32_t connectionId = 1;
99 LimitedBuffer buffer = {0};
100 int32_t *outLen = nullptr;
101 uint8_t *data = nullptr;
102
103 ConnPktHead head = {0};
104 head.magic = MAGIC_NUMBER + 1;
105 head.len = sizeof(ConnPktHead);
106 buffer.capacity = 140;
107 buffer.length = sizeof(ConnPktHead) - 1;
108 buffer.buffer = (uint8_t *)(&head);
109 outLen = (int32_t *)SoftBusCalloc(sizeof(ConnPktHead));
110 ASSERT_NE(nullptr, outLen);
111 data = ConnCocTransRecv(connectionId, &buffer, outLen);
112 EXPECT_EQ(nullptr, data);
113
114 buffer.length = sizeof(ConnPktHead);
115 data = ConnCocTransRecv(connectionId, &buffer, outLen);
116 EXPECT_EQ(nullptr, data);
117
118 head.magic = MAGIC_NUMBER;
119 buffer.capacity = sizeof(ConnPktHead) + sizeof(ConnPktHead) - 1;
120 buffer.length = sizeof(ConnPktHead) + 1;
121 data = ConnCocTransRecv(connectionId, &buffer, outLen);
122 EXPECT_EQ(nullptr, data);
123
124 buffer.length = sizeof(ConnPktHead) + 1;
125 buffer.capacity = sizeof(ConnPktHead) + sizeof(ConnPktHead) + 1;
126 data = ConnCocTransRecv(connectionId, &buffer, outLen);
127 EXPECT_EQ(nullptr, data);
128
129 buffer.length = head.len + sizeof(ConnPktHead) + 1;
130 buffer.capacity = sizeof(ConnPktHead) + sizeof(ConnPktHead) + 1;
131 data = ConnCocTransRecv(connectionId, &buffer, outLen);
132 EXPECT_NE(nullptr, data);
133 }
134
135 /*
136 * @tc.name: TransPackMsg
137 * @tc.desc: Test ConnBlePackCtlMessage.
138 * @tc.in: Test module, Test number, Test Levels.
139 * @tc.out: Zero
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 HWTEST_F(ConnectionBleTransTest, TransPackMsg, TestSize.Level1)
144 {
145 BleCtlMessageSerializationContext ctx;
146 ctx.connectionId = 10;
147 ctx.method = METHOD_NOTIFY_REQUEST;
148 ctx.challengeCode = 0;
149 ctx.referenceRequest.referenceNumber = 2;
150 ctx.referenceRequest.delta = 1;
151 uint8_t *data = nullptr;
152 uint32_t dataLen = 0;
153 NiceMock<ConnectionBleTransInterfaceMock> bleMock;
154 EXPECT_CALL(bleMock, cJSON_CreateObject).WillOnce(Return(nullptr));
155 int64_t ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
156 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
157
158 cJSON json = {0};
159 EXPECT_CALL(bleMock, cJSON_CreateObject).WillOnce(Return(&json));
160 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillOnce(Return(false));
161 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
162 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
163
164 EXPECT_CALL(bleMock, cJSON_CreateObject).WillRepeatedly(Return(&json));
165 ctx.method = (BleCtlMessageMethod)0;
166 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
167 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
168
169 ctx.method = METHOD_NOTIFY_REQUEST;
170 EXPECT_CALL(bleMock, cJSON_CreateObject).WillRepeatedly(Return(&json));
171 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
172 EXPECT_CALL(bleMock, AddNumber16ToJsonObject).WillRepeatedly(Return(true));
173 EXPECT_CALL(bleMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr));
174 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
175 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
176
177 const char *val = "test001";
178 char value[7] = {0};
179 strcpy_s(value, sizeof(value), val);
180 EXPECT_CALL(bleMock, cJSON_PrintUnformatted).WillOnce(Return(value));
181 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
182 EXPECT_EQ(SOFTBUS_OK, ret);
183 }
184
185 /*
186 * @tc.name: TransPostBytesInner
187 * @tc.desc: Test ConnBlePackCtlMessage.
188 * @tc.in: Test module, Test number, Test Levels.
189 * @tc.out: Zero
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(ConnectionBleTransTest, TransPostBytesInner, TestSize.Level1)
194 {
195 uint32_t connectionId = 10;
196 uint8_t *data = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
197 uint32_t dataLen = sizeof(uint8_t);
198 int32_t pid = 0;
199 int32_t flag = 2;
200 int32_t module = MODULE_CONNECTION;
201 int64_t seq = 10;
202 int32_t ret = ConnBlePostBytesInner(connectionId, data, 0, pid, flag, module, seq, nullptr);
203 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
204
205 uint8_t *value = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
206 ret = ConnBlePostBytesInner(connectionId, value, MAX_DATA_LEN + 1, pid, flag, module, seq, nullptr);
207 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
208
209 NiceMock<ConnectionBleTransInterfaceMock> bleMock;
210 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillOnce(Return(nullptr));
211 uint8_t *value1 = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
212 ret = ConnBlePostBytesInner(connectionId, value1, dataLen, pid, flag, module, seq, nullptr);
213 EXPECT_EQ(SOFTBUS_CONN_BLE_CONNECTION_NOT_EXIST_ERR, ret);
214
215 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
216 ASSERT_NE(nullptr, connection);
217 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
218 SoftBusMutexInit(&connection->lock, nullptr);
219 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillOnce(Return(connection));
220 uint8_t *value2 = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
221 ret = ConnBlePostBytesInner(connectionId, value2, dataLen, pid, flag, MODULE_AUTH_MSG, seq, nullptr);
222 EXPECT_EQ(SOFTBUS_CONN_BLE_CONNECTION_NOT_READY_ERR, ret);
223
224 uint8_t *value3 = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
225 ConnBleConnection *bleConnectionconnection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
226 ASSERT_NE(nullptr, connection);
227 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillRepeatedly(Return(bleConnectionconnection));
228 SoftBusMutexInit(&bleConnectionconnection->lock, nullptr);
229 bleConnectionconnection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
230
231 ret = ConnBlePostBytesInner(connectionId, value3, dataLen, pid, flag, MODULE_AUTH_MSG, seq, nullptr);
232 EXPECT_EQ(SOFTBUS_OK, ret);
233 SoftBusSleepMs(1000);
234 }
235
236 /*
237 * @tc.name: GattTransRecv001
238 * @tc.desc: Test ConnGattTransRecv001.
239 * @tc.in: Test module, Test number, Test Levels.
240 * @tc.out: Zero
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(ConnectionBleTransTest, GattTransRecv001, TestSize.Level1)
245 {
246 uint8_t *data = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
247 uint32_t dataLen = sizeof(uint8_t) + sizeof(BleTransHeader);
248 ConnBleReadBuffer buffer;
249 uint32_t outLen = 0;
250 uint32_t connectionId = 1;
251 uint8_t *value = ConnGattTransRecv(connectionId, data, BLE_TRANS_HEADER_SIZE - 1, &buffer, &outLen);
252 EXPECT_EQ(nullptr, value);
253
254 BleTransHeader tmp;
255 tmp.seq = 100000;
256 tmp.size = 0x01;
257 tmp.offset = 0;
258 tmp.total = 0x10;
259
260 data = (uint8_t *)&tmp;
261 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
262 EXPECT_EQ(nullptr, value);
263
264 tmp.size = 0x11;
265 data = (uint8_t *)&tmp;
266 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
267 EXPECT_EQ(nullptr, value);
268 }
269
270 /*
271 * @tc.name: GattTransRecv003
272 * @tc.desc: Test ConnGattTransRecv003.
273 * @tc.in: Test module, Test number, Test Levels.
274 * @tc.out: Zero
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(ConnectionBleTransTest, GattTransRecv003, TestSize.Level1)
279 {
280 CONN_LOGI(CONN_BLE, "GattTransRecv003, start");
281 uint8_t *data = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
282 uint32_t connectionId = 1;
283 uint32_t outLen = 0;
284 uint32_t dataLen = sizeof(uint8_t) + sizeof(BleTransHeader);
285 BleTransHeader tmp;
286 tmp.seq = ntohl(100000);
287 tmp.size = ntohl(0x01);
288 tmp.offset = 0;
289 tmp.total = ntohl(0x10000);
290
291 data = (uint8_t *)&tmp;
292 ConnBleReadBuffer buffer = { 0 };
293 uint8_t *value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
294 EXPECT_EQ(nullptr, value);
295
296 tmp.total = 0;
297 data = (uint8_t *)&tmp;
298 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
299 EXPECT_EQ(nullptr, value);
300
301 tmp.total = ntohl(0x10);
302 tmp.offset = tmp.total;
303 data = (uint8_t *)&tmp;
304 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
305 EXPECT_EQ(nullptr, value);
306
307 tmp.offset = 0;
308 tmp.total = tmp.size;
309 data = (uint8_t *)&tmp;
310 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
311 EXPECT_NE(nullptr, value);
312
313 tmp.total = ntohl(0x10);
314 data = (uint8_t *)&tmp;
315 ListInit(&buffer.packets);
316 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
317 EXPECT_EQ(nullptr, value);
318
319 tmp.total = tmp.size;
320 data = (uint8_t *)&tmp;
321 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
322 EXPECT_NE(nullptr, value);
323
324 tmp.total = ntohl(0x10);
325 data = (uint8_t *)&tmp;
326 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
327 EXPECT_EQ(nullptr, value);
328 CONN_LOGI(CONN_BLE, "GattTransRecv003, end");
329 }
330
331 /*
332 * @tc.name: GattTransRecv004
333 * @tc.desc: Test ConnGattTransRecv004.
334 * @tc.in: Test module, Test number, Test Levels.
335 * @tc.out: Zero
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(ConnectionBleTransTest, GattTransRecv004, TestSize.Level1)
340 {
341 CONN_LOGI(CONN_BLE, "GattTransRecv004, start");
342 uint8_t *data = static_cast<uint8_t *>(malloc(sizeof(uint8_t)));
343 uint32_t connectionId = 1;
344 uint32_t outLen = 0;
345 uint32_t dataLen = sizeof(uint8_t) + sizeof(BleTransHeader);
346 BleTransHeader tmp;
347 tmp.seq = ntohl(100000);
348 tmp.size = ntohl(0x01);
349 tmp.offset = ntohl(0x0F);
350 tmp.total = ntohl(0x10);
351
352 data = (uint8_t *)&tmp;
353 ConnBleReadBuffer buffer = { 0 };
354 buffer.seq = ntohl(tmp.seq) + 1;
355 buffer.total = ntohl(tmp.total) + 1;
356 ListInit(&buffer.packets);
357 uint8_t *value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
358 EXPECT_EQ(nullptr, value);
359
360 buffer.seq = ntohl(tmp.seq) + 1;
361 buffer.total = ntohl(tmp.total) + 1;
362 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
363 EXPECT_EQ(nullptr, value);
364
365 buffer.seq = 0;
366 for (uint32_t i = 1; i < ntohl(tmp.total) - 1; i++) {
367 tmp.offset = ntohl(0x0F - i);
368 data = (uint8_t *)&tmp;
369 ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
370 }
371 tmp.offset = 0;
372 data = (uint8_t *)&tmp;
373 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
374 EXPECT_NE(nullptr, value);
375 CONN_LOGI(CONN_BLE, "GattTransRecv004, end");
376 }
377 /*
378 * @tc.name: ConnBleTransConfigPostLimit
379 * @tc.desc: Test ConnBleTransConfigPostLimit.
380 * @tc.in: Test module, Test number, Test Levels.
381 * @tc.out: Zero
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(ConnectionBleTransTest, ConnBleTransConfigPostLimit, TestSize.Level1)
386 {
387 LimitConfiguration configuration;
388 configuration.type = CONNECT_TCP;
389 int32_t ret = ConnBleTransConfigPostLimit(nullptr);
390 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
391 ret = ConnBleTransConfigPostLimit(&configuration);
392 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
393 configuration.type = CONNECT_BLE;
394 configuration.active = false;
395 ret = ConnBleTransConfigPostLimit(&configuration);
396 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
397 configuration.active = true;
398 ret = ConnBleTransConfigPostLimit(&configuration);
399 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
400 }
401
402 /*
403 * @tc.name: QueueBlock
404 * @tc.desc: Test ConnBleDequeueBlock, ConnBleEnqueueNonBlock
405 * @tc.in: Test module, Test number, Test Levels.
406 * @tc.out: Zero
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(ConnectionBleTransTest, QueueBlock, TestSize.Level1)
411 {
412 int32_t ret = ConnBleInitSendQueue();
413 EXPECT_EQ(SOFTBUS_OK, ret);
414
415 SendQueueNode queueNode;
416 queueNode.flag = CONN_HIGH;
417 queueNode.pid = 0;
418 ret = ConnBleEnqueueNonBlock(&queueNode);
419 EXPECT_EQ(SOFTBUS_OK, ret);
420
421 ret = ConnBleDequeueBlock(nullptr);
422 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
423
424 void *msg = nullptr;
425 queueNode.flag = CONN_LOW;
426 queueNode.pid = 1;
427 ret = ConnBleEnqueueNonBlock(&queueNode);
428 EXPECT_EQ(SOFTBUS_OK, ret);
429 ret = ConnBleDequeueBlock(&msg);
430 EXPECT_EQ(SOFTBUS_OK, ret);
431 ConnBleDeinitSendQueue();
432 }
433 }
434