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 class SoftBusUtilsTest : public testing::Test {
25 public:
SetUpTestCase(void)26 static void SetUpTestCase(void) {}
TearDownTestCase(void)27 static void TearDownTestCase(void) {}
28 };
29
MockSoftBusTimer(void)30 void MockSoftBusTimer(void)
31 {
32 }
33
34 /**
35 * @tc.name: SoftBusUtilsTest_CreateSoftBusList_001
36 * @tc.desc: Normal destroy softbus list test.
37 * @tc.type: FUNC
38 * @tc.require:
39 */
40 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_DestroySoftBusList_001, TestSize.Level1)
41 {
42 SoftBusList *list = CreateSoftBusList();
43 EXPECT_TRUE(NULL != list);
44 DestroySoftBusList(list);
45 }
46
47 /**
48 * @tc.name: SoftBusUtilsTest_CreateSoftBusList_001
49 * @tc.desc: Error register timeout callback test.
50 * @tc.type: FUNC
51 * @tc.require:
52 */
53 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_RegisterTimeoutCallback_001, TestSize.Level1)
54 {
55 int32_t timerFunId = SOFTBUS_CONN_TIMER_FUN;
56 TimerFunCallback callbac = NULL;
57 int32_t ret = RegisterTimeoutCallback(timerFunId, callbac);
58 EXPECT_EQ(SOFTBUS_ERR, ret);
59
60 callbac = MockSoftBusTimer;
61 timerFunId = SOFTBUS_CONN_TIMER_FUN - 1;
62 ret = RegisterTimeoutCallback(timerFunId, callbac);
63 EXPECT_EQ(SOFTBUS_ERR, ret);
64
65 timerFunId = SOFTBUS_MAX_TIMER_FUN_NUM;
66 ret = RegisterTimeoutCallback(timerFunId, callbac);
67 EXPECT_EQ(SOFTBUS_ERR, ret);
68 }
69
70 /**
71 * @tc.name: SoftBusUtilsTest_RegisterTimeoutCallback_002
72 * @tc.desc: Normal register timeout callback test.
73 * @tc.type: FUNC
74 * @tc.require:
75 */
76 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_RegisterTimeoutCallback_002, TestSize.Level1)
77 {
78 int32_t timerFunId = SOFTBUS_CONN_TIMER_FUN;
79 TimerFunCallback callbac = MockSoftBusTimer;
80 int32_t ret = RegisterTimeoutCallback(timerFunId, callbac);
81 EXPECT_EQ(SOFTBUS_OK, ret);
82
83 ret = RegisterTimeoutCallback(timerFunId, callbac);
84 EXPECT_EQ(SOFTBUS_OK, ret);
85
86 timerFunId = SOFTBUS_CONN_TIMER_FUN + 1;
87 ret = RegisterTimeoutCallback(timerFunId, callbac);
88 EXPECT_EQ(SOFTBUS_OK, ret);
89 }
90
91 /**
92 * @tc.name: SoftBusUtilsTest_SoftBusTimerInit_001
93 * @tc.desc: Normal timer init.
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerInit_001, TestSize.Level1)
98 {
99 int32_t ret = SoftBusTimerInit();
100 EXPECT_EQ(SOFTBUS_OK, ret);
101
102 ret = SoftBusTimerInit();
103 EXPECT_EQ(SOFTBUS_OK, ret);
104 }
105
106 /**
107 * @tc.name: SoftBusUtilsTest_SoftBusTimerDeInit_001
108 * @tc.desc: Normal timer deinit.
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerDeInit_001, TestSize.Level1)
113 {
114 int32_t ret = SoftBusTimerInit();
115 EXPECT_EQ(SOFTBUS_OK, ret);
116 SoftBusTimerDeInit();
117 }
118
119 /**
120 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_001
121 * @tc.desc: Parameter error when convert hex string to bytes.
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_001, TestSize.Level1)
126 {
127 unsigned char *outBuf = NULL;
128 uint32_t outBufLen = 0;
129 const char *inBuf = "41424344";
130 uint32_t inLen = 8;
131 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
132 EXPECT_EQ(SOFTBUS_ERR, ret);
133
134 unsigned char outBufArray[5] = "\0";
135 outBuf = outBufArray;
136 outBufLen = 5;
137 inBuf = NULL;
138 inLen = 0;
139 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
140 EXPECT_EQ(SOFTBUS_ERR, ret);
141
142 outBuf = outBufArray;
143 outBufLen = 5;
144 inBuf = "414243444";
145 inLen = 9;
146 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
147 EXPECT_EQ(SOFTBUS_ERR, ret);
148
149 outBuf = outBufArray;
150 outBufLen = 5;
151 inBuf = "414243FG";
152 inLen = 8;
153 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
154 EXPECT_EQ(SOFTBUS_ERR, ret);
155
156 outBuf = outBufArray;
157 outBufLen = 5;
158 inBuf = "414243GF";
159 inLen = 8;
160 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
161 EXPECT_EQ(SOFTBUS_ERR, ret);
162 }
163
164 /**
165 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_002
166 * @tc.desc: Normal convert hex string to bytes.
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_002, TestSize.Level1)
171 {
172 unsigned char outBuf[5] = "\0";
173 uint32_t outBufLen = 5;
174 const char *inBuf = "41424344";
175 uint32_t inLen = 8;
176 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
177 EXPECT_EQ(SOFTBUS_OK, ret);
178
179 const unsigned char expect[5] = "ABCD";
180 for (int i = 0; i < 5; i++) {
181 EXPECT_EQ(expect[i], outBuf[i]);
182 }
183 }
184
185 /**
186 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_001
187 * @tc.desc: Parameter error when convert bytes to hex string.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_001, TestSize.Level1)
192 {
193 char *outBuf = NULL;
194 uint32_t outBufLen = 0;
195 const unsigned char inBuf[5] = "ABCD";
196 uint32_t inLen = 4;
197 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
198 EXPECT_EQ(SOFTBUS_ERR, ret);
199
200 char outBufArray[5] = "\0";
201 outBuf = outBufArray;
202 outBufLen = 4;
203 inLen = 8;
204 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
205 EXPECT_EQ(SOFTBUS_ERR, ret);
206
207 outBufLen = 9;
208 const unsigned char *inBuf2 = NULL;
209 inLen = 0;
210 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf2, inLen);
211 EXPECT_EQ(SOFTBUS_ERR, ret);
212 }
213
214 /**
215 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_002
216 * @tc.desc: Normal convert bytes to hex string.
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_002, TestSize.Level1)
221 {
222 char outBuf[9] = "\0";
223 uint32_t outBufLen = 9;
224 unsigned char inBuf[5] = "abcd";
225 uint32_t inLen = 4;
226 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
227 EXPECT_EQ(SOFTBUS_OK, ret);
228
229 const char *expect = "61626364";
230 EXPECT_STREQ(expect, outBuf);
231 }
232
233 /**
234 * @tc.name: SoftBusUtilsTest_GenerateRandomStr_001
235 * @tc.desc: Parameter error when generate random string.
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_GenerateRandomStr_001, TestSize.Level1)
240 {
241 char *str = NULL;
242 uint32_t len = 4;
243 int32_t ret = GenerateRandomStr(str, len);
244 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
245
246 char str2[5] = "\0";
247 len = 1;
248 ret = GenerateRandomStr(str2, len);
249 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
250 }
251
252 /**
253 * @tc.name: SoftBusUtilsTest_IsValidString_001
254 * @tc.desc: Check string valid.
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_IsValidString_001, TestSize.Level1)
259 {
260 const char *input = nullptr;
261 uint32_t maxLen = 4;
262 EXPECT_FALSE(IsValidString(input, maxLen));
263
264 input = "";
265 maxLen = 4;
266 EXPECT_FALSE(IsValidString(input, maxLen));
267
268 input = "ABCDE";
269 maxLen = 4;
270 EXPECT_FALSE(IsValidString(input, maxLen));
271
272 input = "ABCDE";
273 maxLen = 5;
274 EXPECT_TRUE(IsValidString(input, maxLen));
275 }
276
277 /**
278 * @tc.name: SoftBusUtilsTest_ConvertBtMacToBinary_001
279 * @tc.desc: Parameter error when convert bt mac to binary.
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToBinary_001, TestSize.Level1)
284 {
285 const char *strMac = NULL;
286 uint32_t strMacLen = 0;
287 uint8_t *binMac = NULL;
288 uint32_t binMacLen = 0;
289 int32_t ret = ConvertBtMacToBinary(strMac, strMacLen, binMac, binMacLen);
290 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
291 }
292
293 /**
294 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_001
295 * @tc.desc: Parameter error when convert binary to bt mac.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_001, TestSize.Level1)
300 {
301 char *strMac = NULL;
302 uint32_t strMacLen = 0;
303 const uint8_t *binMac = NULL;
304 uint32_t binMacLen = 0;
305 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
306 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
307 }
308
309 /**
310 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_002
311 * @tc.desc: Normal convert binary to bt mac.
312 * @tc.type: FUNC
313 * @tc.require:
314 */
315 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_002, TestSize.Level1)
316 {
317 char strMac[19] = "\0";
318 uint32_t strMacLen = 18;
319 const uint8_t binMac[6] = { 101, 102, 103, 104, 105, 106 };
320 uint32_t binMacLen = 6;
321 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
322 EXPECT_EQ(SOFTBUS_OK, ret);
323
324 const char *expect = "65:66:67:68:69:6a";
325 EXPECT_STREQ(expect, strMac);
326 }
327 } // namespace OHOS