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 constexpr uint32_t TEST_MAX_LEN = 256;
29 constexpr uint32_t TEST_LEN = 8;
30
31 class SoftBusUtilsTest : public testing::Test {
32 public:
SetUpTestCase(void)33 static void SetUpTestCase(void) { }
TearDownTestCase(void)34 static void TearDownTestCase(void) { }
35 };
36
MockSoftBusTimer(void)37 void MockSoftBusTimer(void) { }
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(list != nullptr);
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 = nullptr;
62 int32_t ret = RegisterTimeoutCallback(timerFunId, callbac);
63 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
64
65 callbac = MockSoftBusTimer;
66 timerFunId = SOFTBUS_CONN_TIMER_FUN - 1;
67 ret = RegisterTimeoutCallback(timerFunId, callbac);
68 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
69
70 timerFunId = SOFTBUS_MAX_TIMER_FUN_NUM;
71 ret = RegisterTimeoutCallback(timerFunId, callbac);
72 EXPECT_EQ(SOFTBUS_INVALID_PARAM, 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_UnRegisterTimeoutCallback
98 * @tc.desc: Normal unregister timeout callback test.
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_UnRegisterTimeoutCallback, TestSize.Level1)
103 {
104 int32_t timerFunId = SOFTBUS_CONN_TIMER_FUN - 1;
105 int32_t ret = UnRegisterTimeoutCallback(timerFunId);
106 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
107
108 timerFunId = SOFTBUS_MAX_TIMER_FUN_NUM;
109 ret = UnRegisterTimeoutCallback(timerFunId);
110 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
111
112 timerFunId = SOFTBUS_CONN_TIMER_FUN;
113 ret = UnRegisterTimeoutCallback(timerFunId);
114 EXPECT_EQ(SOFTBUS_OK, ret);
115 }
116
117 /**
118 * @tc.name: SoftBusUtilsTest_SoftBusTimerInit_001
119 * @tc.desc: Normal timer init.
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerInit_001, TestSize.Level1)
124 {
125 int32_t ret = SoftBusTimerInit();
126 EXPECT_EQ(SOFTBUS_OK, ret);
127
128 ret = SoftBusTimerInit();
129 EXPECT_EQ(SOFTBUS_OK, ret);
130 }
131
132 /**
133 * @tc.name: SoftBusUtilsTest_SoftBusTimerDeInit_001
134 * @tc.desc: Normal timer deinit.
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftBusTimerDeInit_001, TestSize.Level1)
139 {
140 int32_t ret = SoftBusTimerInit();
141 EXPECT_EQ(SOFTBUS_OK, ret);
142 SoftBusTimerDeInit();
143 }
144
145 /**
146 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_001
147 * @tc.desc: Parameter error when convert hex string to bytes.
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_001, TestSize.Level1)
152 {
153 unsigned char *outBuf = nullptr;
154 uint32_t outBufLen = 0;
155 const char *inBuf = "41424344";
156 uint32_t inLen = 8;
157 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
158 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
159
160 unsigned char outBufArray[5] = "\0";
161 outBuf = outBufArray;
162 outBufLen = 5;
163 inBuf = nullptr;
164 inLen = 0;
165 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
166 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
167
168 outBuf = outBufArray;
169 outBufLen = 5;
170 inBuf = "414243444";
171 inLen = 9;
172 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
173 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
174
175 outBuf = outBufArray;
176 outBufLen = 5;
177 inBuf = "414243FG";
178 inLen = 8;
179 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
180 EXPECT_EQ(SOFTBUS_ERR, ret);
181
182 outBuf = outBufArray;
183 outBufLen = 5;
184 inBuf = "414243GF";
185 inLen = 8;
186 ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
187 EXPECT_EQ(SOFTBUS_ERR, ret);
188 }
189
190 /**
191 * @tc.name: SoftBusUtilsTest_ConvertHexStringToBytes_002
192 * @tc.desc: Normal convert hex string to bytes.
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertHexStringToBytes_002, TestSize.Level1)
197 {
198 unsigned char outBuf[5] = "\0";
199 uint32_t outBufLen = 5;
200 const char *inBuf = "41424344";
201 uint32_t inLen = 8;
202 int32_t ret = ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen);
203 EXPECT_EQ(SOFTBUS_OK, ret);
204
205 const unsigned char expect[5] = "ABCD";
206 for (int32_t i = 0; i < 5; i++) {
207 EXPECT_EQ(expect[i], outBuf[i]);
208 }
209 }
210
211 /**
212 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_001
213 * @tc.desc: Parameter error when convert bytes to hex string.
214 * @tc.type: FUNC
215 * @tc.require:
216 */
217 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_001, TestSize.Level1)
218 {
219 char *outBuf = nullptr;
220 uint32_t outBufLen = 0;
221 const unsigned char inBuf[5] = "ABCD";
222 uint32_t inLen = 4;
223 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
224 EXPECT_EQ(SOFTBUS_ERR, ret);
225
226 char outBufArray[5] = "\0";
227 outBuf = outBufArray;
228 outBufLen = 4;
229 inLen = 8;
230 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
231 EXPECT_EQ(SOFTBUS_ERR, ret);
232
233 outBufLen = 9;
234 const unsigned char *inBuf2 = nullptr;
235 inLen = 0;
236 ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf2, inLen);
237 EXPECT_EQ(SOFTBUS_ERR, ret);
238 }
239
240 /**
241 * @tc.name: SoftBusUtilsTest_ConvertBytesToHexString_002
242 * @tc.desc: Normal convert bytes to hex string.
243 * @tc.type: FUNC
244 * @tc.require:
245 */
246 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBytesToHexString_002, TestSize.Level1)
247 {
248 char outBuf[9] = "\0";
249 uint32_t outBufLen = 9;
250 unsigned char inBuf[5] = "abcd";
251 uint32_t inLen = 4;
252 int32_t ret = ConvertBytesToHexString(outBuf, outBufLen, inBuf, inLen);
253 EXPECT_EQ(SOFTBUS_OK, ret);
254
255 const char *expect = "61626364";
256 EXPECT_STREQ(expect, outBuf);
257 }
258
259 /**
260 * @tc.name: SoftBusUtilsTest_GenerateRandomStr_001
261 * @tc.desc: Parameter error when generate random string.
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_GenerateRandomStr_001, TestSize.Level1)
266 {
267 char *str = nullptr;
268 uint32_t len = 4;
269 int32_t ret = GenerateRandomStr(str, len);
270 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
271
272 char str2[5] = "\0";
273 len = 1;
274 ret = GenerateRandomStr(str2, len);
275 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
276 }
277
278 /**
279 * @tc.name: SoftBusUtilsTest_IsValidString_001
280 * @tc.desc: Check string valid.
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_IsValidString_001, TestSize.Level1)
285 {
286 const char *input = nullptr;
287 uint32_t maxLen = 4;
288 EXPECT_FALSE(IsValidString(input, maxLen));
289
290 input = "";
291 maxLen = 4;
292 EXPECT_FALSE(IsValidString(input, maxLen));
293
294 input = "ABCDE";
295 maxLen = 4;
296 EXPECT_FALSE(IsValidString(input, maxLen));
297
298 input = "ABCDE";
299 maxLen = 5;
300 EXPECT_TRUE(IsValidString(input, maxLen));
301 }
302
303 /**
304 * @tc.name: SoftBusUtilsTest_ConvertBtMacToBinary_001
305 * @tc.desc: Parameter error when convert bt mac to binary.
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToBinary_001, TestSize.Level1)
310 {
311 const char *strMac = nullptr;
312 uint32_t strMacLen = 0;
313 uint8_t *binMac = nullptr;
314 uint32_t binMacLen = 0;
315 int32_t ret = ConvertBtMacToBinary(strMac, strMacLen, binMac, binMacLen);
316 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
317 }
318
319 /**
320 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_001
321 * @tc.desc: Parameter error when convert binary to bt mac.
322 * @tc.type: FUNC
323 * @tc.require:
324 */
325 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_001, TestSize.Level1)
326 {
327 char *strMac = nullptr;
328 uint32_t strMacLen = 0;
329 const uint8_t *binMac = nullptr;
330 uint32_t binMacLen = 0;
331 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
332 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
333 }
334
335 /**
336 * @tc.name: SoftBusUtilsTest_ConvertBtMacToStr_002
337 * @tc.desc: Normal convert binary to bt mac.
338 * @tc.type: FUNC
339 * @tc.require:
340 */
341 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_ConvertBtMacToStr_002, TestSize.Level1)
342 {
343 char strMac[19] = "\0";
344 uint32_t strMacLen = 18;
345 const uint8_t binMac[6] = { 101, 102, 103, 104, 105, 106 };
346 uint32_t binMacLen = 6;
347 int32_t ret = ConvertBtMacToStr(strMac, strMacLen, binMac, binMacLen);
348 EXPECT_EQ(SOFTBUS_OK, ret);
349
350 const char *expect = "65:66:67:68:69:6a";
351 EXPECT_STREQ(expect, strMac);
352 }
353
354 /**
355 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_001
356 * @tc.desc: Test softbus event error code.
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_001, TestSize.Level1)
361 {
362 uint32_t errorCode = -SOFTBUS_PUBLIC_ERR_BASE;
363 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
364 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), PUBLIC_SUB_MODULE_CODE);
365 }
366
367 /**
368 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_002
369 * @tc.desc: Test disc event error code.
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_002, TestSize.Level1)
374 {
375 uint32_t errorCode = -SOFTBUS_DISCOVER_ERR_BASE;
376 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
377 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), DISC_SUB_MODULE_CODE);
378 }
379
380 /**
381 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_003
382 * @tc.desc: Test conn event error code.
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_003, TestSize.Level1)
387 {
388 uint32_t errorCode = -SOFTBUS_CONN_ERR_BASE;
389 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
390 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), CONN_SUB_MODULE_CODE);
391 }
392
393 /**
394 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_004
395 * @tc.desc: Test auth event error code.
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_004, TestSize.Level1)
400 {
401 uint32_t errorCode = -SOFTBUS_AUTH_ERR_BASE;
402 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
403 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), AUTH_SUB_MODULE_CODE);
404 }
405
406 /**
407 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_005
408 * @tc.desc: Test lnn event error code.
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_005, TestSize.Level1)
413 {
414 uint32_t errorCode = -SOFTBUS_NETWORK_ERR_BASE;
415 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
416 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), LNN_SUB_MODULE_CODE);
417 }
418
419 /**
420 * @tc.name: SoftBusUtilsTest_SoftbusErrorCodeStandard_006
421 * @tc.desc: Test trans event error code.
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(SoftBusUtilsTest, SoftBusUtilsTest_SoftbusErrorCodeStandard_006, TestSize.Level1)
426 {
427 uint32_t errorCode = -SOFTBUS_TRANS_ERR_BASE;
428 EXPECT_EQ(((errorCode & ERROR_CODE_SUB_SYSTEM_AND) >> ERROR_CODE_SUB_SYSTEM_INDEX), SOFTBUS_SUB_SYSTEM);
429 EXPECT_EQ(((errorCode & ERROR_CODE_MODULE_AND) >> ERROR_CODE_MODULE_INDEX), TRANS_SUB_MODULE_CODE);
430 }
431
432 /**
433 * @tc.name: SoftBusUtilsTest_CalculateMbsTruncateSize001
434 * @tc.desc: Test CalculateMbsTruncateSize with null str.
435 * @tc.type: FUNC
436 * @tc.require:
437 */
438 HWTEST_F(SoftBusUtilsTest, CalculateMbsTruncateSize001, TestSize.Level1)
439 {
440 uint32_t maxCapacity = 15;
441 char multiByteStr[] = "";
442 uint32_t exceptSize = 0;
443 uint32_t truncatedSize = 0;
444
445 for (uint32_t capacity = 0; capacity < maxCapacity; ++capacity) {
446 int32_t ret = CalculateMbsTruncateSize(multiByteStr, capacity, &truncatedSize);
447 EXPECT_EQ(ret, SOFTBUS_OK);
448 EXPECT_EQ(truncatedSize, exceptSize);
449 }
450 }
451
452 /**
453 * @tc.name: SoftBusUtilsTest_CalculateMbsTruncateSize002
454 * @tc.desc: Test CalculateMbsTruncateSize with ascii str.
455 * @tc.type: FUNC
456 * @tc.require:
457 */
458 HWTEST_F(SoftBusUtilsTest, CalculateMbsTruncateSize002, TestSize.Level1)
459 {
460 uint32_t maxCapacity = 25;
461 char multiByteStr[] = "ABCDEF Ghig 12 Klm";
462 uint32_t exceptSize[] = {
463 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
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
474 /**
475 * @tc.name: SoftBusUtilsTest_CalculateMbsTruncateSize003
476 * @tc.desc: Test CalculateMbsTruncateSize with utf-8 str.
477 * @tc.type: FUNC
478 * @tc.require:
479 */
480 HWTEST_F(SoftBusUtilsTest, CalculateMbsTruncateSize003, TestSize.Level1)
481 {
482 uint32_t maxCapacity = 40;
483 char multiByteStr[] = "床前明月,光疑是地上霜。";
484 uint32_t exceptSize[] = {
485 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,
486 31, 31, 31, 34, 34, 34, 34, 34, 34
487 };
488 uint32_t truncatedSize = 0;
489
490 for (uint32_t capacity = 0; capacity < maxCapacity; ++capacity) {
491 int32_t ret = CalculateMbsTruncateSize(multiByteStr, capacity, &truncatedSize);
492 EXPECT_EQ(ret, SOFTBUS_OK);
493 EXPECT_EQ(truncatedSize, exceptSize[capacity]);
494 }
495 }
496
497 /**
498 * @tc.name: AddNumberToSocketName001
499 * @tc.desc: Test Add Number To Socket Name
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(SoftBusUtilsTest, AddNumberToSocketName001, TestSize.Level1)
504 {
505 uint32_t num = 1;
506 uint32_t preLen = TEST_MAX_LEN;
507 const char *testName = "socket_";
508 char socketName[SESSION_NAME_SIZE_MAX] = { 0 };
509 int32_t ret = AddNumberToSocketName(num, testName, preLen, nullptr);
510 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
511 ret = AddNumberToSocketName(num, nullptr, preLen, socketName);
512 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
513 ret = AddNumberToSocketName(num, testName, preLen, socketName);
514 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
515 preLen = 1;
516 ret = AddNumberToSocketName(num, testName, preLen, socketName);
517 EXPECT_EQ(ret, SOFTBUS_STRCPY_ERR);
518 preLen = TEST_LEN;
519 ret = AddNumberToSocketName(num, testName, preLen, socketName);
520 EXPECT_EQ(ret, SOFTBUS_OK);
521 }
522 } // namespace OHOS