1 /*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
17
18 #include "softbus_errcode.h"
19 #include "softbus_utils.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 constexpr uint32_t ERROR_CODE_SUB_SYSTEM_INDEX = 21;
25 constexpr uint32_t ERROR_CODE_MODULE_INDEX = 16;
26 constexpr uint32_t ERROR_CODE_SUB_SYSTEM_AND = 0x1FE00000;
27 constexpr uint32_t ERROR_CODE_MODULE_AND = 0x1F0000;
28
29 class SoftBusUtilsTest : public testing::Test {
30 public:
SetUpTestCase(void)31 static void SetUpTestCase(void) {}
TearDownTestCase(void)32 static void TearDownTestCase(void) {}
33 };
34
MockSoftBusTimer(void)35 void MockSoftBusTimer(void)
36 {
37 }
38
39 /**
40 * @tc.name: SoftBusUtilsTest_CreateSoftBusList_001
41 * @tc.desc: Normal destroy softbus list test.
42 * @tc.type: FUNC
43 * @tc.require:
44 */
45 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_DestroySoftBusList_001, TestSize.Level1)
46 {
47 SoftBusList *list = CreateSoftBusList();
48 EXPECT_TRUE(NULL != list);
49 DestroySoftBusList(list);
50 }
51
52 /**
53 * @tc.name: SoftBusUtilsTest_CreateSoftBusList_001
54 * @tc.desc: Error register timeout callback test.
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_RegisterTimeoutCallback_001, TestSize.Level1)
59 {
60 int32_t timerFunId = SOFTBUS_CONN_TIMER_FUN;
61 TimerFunCallback callbac = NULL;
62 int32_t ret = RegisterTimeoutCallback(timerFunId, callbac);
63 EXPECT_EQ(SOFTBUS_ERR, ret);
64
65 callbac = MockSoftBusTimer;
66 timerFunId = SOFTBUS_CONN_TIMER_FUN - 1;
67 ret = RegisterTimeoutCallback(timerFunId, callbac);
68 EXPECT_EQ(SOFTBUS_ERR, ret);
69
70 timerFunId = SOFTBUS_MAX_TIMER_FUN_NUM;
71 ret = RegisterTimeoutCallback(timerFunId, callbac);
72 EXPECT_EQ(SOFTBUS_ERR, ret);
73 }
74
75 /**
76 * @tc.name: SoftBusUtilsTest_RegisterTimeoutCallback_002
77 * @tc.desc: Normal register timeout callback test.
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_RegisterTimeoutCallback_002, TestSize.Level1)
82 {
83 int32_t timerFunId = SOFTBUS_CONN_TIMER_FUN;
84 TimerFunCallback callbac = MockSoftBusTimer;
85 int32_t ret = RegisterTimeoutCallback(timerFunId, callbac);
86 EXPECT_EQ(SOFTBUS_OK, ret);
87
88 ret = RegisterTimeoutCallback(timerFunId, callbac);
89 EXPECT_EQ(SOFTBUS_OK, ret);
90
91 timerFunId = SOFTBUS_CONN_TIMER_FUN + 1;
92 ret = RegisterTimeoutCallback(timerFunId, callbac);
93 EXPECT_EQ(SOFTBUS_OK, ret);
94 }
95
96 /**
97 * @tc.name: SoftBusUtilsTest_SoftBusTimerInit_001
98 * @tc.desc: Normal timer init.
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerInit_001, TestSize.Level1)
103 {
104 int32_t ret = SoftBusTimerInit();
105 EXPECT_EQ(SOFTBUS_OK, ret);
106
107 ret = SoftBusTimerInit();
108 EXPECT_EQ(SOFTBUS_OK, ret);
109 }
110
111 /**
112 * @tc.name: SoftBusUtilsTest_SoftBusTimerDeInit_001
113 * @tc.desc: Normal timer deinit.
114 * @tc.type: FUNC
115 * @tc.require:
116 */
117 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerDeInit_001, TestSize.Level1)
118 {
119 int32_t ret = SoftBusTimerInit();
120 EXPECT_EQ(SOFTBUS_OK, ret);
121 SoftBusTimerDeInit();
122 }
123
124 /**
125 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_001
126 * @tc.desc: Parameter error when convert hex string to bytes.
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_001, TestSize.Level1)
131 {
132 unsigned char *outBuf = NULL;
133 uint32_t outBufLen = 0;
134 const char *inBuf = "41424344";
135 uint32_t inLen = 8;
136 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
137 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
138
139 unsigned char outBufArray[5] = "\0";
140 outBuf = outBufArray;
141 outBufLen = 5;
142 inBuf = NULL;
143 inLen = 0;
144 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
145 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
146
147 outBuf = outBufArray;
148 outBufLen = 5;
149 inBuf = "414243444";
150 inLen = 9;
151 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
152 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
153
154 outBuf = outBufArray;
155 outBufLen = 5;
156 inBuf = "414243FG";
157 inLen = 8;
158 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
159 EXPECT_EQ(SOFTBUS_ERR, ret);
160
161 outBuf = outBufArray;
162 outBufLen = 5;
163 inBuf = "414243GF";
164 inLen = 8;
165 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
166 EXPECT_EQ(SOFTBUS_ERR, ret);
167 }
168
169 /**
170 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_002
171 * @tc.desc: Normal convert hex string to bytes.
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_002, TestSize.Level1)
176 {
177 unsigned char outBuf[5] = "\0";
178 uint32_t outBufLen = 5;
179 const char *inBuf = "41424344";
180 uint32_t inLen = 8;
181 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
182 EXPECT_EQ(SOFTBUS_OK, ret);
183
184 const unsigned char expect[5] = "ABCD";
185 for (int i = 0; i < 5; i++) {
186 EXPECT_EQ(expect[i], outBuf[i]);
187 }
188 }
189
190 /**
191 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_001
192 * @tc.desc: Parameter error when convert bytes to hex string.
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_001, TestSize.Level1)
197 {
198 char *outBuf = NULL;
199 uint32_t outBufLen = 0;
200 const unsigned char inBuf[5] = "ABCD";
201 uint32_t inLen = 4;
202 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
203 EXPECT_EQ(SOFTBUS_ERR, ret);
204
205 char outBufArray[5] = "\0";
206 outBuf = outBufArray;
207 outBufLen = 4;
208 inLen = 8;
209 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
210 EXPECT_EQ(SOFTBUS_ERR, ret);
211
212 outBufLen = 9;
213 const unsigned char *inBuf2 = NULL;
214 inLen = 0;
215 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf2, inLen);
216 EXPECT_EQ(SOFTBUS_ERR, ret);
217 }
218
219 /**
220 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_002
221 * @tc.desc: Normal convert bytes to hex string.
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_002, TestSize.Level1)
226 {
227 char outBuf[9] = "\0";
228 uint32_t outBufLen = 9;
229 unsigned char inBuf[5] = "abcd";
230 uint32_t inLen = 4;
231 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
232 EXPECT_EQ(SOFTBUS_OK, ret);
233
234 const char *expect = "61626364";
235 EXPECT_STREQ(expect, outBuf);
236 }
237
238 /**
239 * @tc.name: SoftBusUtilsTest_GenerateRandomStr_001
240 * @tc.desc: Parameter error when generate random string.
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_GenerateRandomStr_001, TestSize.Level1)
245 {
246 char *str = NULL;
247 uint32_t len = 4;
248 int32_t ret = GenerateRandomStr(str, len);
249 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
250
251 char str2[5] = "\0";
252 len = 1;
253 ret = GenerateRandomStr(str2, len);
254 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
255 }
256
257 /**
258 * @tc.name: SoftBusUtilsTest_IsValidString_001
259 * @tc.desc: Check string valid.
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_IsValidString_001, TestSize.Level1)
264 {
265 const char *input = nullptr;
266 uint32_t maxLen = 4;
267 EXPECT_FALSE(IsValidString(input, maxLen));
268
269 input = "";
270 maxLen = 4;
271 EXPECT_FALSE(IsValidString(input, maxLen));
272
273 input = "ABCDE";
274 maxLen = 4;
275 EXPECT_FALSE(IsValidString(input, maxLen));
276
277 input = "ABCDE";
278 maxLen = 5;
279 EXPECT_TRUE(IsValidString(input, maxLen));
280 }
281
282 /**
283 * @tc.name: SoftBusUtilsTest_ConvertBtMacToBinary_001
284 * @tc.desc: Parameter error when convert bt mac to binary.
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToBinary_001, TestSize.Level1)
289 {
290 const char *strMac = NULL;
291 uint32_t strMacLen = 0;
292 uint8_t *binMac = NULL;
293 uint32_t binMacLen = 0;
294 int32_t ret = ConvertBtMacToBinary(strMac, strMacLen, binMac, binMacLen);
295 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
296 }
297
298 /**
299 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_001
300 * @tc.desc: Parameter error when convert binary to bt mac.
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_001, TestSize.Level1)
305 {
306 char *strMac = NULL;
307 uint32_t strMacLen = 0;
308 const uint8_t *binMac = NULL;
309 uint32_t binMacLen = 0;
310 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
311 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
312 }
313
314 /**
315 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_002
316 * @tc.desc: Normal convert binary to bt mac.
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_002, TestSize.Level1)
321 {
322 char strMac[19] = "\0";
323 uint32_t strMacLen = 18;
324 const uint8_t binMac[6] = { 101, 102, 103, 104, 105, 106 };
325 uint32_t binMacLen = 6;
326 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
327 EXPECT_EQ(SOFTBUS_OK, ret);
328
329 const char *expect = "65:66:67:68:69:6a";
330 EXPECT_STREQ(expect, strMac);
331 }
332
333 /**
334 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_001
335 * @tc.desc: Test softbus event error code.
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_001, TestSize.Level1)
340 {
341 uint32_t errorCode = -SOFTBUS_PUBLIC_ERR_BASE;
342 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
343 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), PUBLIC_SUB_MODULE_CODE);
344 }
345
346 /**
347 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_002
348 * @tc.desc: Test disc event error code.
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_002, TestSize.Level1)
353 {
354 uint32_t errorCode = -SOFTBUS_DISCOVER_ERR_BASE;
355 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
356 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), DISC_SUB_MODULE_CODE);
357 }
358
359 /**
360 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_003
361 * @tc.desc: Test conn event error code.
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_003, TestSize.Level1)
366 {
367 uint32_t errorCode = -SOFTBUS_CONN_ERR_BASE;
368 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
369 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), CONN_SUB_MODULE_CODE);
370 }
371
372 /**
373 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_004
374 * @tc.desc: Test auth event error code.
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_004, TestSize.Level1)
379 {
380 uint32_t errorCode = -SOFTBUS_AUTH_ERR_BASE;
381 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
382 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), AUTH_SUB_MODULE_CODE);
383 }
384
385 /**
386 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_005
387 * @tc.desc: Test lnn event error code.
388 * @tc.type: FUNC
389 * @tc.require:
390 */
391 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_005, TestSize.Level1)
392 {
393 uint32_t errorCode = -SOFTBUS_NETWORK_ERR_BASE;
394 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
395 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), LNN_SUB_MODULE_CODE);
396 }
397
398 /**
399 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_006
400 * @tc.desc: Test trans event error code.
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_006, TestSize.Level1)
405 {
406 uint32_t errorCode = -SOFTBUS_TRANS_ERR_BASE;
407 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
408 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), TRANS_SUB_MODULE_CODE);
409 }
410 } // namespace OHOS