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 <cstdio>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include "softbus_conn_ble_connection_mock.h"
21 #include "common_list.h"
22 #include "softbus_conn_interface.h"
23 #include "softbus_conn_manager.h"
24 #include "softbus_def.h"
25 #include "softbus_error_code.h"
26 #include "softbus_feature_config.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_conn_ble_send_queue.h"
29 #include "softbus_conn_ble_trans.h"
30 #include "ble_protocol_interface_factory.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34 namespace OHOS {
35 static uint32_t g_connId;
36
ConnectedCB(unsigned int connectionId,const ConnectionInfo * info)37 void ConnectedCB(unsigned int connectionId, const ConnectionInfo *info)
38 {
39 if (info->type == CONNECT_BLE) {
40 g_connId = connectionId;
41 }
42 }
DisConnectedCB(unsigned int connectionId,const ConnectionInfo * info)43 void DisConnectedCB(unsigned int connectionId, const ConnectionInfo *info) {}
DataReceivedCB(unsigned int connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)44 void DataReceivedCB(unsigned int connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len) {}
45 class ConnectionBleTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
SetUp()49 void SetUp() override {}
TearDown()50 void TearDown() override {}
51 };
52
SetUpTestCase()53 void ConnectionBleTest::SetUpTestCase()
54 {
55 LooperInit();
56 SoftbusConfigInit();
57 ConnServerInit();
58 }
59
TearDownTestCase()60 void ConnectionBleTest::TearDownTestCase()
61 {
62 LooperDeinit();
63 }
64
65 /*
66 * @tc.name: TransTest001
67 * @tc.desc: Test ConnBlePackCtlMessage.
68 * @tc.in: Test module, Test number, Test Levels.
69 * @tc.out: Zero
70 * @tc.type: FUNC
71 * @tc.require:
72 */
73 HWTEST_F(ConnectionBleTest, TransTest001, TestSize.Level1)
74 {
75 int64_t ret;
76 uint8_t *outData = nullptr;
77 uint32_t outLen;
78 BleCtlMessageSerializationContext ctx;
79 NiceMock<ConnectionBleInterfaceMock> bleMock;
80
81 ctx.connectionId = 1;
82 ctx.method = METHOD_NOTIFY_REQUEST;
83 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
84 ret = ConnBlePackCtlMessage(ctx, &outData, &outLen);
85 EXPECT_EQ(SOFTBUS_OK, ret);
86
87 EXPECT_CALL(bleMock, AddNumberToJsonObject).WillRepeatedly(Return(false));
88 ret = ConnBlePackCtlMessage(ctx, &outData, &outLen);
89 EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
90 }
91
92 /*
93 * @tc.name: TransTest002
94 * @tc.desc: Test ConnGattTransRecv.
95 * @tc.in: Test module, Test number, Test Levels.
96 * @tc.out: Zero
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(ConnectionBleTest, TransTest002, TestSize.Level1)
101 {
102 uint8_t *value;
103 uint32_t connectionId = 1;
104 uint8_t *data = nullptr;
105 uint32_t dataLen = 0;
106 ConnBleReadBuffer buffer;
107 uint32_t *outLen = nullptr;
108 BleTransHeader tmp;
109
110 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, outLen);
111 ASSERT_TRUE(value == nullptr);
112
113 uint32_t len = sizeof(ConnBleReadBuffer) - 1;
114 value = ConnGattTransRecv(connectionId, data, len, &buffer, outLen);
115 ASSERT_TRUE(value == nullptr);
116
117 tmp.total = MAX_DATA_LEN + 1;
118 dataLen = 17;
119 data = (uint8_t *)(&tmp);
120 outLen = (uint32_t *)SoftBusCalloc(buffer.total);
121 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, outLen);
122 ASSERT_TRUE(value == nullptr);
123
124 tmp.seq = 1;
125 tmp.size = 2;
126 tmp.offset = 0;
127 tmp.total = MAX_DATA_LEN + 1;
128 data = (uint8_t *)(&tmp);
129 buffer.seq = 1;
130 outLen = (uint32_t *)SoftBusCalloc(buffer.total);
131 value = ConnGattTransRecv(connectionId, data, dataLen, &buffer, outLen);
132 ASSERT_TRUE(value == nullptr);
133 }
134
135 /*
136 * @tc.name: TransTest003
137 * @tc.desc: Test ConnCocTransRecv.
138 * @tc.in: Test module, Test number, Test Levels.
139 * @tc.out: Zero
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 HWTEST_F(ConnectionBleTest, TransTest003, TestSize.Level1)
144 {
145 uint8_t *value;
146 uint32_t connectionId;
147 LimitedBuffer buffer;
148 int32_t *outLen = nullptr;
149 ConnPktHead head;
150
151 head.magic = MAGIC_NUMBER;
152 head.len = 70;
153 buffer.capacity = 140;
154 buffer.length = 100;
155 buffer.buffer = (uint8_t *)(&head);
156 connectionId = 1;
157 outLen = (int32_t *)SoftBusCalloc(head.len + sizeof(ConnPktHead));
158 value = ConnCocTransRecv(connectionId, &buffer, outLen);
159 ASSERT_TRUE(value != nullptr);
160
161 head.magic = MAGIC_NUMBER + 1;
162 head.len = 70;
163 buffer.capacity = 140;
164 buffer.length = 100;
165 buffer.buffer = (uint8_t *)(&head);
166 connectionId = 1;
167 value = ConnCocTransRecv(connectionId, &buffer, outLen);
168 ASSERT_TRUE(value == nullptr);
169 }
170
171 /*
172 * @tc.name: QueueTest001
173 * @tc.desc: Test ConnBleEnqueueNonBlock.
174 * @tc.in: Test module, Test number, Test Levels.
175 * @tc.out: Zero
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(ConnectionBleTest, QueueTest001, TestSize.Level1)
180 {
181 int32_t ret;
182 SendQueueNode queueNode;
183
184 ret = ConnBleInitSendQueue();
185 EXPECT_EQ(SOFTBUS_OK, ret);
186
187 ret = ConnBleEnqueueNonBlock(nullptr);
188 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
189
190 queueNode.flag = CONN_HIGH;
191 queueNode.pid = 0;
192 ret = ConnBleEnqueueNonBlock(&queueNode);
193 EXPECT_EQ(SOFTBUS_OK, ret);
194
195 queueNode.flag = CONN_MIDDLE;
196 queueNode.pid = 1;
197 ret = ConnBleEnqueueNonBlock(&queueNode);
198 EXPECT_EQ(SOFTBUS_OK, ret);
199
200 queueNode.flag = CONN_LOW;
201 queueNode.pid = 1;
202 ret = ConnBleEnqueueNonBlock(&queueNode);
203 EXPECT_EQ(SOFTBUS_OK, ret);
204
205 ConnBleDeinitSendQueue();
206 }
207
208 /*
209 * @tc.name: QueueTest002
210 * @tc.desc: Test ConnBleEnqueueNonBlock.
211 * @tc.in: Test module, Test number, Test Levels.
212 * @tc.out: Zero
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(ConnectionBleTest, QueueTest002, TestSize.Level1)
217 {
218 int32_t ret;
219 void *msg = nullptr;
220 SendQueueNode queueNode;
221
222 ret = ConnBleInitSendQueue();
223 EXPECT_EQ(SOFTBUS_OK, ret);
224
225 queueNode.flag = CONN_LOW;
226 queueNode.pid = 1;
227 ret = ConnBleEnqueueNonBlock(&queueNode);
228 EXPECT_EQ(SOFTBUS_OK, ret);
229 ret = ConnBleDequeueBlock(&msg);
230 EXPECT_EQ(SOFTBUS_OK, ret);
231
232 ret = ConnBleDequeueBlock(nullptr);
233 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
234
235 ConnBleDeinitSendQueue();
236 }
237
238 /*
239 * @tc.name: ManagerTest001
240 * @tc.desc: Test ConnTypeIsSupport.
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(ConnectionBleTest, ManagerTest001, TestSize.Level1)
245 {
246 int32_t ret;
247 ret = ConnTypeIsSupport(CONNECT_BLE);
248 EXPECT_EQ(ret, SOFTBUS_OK);
249 }
250
251 /*
252 * @tc.name: ManagerTest002
253 * @tc.desc: Test invalid param.
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(ConnectionBleTest, ManagerTest002, TestSize.Level1)
258 {
259 int32_t ret = ConnSetConnectCallback(static_cast<ConnModule>(0), nullptr);
260 ASSERT_TRUE(ret != SOFTBUS_OK);
261 ret = ConnConnectDevice(nullptr, 0, nullptr);
262 ASSERT_TRUE(ret != SOFTBUS_OK);
263 ret = ConnDisconnectDevice(0);
264 ASSERT_TRUE(ret != SOFTBUS_OK);
265 ret = ConnPostBytes(0, nullptr);
266 ASSERT_TRUE(ret != SOFTBUS_OK);
267 ret = ConnStartLocalListening(nullptr);
268 ASSERT_TRUE(ret != SOFTBUS_OK);
269 ret = ConnStopLocalListening(nullptr);
270 ASSERT_TRUE(ret != SOFTBUS_OK);
271 }
272 /*
273 * @tc.name: ManagerTest003
274 * @tc.desc: Test Start stop listening.
275 * @tc.in: Test module, Test number, Test Levels.
276 * @tc.out: NonZero
277 * @tc.type: FUNC
278 * @tc.require:The ConnStartLocalListening and ConnStopLocalListening operates normally.
279 */
280 HWTEST_F(ConnectionBleTest, ManagerTest003, TestSize.Level1)
281 {
282 ConnectCallback connCb;
283 connCb.OnConnected = ConnectedCB;
284 connCb.OnDisconnected = DisConnectedCB;
285 connCb.OnDataReceived = DataReceivedCB;
286 int32_t ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
287 EXPECT_EQ(ret, SOFTBUS_OK);
288
289 NiceMock<ConnectionBleInterfaceMock> bleMock;
290 EXPECT_CALL(bleMock, BleGattsAddService).WillRepeatedly(Return(SOFTBUS_OK));
291 LocalListenerInfo info;
292 info.type = CONNECT_BLE;
293 ret = ConnStartLocalListening(&info);
294 EXPECT_EQ(ret, SOFTBUS_OK);
295 ret = ConnStopLocalListening(&info);
296 EXPECT_EQ(ret, SOFTBUS_OK);
297 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
298 }
299
300 /*
301 * @tc.name: InterFaceFactoryTest
302 * @tc.desc: Test ConnBleGetUnifyInterface
303 * @tc.in: Test module, Test number, Test Levels.
304 * @tc.out: Zero
305 * @tc.type: FUNC
306 * @tc.require:
307 */
308 HWTEST_F(ConnectionBleTest, InterFaceFactoryTest001, TestSize.Level1)
309 {
310 const BleUnifyInterface *ret = ConnBleGetUnifyInterface(BLE_PROTOCOL_MAX);
311 EXPECT_EQ(nullptr, ret);
312 ret = ConnBleGetUnifyInterface(BLE_GATT);
313 EXPECT_NE(nullptr, ret);
314 }
315 }