1 /*
2 * Copyright (c) 2022 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 "dslm_baselib_utils_test.h"
17
18 #include <gtest/gtest.h>
19
20 #include "file_ex.h"
21 #include "nativetoken_kit.h"
22 #include "securec.h"
23 #include "token_setproc.h"
24
25 #include "utils_base64.h"
26 #include "utils_datetime.h"
27 #include "utils_hexstring.h"
28 #include "utils_json.h"
29 #include "utils_mem.h"
30 #include "utils_state_machine.h"
31 #include "utils_timer.h"
32 #include "utils_tlv.h"
33
34 #define MAX_ENTRY 8
35 #define MAX_MALLOC_LEN (1 * 1024 * 1024)
36
37 using namespace std;
38 using namespace std::chrono;
39 using namespace testing;
40 using namespace testing::ext;
41
42 // for testing
43 extern "C" {
44 extern void DoTimerProcess(TimerProc callback, const void *context);
45 }
46
47 namespace OHOS {
48 namespace Security {
49 namespace DslmUnitTest {
SetUpTestCase()50 void DslmBaselibUtilsTest::SetUpTestCase()
51 {
52 }
TearDownTestCase()53 void DslmBaselibUtilsTest::TearDownTestCase()
54 {
55 }
SetUp()56 void DslmBaselibUtilsTest::SetUp()
57 {
58 }
TearDown()59 void DslmBaselibUtilsTest::TearDown()
60 {
61 }
62
63 /**
64 * @tc.name: Deserialize_case1
65 * @tc.desc: function Deserialize with malformed input
66 * @tc.type: FUNC
67 * @tc.require: issueNumber
68 */
69 HWTEST_F(DslmBaselibUtilsTest, Deserialize_case1, TestSize.Level0)
70 {
71 uint32_t cnt = 0;
72 TlvCommon tlvs[MAX_ENTRY];
73 // every entry has a sizeof(void *)-byte value
74 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
75
76 {
77 cnt = 0;
78 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
79 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
80
81 uint32_t ret = Deserialize(nullptr, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
82 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
83 }
84
85 {
86 // buff contains 10 entries which greater than MAX_ENTRY
87 int i;
88 // every entry has a sizeof(void *)-byte value
89 uint8_t buff[(MAX_ENTRY + 2) * sizeof(TlvCommon)] = {0};
90
91 cnt = 0;
92 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
93
94 for (i = 0; i < (MAX_ENTRY + 2); i++) {
95 TlvCommon *ptr = (TlvCommon *)buff + i;
96 ptr->tag = 0x105;
97 ptr->len = 4;
98 }
99
100 uint32_t ret = Deserialize(buff, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
101 EXPECT_EQ((uint32_t)TLV_ERR_BUFF_NO_ENOUGH, ret);
102 EXPECT_EQ(0U, cnt);
103 }
104 }
105
106 /**
107 * @tc.name: Deserialize_case2
108 * @tc.desc: function Deserialize with malformed input
109 * @tc.type: FUNC
110 * @tc.require: issueNumber
111 */
112 HWTEST_F(DslmBaselibUtilsTest, Deserialize_case2, TestSize.Level0)
113 {
114 int i;
115 uint32_t cnt = 0;
116 TlvCommon tlvs[MAX_ENTRY];
117 // every entry has a sizeof(void *)-byte value
118 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
119
120 // malformed tlv entry's len
121 cnt = 0;
122 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
123 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
124
125 for (i = 0; i < MAX_ENTRY; i++) {
126 TlvCommon *ptr = (TlvCommon *)buff + i;
127 ptr->tag = 0x105;
128 ptr->len = 0x100;
129 }
130
131 uint32_t ret = Deserialize(buff, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
132 EXPECT_EQ(0U, ret);
133 EXPECT_EQ(0U, cnt);
134 }
135
136 HWTEST_F(DslmBaselibUtilsTest, Deserialize_case3, TestSize.Level0)
137 {
138 uint32_t cnt = 0;
139 TlvCommon tlvs[MAX_ENTRY];
140
141 {
142 // buff contains 10 entries which greater than MAX_ENTRY
143 int i;
144 // every entry has a sizeof(void *)-byte value
145 uint8_t buff[(MAX_ENTRY + 2) * sizeof(TlvCommon)] = {0};
146
147 cnt = 0;
148 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
149
150 for (i = 0; i < (MAX_ENTRY + 2); i++) {
151 TlvCommon *ptr = (TlvCommon *)buff + i;
152 ptr->tag = 0x105;
153 ptr->len = 4;
154 }
155
156 uint32_t ret = Deserialize(buff, sizeof(buff), nullptr, MAX_ENTRY, &cnt);
157 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
158 }
159
160 {
161 // buff contains 10 entries which greater than MAX_ENTRY
162 int i;
163 // every entry has a sizeof(void *)-byte value
164 uint8_t buff[(MAX_ENTRY + 2) * sizeof(TlvCommon)] = {0};
165
166 cnt = 0;
167 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
168
169 for (i = 0; i < (MAX_ENTRY + 2); i++) {
170 TlvCommon *ptr = (TlvCommon *)buff + i;
171 ptr->tag = 0x105;
172 ptr->len = 4;
173 }
174
175 uint32_t ret = Deserialize(buff, sizeof(buff), &tlvs[0], MAX_ENTRY, nullptr);
176 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
177 }
178 }
179
180 /**
181 * @tc.name: Serialize_case1
182 * @tc.desc: function Serialize with malformed input
183 * @tc.type: FUNC
184 * @tc.require: issueNumber
185 */
186 HWTEST_F(DslmBaselibUtilsTest, Serialize_case1, TestSize.Level0)
187 {
188 uint32_t size = 0;
189 int i = 0;
190 TlvCommon tlvs[MAX_ENTRY];
191 // every entry has a sizeof(void *)-byte value
192 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
193
194 {
195 size = 0;
196 uint32_t ret = Serialize(nullptr, MAX_ENTRY, buff, sizeof(buff), &size);
197 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
198 }
199
200 {
201 // malformed max buffer size
202
203 size = 0;
204 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
205 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
206
207 for (i = 0; i < MAX_ENTRY; i++) {
208 TlvCommon *ptr = (TlvCommon *)tlvs + i;
209 ptr->tag = 0x105;
210 ptr->len = 4;
211 }
212
213 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, 1, &size);
214 EXPECT_EQ((uint32_t)TLV_ERR_BUFF_NO_ENOUGH, ret);
215 EXPECT_EQ(0U, size);
216 }
217 }
218
219 /**
220 * @tc.name: Serialize_case1
221 * @tc.desc: function Serialize with malformed input
222 * @tc.type: FUNC
223 * @tc.require: issueNumber
224 */
225 HWTEST_F(DslmBaselibUtilsTest, Serialize_case2, TestSize.Level0)
226 {
227 uint32_t size = 0;
228 int i = 0;
229 TlvCommon tlvs[MAX_ENTRY];
230 // every entry has a sizeof(void *)-byte value
231 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
232 {
233 // malformed tvl.len
234 size = 0;
235 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
236 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
237
238 for (i = 0; i < MAX_ENTRY; i++) {
239 TlvCommon *ptr = (TlvCommon *)tlvs + i;
240 ptr->tag = 0x105;
241 ptr->len = 0;
242 }
243
244 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, sizeof(buff), &size);
245 EXPECT_EQ(0U, ret);
246 // (TLV_TLV_HEAD_LEN + ptr->len) * MAX_ENTRY
247 EXPECT_EQ(32U, size);
248 }
249
250 {
251 // malformed tvl.value
252 size = 0;
253 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
254 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
255
256 for (i = 0; i < MAX_ENTRY; i++) {
257 TlvCommon *ptr = (TlvCommon *)tlvs + i;
258 ptr->tag = 0x105;
259 ptr->len = 4;
260 ptr->value = nullptr;
261 }
262
263 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, sizeof(buff), &size);
264 EXPECT_EQ(0U, ret);
265 // (TLV_TLV_HEAD_LEN + ptr->len) * MAX_ENTRY
266 EXPECT_EQ(64U, size);
267 }
268 }
269
270 HWTEST_F(DslmBaselibUtilsTest, Serialize_case3, TestSize.Level0)
271 {
272 uint32_t size = 0;
273 int i = 0;
274 TlvCommon tlvs[MAX_ENTRY];
275 // every entry has a sizeof(void *)-byte value
276 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
277
278 {
279 // malformed max buffer size
280
281 size = 0;
282 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
283 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
284
285 for (i = 0; i < MAX_ENTRY; i++) {
286 TlvCommon *ptr = (TlvCommon *)tlvs + i;
287 ptr->tag = 0x105;
288 ptr->len = 4;
289 }
290
291 uint32_t ret = Serialize(tlvs, MAX_ENTRY, nullptr, 1, &size);
292 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
293 }
294
295 {
296 // malformed max buffer size
297
298 size = 0;
299 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
300 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
301
302 for (i = 0; i < MAX_ENTRY; i++) {
303 TlvCommon *ptr = (TlvCommon *)tlvs + i;
304 ptr->tag = 0x105;
305 ptr->len = 4;
306 }
307
308 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, 1, nullptr);
309 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
310 }
311 }
312
313 /**
314 * @tc.name: GetDateTimeByMillisecondSince1970_case1
315 * @tc.desc: function GetDateTimeByMillisecondSince1970 with malformed input
316 * @tc.type: FUNC
317 * @tc.require: issueNumber
318 */
319 HWTEST_F(DslmBaselibUtilsTest, GetDateTimeByMillisecondSince1970_case1, TestSize.Level0)
320 {
321 uint64_t input = 0;
322
323 {
324 EXPECT_EQ(false, GetDateTimeByMillisecondSince1970(input, nullptr));
325 EXPECT_EQ(false, GetDateTimeByMillisecondSinceBoot(input, nullptr));
326 }
327
328 {
329 DoTimerProcess(nullptr, nullptr);
330 }
331 }
332
333 /**
334 * @tc.name: Base64UrlDecodeApp_case1
335 * @tc.desc: function Base64UrlDecodeApp with malformed input
336 * @tc.type: FUNC
337 * @tc.require: issueNumber
338 */
339 HWTEST_F(DslmBaselibUtilsTest, Base64UrlDecodeApp_case1, TestSize.Level0)
340 {
341 uint8_t src[] = {'a', '-', '_', 'd', '\0'};
342 uint8_t *to = nullptr;
343 {
344 int32_t ret = Base64UrlDecodeApp(nullptr, nullptr);
345 EXPECT_EQ(0, ret);
346 }
347
348 {
349 int32_t ret = Base64UrlDecodeApp(nullptr, &to);
350 EXPECT_EQ(0, ret);
351 }
352
353 {
354 int32_t ret = Base64UrlDecodeApp(src, nullptr);
355 EXPECT_EQ(0, ret);
356 }
357
358 {
359 int32_t ret = Base64UrlDecodeApp(src, &to);
360 ASSERT_NE(to, nullptr);
361
362 EXPECT_EQ(3, ret);
363 EXPECT_EQ('\xEF', to[1]);
364 EXPECT_EQ('\xDD', to[2]);
365 FREE(to);
366 }
367 }
368
369 /**
370 * @tc.name: Base64DecodeApp_case1
371 * @tc.desc: function Base64DecodeApp with malformed input
372 * @tc.type: FUNC
373 * @tc.require: issueNumber
374 */
375 HWTEST_F(DslmBaselibUtilsTest, Base64DecodeApp_case1, TestSize.Level0)
376 {
377 uint8_t *to = nullptr;
378
379 {
380 int32_t ret = Base64DecodeApp(nullptr, nullptr);
381 EXPECT_EQ(0, ret);
382 }
383
384 {
385 int32_t ret = Base64DecodeApp(nullptr, &to);
386 EXPECT_EQ(0, ret);
387 }
388
389 {
390 uint32_t maxStrLen = MAX_MALLOC_LEN / 3 * 4 + 10;
391 uint8_t *maxStr = (uint8_t *)MALLOC(sizeof(uint8_t) * maxStrLen);
392 ASSERT_NE(nullptr, maxStr);
393
394 memset_s(maxStr, maxStrLen - 1, 'c', maxStrLen - 1);
395
396 int32_t ret = Base64DecodeApp(maxStr, &to);
397 EXPECT_EQ(0, ret);
398 FREE(maxStr);
399 }
400
401 {
402 uint32_t maxStrLen = MAX_MALLOC_LEN / 3 * 4 + 10;
403 uint8_t *maxStr = (uint8_t *)MALLOC(sizeof(uint8_t) * maxStrLen);
404 ASSERT_NE(nullptr, maxStr);
405
406 memset_s(maxStr, maxStrLen - 1, 'c', maxStrLen - 1);
407
408 int32_t ret = Base64DecodeApp(maxStr, nullptr);
409 EXPECT_EQ(0, ret);
410 FREE(maxStr);
411 }
412 }
413
414 /**
415 * @tc.name: Base64EncodeApp_case1
416 * @tc.desc: function Base64EncodeApp with malformed input
417 * @tc.type: FUNC
418 * @tc.require: issueNumber
419 */
420 HWTEST_F(DslmBaselibUtilsTest, Base64EncodeApp_case1, TestSize.Level0)
421 {
422 uint8_t src[] = {'a', 'b', 'c', 'd', '\0'};
423
424 EXPECT_EQ(nullptr, Base64EncodeApp(nullptr, sizeof(src)));
425 EXPECT_EQ(nullptr, Base64EncodeApp(src, 0));
426
427 {
428 uint32_t maxStrLen = MAX_MALLOC_LEN / 4 * 3;
429 EXPECT_EQ(nullptr, Base64EncodeApp(src, maxStrLen));
430 }
431 }
432
433 /**
434 * @tc.name: InitStateMachine_case1
435 * @tc.desc: function InitStateMachine with malformed input
436 * @tc.type: FUNC
437 * @tc.require: issueNumber
438 */
439 HWTEST_F(DslmBaselibUtilsTest, InitStateMachine_case1, TestSize.Level0)
440 {
441 {
442 StateMachine *machine = nullptr;
443 uint32_t machineId = 0;
444 uint32_t initState = 0;
445
446 InitStateMachine(machine, machineId, initState);
447 EXPECT_EQ(nullptr, machine);
448 }
449
450 {
451 StateNode *node = nullptr;
452 uint32_t nodeCnt = 0;
453 StateMachine machine;
454 uint32_t event = 0;
455
456 ScheduleMachine(node, nodeCnt, &machine, event, nullptr);
457 EXPECT_EQ(nullptr, node);
458 }
459
460 {
461 StateNode node;
462 uint32_t nodeCnt = 0;
463 StateMachine machine;
464 uint32_t event = 0;
465
466 ScheduleMachine(&node, nodeCnt, &machine, event, nullptr);
467 }
468
469 {
470 StateNode node;
471 uint32_t nodeCnt = 1;
472 uint32_t event = 0;
473
474 ScheduleMachine(&node, nodeCnt, nullptr, event, nullptr);
475 }
476 }
477
478 /**
479 * @tc.name: DestroyJson_case1
480 * @tc.desc: function DslmDestroyJson with malformed input
481 * @tc.type: FUNC
482 * @tc.require: issueNumber
483 */
484 HWTEST_F(DslmBaselibUtilsTest, DestroyJson_case1, TestSize.Level0)
485 {
486 int32_t arr[10] = {0};
487 const char *field = "test";
488 const char *value = "add";
489
490 const char *str = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2}";
491 DslmJsonHandle handle = DslmCreateJson(str);
492
493 DslmDestroyJson(nullptr);
494 DslmAddFieldBoolToJson(nullptr, nullptr, true);
495 DslmAddFieldBoolToJson(nullptr, field, true);
496 DslmAddFieldIntToJson(nullptr, field, 0);
497 DslmAddFieldIntArrayToJson(nullptr, field, arr, sizeof(arr));
498 DslmAddFieldStringToJson(nullptr, field, value);
499 DslmAddFieldJsonToJson(handle, field, nullptr);
500
501 {
502 int32_t ret = DslmGetJsonFieldInt(nullptr, str);
503 EXPECT_EQ(-1, ret);
504
505 ret = DslmGetJsonFieldInt(handle, nullptr);
506 EXPECT_EQ(0, ret);
507 }
508
509 {
510 uint32_t ret = DslmGetJsonFieldIntArray(nullptr, nullptr, nullptr, 0);
511 EXPECT_EQ(0U, ret);
512 }
513
514 {
515 uint32_t ret = DslmGetJsonFieldIntArray(handle, nullptr, nullptr, 0);
516 EXPECT_EQ(0U, ret);
517 }
518
519 {
520 uint32_t ret = DslmGetJsonFieldIntArray(handle, str, nullptr, 0);
521 EXPECT_EQ(0U, ret);
522 }
523
524 {
525 uint32_t ret = DslmGetJsonFieldIntArray(nullptr, str, arr, sizeof(arr));
526 EXPECT_EQ(0U, ret);
527 }
528
529 {
530 const char *ret = DslmGetJsonFieldString(nullptr, str);
531 EXPECT_EQ(nullptr, ret);
532 }
533
534 {
535 const char *ret = DslmGetJsonFieldString(handle, nullptr);
536 EXPECT_EQ(nullptr, ret);
537 }
538
539 EXPECT_EQ(false, DslmCompareJsonData(handle, nullptr, true));
540
541 FREE(handle);
542 }
543
544 HWTEST_F(DslmBaselibUtilsTest, DestroyJson_case2, TestSize.Level0)
545 {
546 int32_t arr[10] = {0};
547 const char *field = "test";
548 const char *value = "add";
549
550 const char *str = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2}";
551 DslmJsonHandle handle = DslmCreateJson(str);
552
553 DslmAddFieldBoolToJson(handle, nullptr, true);
554 DslmAddFieldIntToJson(handle, nullptr, 0);
555 DslmAddFieldIntArrayToJson(handle, nullptr, arr, sizeof(arr));
556 DslmAddFieldIntArrayToJson(handle, field, nullptr, sizeof(arr));
557 DslmAddFieldStringToJson(handle, nullptr, value);
558 DslmAddFieldStringToJson(handle, field, nullptr);
559 DslmAddFieldJsonToJson(nullptr, nullptr, nullptr);
560 DslmAddFieldJsonToJson(handle, nullptr, nullptr);
561
562 EXPECT_EQ(false, DslmCompareJsonData(nullptr, nullptr, true));
563
564 FREE(handle);
565 }
566
567 /**
568 * @tc.name: GetJsonFieldInt_case1
569 * @tc.desc: function DslmGetJsonFieldInt with malformed input
570 * @tc.type: FUNC
571 * @tc.require: issueNumber
572 */
573 HWTEST_F(DslmBaselibUtilsTest, GetJsonFieldInt_case1, TestSize.Level0)
574 {
575 const char *str = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2}";
576 DslmJsonHandle handle = DslmCreateJson(str);
577
578 int32_t ret = DslmGetJsonFieldInt(handle, "challenge");
579 EXPECT_EQ(-1, ret);
580 FREE(handle);
581 }
582
583 /**
584 * @tc.name: GetJsonFieldIntArray_case1
585 * @tc.desc: function DslmGetJsonFieldIntArray with malformed input
586 * @tc.type: FUNC
587 * @tc.require: issueNumber
588 */
589 HWTEST_F(DslmBaselibUtilsTest, GetJsonFieldIntArray_case1, TestSize.Level0)
590 {
591 int32_t arr[5] = {0};
592 int32_t arrLen = sizeof(arr) / sizeof(arr[0]);
593 const char *str = "{\"version\":131072,\"challenge\":\"test challenge\",\"arr\":[\"3C1F21EE53D3C4E2\", \"elem2\", "
594 "3, 4, 5],\"type\":2}";
595 DslmJsonHandle handle = DslmCreateJson(str);
596
597 {
598 uint32_t ret = DslmGetJsonFieldIntArray(handle, "challenge", arr, arrLen);
599 EXPECT_EQ(0U, ret);
600 }
601
602 {
603 uint32_t ret = DslmGetJsonFieldIntArray(handle, "arr", arr, arrLen - 2);
604 EXPECT_EQ(1U, ret);
605 }
606
607 FREE(handle);
608 }
609
610 /**
611 * @tc.name: ByteToHexString_case1
612 * @tc.desc: function DslmByteToHexString with malformed input
613 * @tc.type: FUNC
614 * @tc.require: issueNumber
615 */
616 HWTEST_F(DslmBaselibUtilsTest, ByteToHexString_case1, TestSize.Level0)
617 {
618 const uint8_t hex[] = {0x1, 0xF, 0xE, 0x8, 0xA};
619 uint32_t hexLen = sizeof(hex);
620 uint8_t str[10] = {0};
621 uint32_t strLen = 10;
622
623 DslmByteToHexString(nullptr, 0, str, strLen);
624 EXPECT_EQ(0U, str[0]);
625
626 DslmByteToHexString(hex, hexLen, nullptr, 0);
627 EXPECT_EQ(0U, str[0]);
628
629 DslmByteToHexString(hex, hexLen, str, strLen - 1);
630 EXPECT_EQ(0U, str[0]);
631 }
632
633 /**
634 * @tc.name: HexStringToByte_case1
635 * @tc.desc: function DslmHexStringToByte with malformed input
636 * @tc.type: FUNC
637 * @tc.require: issueNumber
638 */
639 HWTEST_F(DslmBaselibUtilsTest, HexStringToByte_case1, TestSize.Level0)
640 {
641 uint32_t hexLen = 5;
642 uint32_t strLen = 10;
643 uint8_t hex[5] = {0};
644 char str[10] = {0};
645
646 {
647 int32_t ret = DslmHexStringToByte(nullptr, 0, hex, hexLen);
648 EXPECT_EQ(-1, ret);
649 EXPECT_EQ(0U, str[0]);
650 }
651
652 {
653 int32_t ret = DslmHexStringToByte(str, strLen, nullptr, 0);
654 EXPECT_EQ(-1, ret);
655 EXPECT_EQ(0U, str[0]);
656 }
657
658 {
659 int32_t ret = DslmHexStringToByte(str, strLen, hex, hexLen - 2);
660 EXPECT_EQ(-1, ret);
661 EXPECT_EQ(0U, str[0]);
662 }
663 }
664 } // namespace DslmUnitTest
665 } // namespace Security
666 } // namespace OHOS