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