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_errcode.h"
22 #include "softbus_conn_ble_trans.h"
23 #include "connection_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
28 using namespace testing::ext;
29 using namespace testing;
30 static ConnBleTransEventListener g_transEventListener = { 0 };
31 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)32 void OnPostBytesFinished(
33 uint32_t connectionId, uint32_t len, int32_t pid, int32_t flag, int32_t module, int64_t seq, int32_t error)
34 {
35 (void)connectionId;
36 (void)len;
37 (void)pid;
38 (void)flag;
39 (void)module;
40 (void)seq;
41 (void)error;
42 }
43
44 extern "C" {
ConnBleReturnConnection(ConnBleConnection ** connection)45 void ConnBleReturnConnection(ConnBleConnection **connection)
46 {
47 (void)connection;
48 }
49
cJSON_Delete(cJSON * json)50 void cJSON_Delete(cJSON *json)
51 {
52 (void)json;
53 }
54
cJSON_free(void * object)55 void cJSON_free(void *object)
56 {
57 (void)object;
58 }
59
ConnBleRefreshIdleTimeout(ConnBleConnection * connection)60 void ConnBleRefreshIdleTimeout(ConnBleConnection *connection)
61 {
62 (void)connection;
63 }
64 }
65 namespace OHOS {
66 class ConnectionBleTransTest : public testing::Test {
67 public:
68 static void SetUpTestCase();
69 static void TearDownTestCase();
SetUp()70 void SetUp() override {}
TearDown()71 void TearDown() override {}
72 };
73
SetUpTestCase()74 void ConnectionBleTransTest::SetUpTestCase()
75 {
76 LooperInit();
77 g_transEventListener.onPostBytesFinished = OnPostBytesFinished;
78 int32_t ret = ConnBleInitTransModule(&g_transEventListener);
79 EXPECT_EQ(SOFTBUS_OK, ret);
80 }
81
TearDownTestCase()82 void ConnectionBleTransTest::TearDownTestCase()
83 {
84 LooperDeinit();
85 }
86
87 /*
88 * @tc.name: TransRecv
89 * @tc.desc: Test ConnCocTransRecv.
90 * @tc.in: Test module, Test number, Test Levels.
91 * @tc.out: Zero
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(ConnectionBleTransTest, TransRecv, TestSize.Level1)
96 {
97 uint32_t connectionId = 1;
98 LimitedBuffer buffer = {0};
99 int32_t *outLen = nullptr;
100 uint8_t *data = nullptr;
101
102 ConnPktHead head = {0};
103 head.magic = MAGIC_NUMBER + 1;
104 head.len = sizeof(ConnPktHead);
105 buffer.capacity = 140;
106 buffer.length = sizeof(ConnPktHead) - 1;
107 buffer.buffer = (uint8_t *)(&head);
108 outLen = (int32_t *)SoftBusCalloc(sizeof(ConnPktHead));
109 data = ConnCocTransRecv(connectionId, &buffer, outLen);
110 EXPECT_EQ(nullptr, data);
111
112 buffer.length = sizeof(ConnPktHead);
113 data = ConnCocTransRecv(connectionId, &buffer, outLen);
114 EXPECT_EQ(nullptr, data);
115
116 head.magic = MAGIC_NUMBER;
117 buffer.capacity = sizeof(ConnPktHead) + sizeof(ConnPktHead) - 1;
118 buffer.length = sizeof(ConnPktHead) + 1;
119 data = ConnCocTransRecv(connectionId, &buffer, outLen);
120 EXPECT_EQ(nullptr, data);
121
122 buffer.length = sizeof(ConnPktHead) + 1;
123 buffer.capacity = sizeof(ConnPktHead) + sizeof(ConnPktHead) + 1;
124 data = ConnCocTransRecv(connectionId, &buffer, outLen);
125 EXPECT_EQ(nullptr, data);
126 }
127
128 /*
129 * @tc.name: TransPackMsg
130 * @tc.desc: Test ConnBlePackCtlMessage.
131 * @tc.in: Test module, Test number, Test Levels.
132 * @tc.out: Zero
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(ConnectionBleTransTest, TransPackMsg, TestSize.Level1)
137 {
138 BleCtlMessageSerializationContext ctx;
139 ctx.connectionId = 10;
140 ctx.method = METHOD_NOTIFY_REQUEST;
141 ctx.challengeCode = 0;
142 ctx.referenceRequest.referenceNumber = 2;
143 ctx.referenceRequest.delta = 1;
144 uint8_t *data = NULL;
145 uint32_t dataLen = 0;
146 NiceMock<ConnectionBleTransInterfaceMock> bleMock;
147 EXPECT_CALL(bleMock, cJSON_CreateObject).WillOnce(Return(nullptr));
148 int64_t ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
149 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
150
151 cJSON json = {0};
152 EXPECT_CALL(bleMock, cJSON_CreateObject).WillOnce(Return(&json));
153 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillOnce(Return(false));
154 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
155 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
156
157 EXPECT_CALL(bleMock, cJSON_CreateObject).WillRepeatedly(Return(&json));
158 ctx.method = (BleCtlMessageMethod)0;
159 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
160 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
161
162 ctx.method = METHOD_NOTIFY_REQUEST;
163 EXPECT_CALL(bleMock, cJSON_CreateObject).WillRepeatedly(Return(&json));
164 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
165 EXPECT_CALL(bleMock, AddNumber16ToJsonObject).WillRepeatedly(Return(true));
166 EXPECT_CALL(bleMock, cJSON_PrintUnformatted).WillOnce(Return(nullptr));
167 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
168 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
169
170 const char *val = "test001";
171 char value[7] = {0};
172 strcpy_s(value, sizeof(value), val);
173 EXPECT_CALL(bleMock, cJSON_PrintUnformatted).WillOnce(Return(value));
174 ret = ConnBlePackCtlMessage(ctx, &data, &dataLen);
175 EXPECT_EQ(SOFTBUS_OK, ret);
176 }
177
178 /*
179 * @tc.name: TransPostBytesInner
180 * @tc.desc: Test ConnBlePackCtlMessage.
181 * @tc.in: Test module, Test number, Test Levels.
182 * @tc.out: Zero
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(ConnectionBleTransTest, TransPostBytesInner, TestSize.Level1)
187 {
188 uint32_t connectionId = 10;
189 uint8_t *data = (uint8_t *)malloc(sizeof(uint8_t));
190 uint32_t dataLen = sizeof(uint8_t);
191 int32_t pid = 0;
192 int32_t flag = 2;
193 int32_t module = MODULE_CONNECTION;
194 int64_t seq = 10;
195 int32_t ret = ConnBlePostBytesInner(connectionId, data, 0, pid, flag, module, seq, NULL);
196 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
197
198 uint8_t *value = (uint8_t *)malloc(sizeof(uint8_t));
199 ret = ConnBlePostBytesInner(connectionId, value, MAX_DATA_LEN + 1, pid, flag, module, seq, NULL);
200 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
201
202 NiceMock<ConnectionBleTransInterfaceMock> bleMock;
203 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillOnce(Return(nullptr));
204 uint8_t *value1 = (uint8_t *)malloc(sizeof(uint8_t));
205 ret = ConnBlePostBytesInner(connectionId, value1, dataLen, pid, flag, module, seq, NULL);
206 EXPECT_EQ(SOFTBUS_CONN_BLE_CONNECTION_NOT_EXIST_ERR, ret);
207
208 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
209 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
210 SoftBusMutexInit(&connection->lock, NULL);
211 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillOnce(Return(connection));
212 uint8_t *value2 = (uint8_t *)malloc(sizeof(uint8_t));
213 ret = ConnBlePostBytesInner(connectionId, value2, dataLen, pid, flag, MODULE_AUTH_MSG, seq, NULL);
214 EXPECT_EQ(SOFTBUS_CONN_BLE_CONNECTION_NOT_READY_ERR, ret);
215
216 uint8_t *value3 = (uint8_t *)malloc(sizeof(uint8_t));
217 ConnBleConnection *bleConnectionconnection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
218 EXPECT_CALL(bleMock, ConnBleGetConnectionById).WillRepeatedly(Return(bleConnectionconnection));
219 SoftBusMutexInit(&bleConnectionconnection->lock, NULL);
220 bleConnectionconnection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
221
222 ret = ConnBlePostBytesInner(connectionId, value3, dataLen, pid, flag, MODULE_AUTH_MSG, seq, NULL);
223 EXPECT_EQ(SOFTBUS_OK, ret);
224 SoftBusSleepMs(1000);
225 }
226
227 /*
228 * @tc.name: GattTransRecv
229 * @tc.desc: Test ConnGattTransRecv.
230 * @tc.in: Test module, Test number, Test Levels.
231 * @tc.out: Zero
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(ConnectionBleTransTest, GattTransRecv, TestSize.Level1)
236 {
237 uint8_t *data = (uint8_t *)malloc(sizeof(uint8_t));
238 uint32_t dataLen = sizeof(uint8_t) + sizeof(BleTransHeader);
239 ConnBleReadBuffer buffer;
240 uint32_t outLen = 0;
241 uint32_t connectionId = 1;
242 uint8_t *value = ConnGattTransRecv(connectionId, data, BLE_TRANS_HEADER_SIZE - 1, &buffer, &outLen);
243 EXPECT_EQ(nullptr, value);
244
245 BleTransHeader tmp;
246 tmp.seq = 100000;
247 tmp.size = 0x01;
248 tmp.offset = 0;
249 tmp.total = 0x10;
250
251 data = (uint8_t *)&tmp;
252 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, &outLen);
253 EXPECT_EQ(nullptr, value);
254 }
255
256 /*
257 * @tc.name: QueueBlock
258 * @tc.desc: Test ConnBleDequeueBlock, ConnBleEnqueueNonBlock
259 * @tc.in: Test module, Test number, Test Levels.
260 * @tc.out: Zero
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(ConnectionBleTransTest, QueueBlock, TestSize.Level1)
265 {
266 int32_t ret = ConnBleInitSendQueue();
267 EXPECT_EQ(SOFTBUS_OK, ret);
268
269 SendQueueNode queueNode;
270 queueNode.flag = CONN_HIGH;
271 queueNode.pid = 0;
272 ret = ConnBleEnqueueNonBlock(&queueNode);
273 EXPECT_EQ(SOFTBUS_OK, ret);
274
275 ret = ConnBleDequeueBlock(NULL);
276 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
277
278 void *msg = nullptr;
279 queueNode.flag = CONN_LOW;
280 queueNode.pid = 1;
281 ret = ConnBleEnqueueNonBlock(&queueNode);
282 EXPECT_EQ(SOFTBUS_OK, ret);
283 ret = ConnBleDequeueBlock(&msg);
284 EXPECT_EQ(SOFTBUS_OK, ret);
285 ConnBleDeinitSendQueue();
286 }
287 }
288