1 /*
2 * Copyright (C) 2022-2025 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 "common_lib_test.h"
17 #include <gtest/gtest.h>
18 #include <cstdint>
19 #include <cstdlib>
20 #include <cstring>
21 #include <cstddef>
22 #include "securec.h"
23 #include "base/security/device_auth/common_lib/impl/src/hc_parcel.c"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace {
29 static const uint32_t TEST_BUFFER_SIZE = 16;
30 static const uint32_t TEST_MIN_ANONYMOUS_LEN = 12;
31 static const uint32_t TEST_INVALID_BUFFER_SIZE = 0;
32 static const uint32_t TEST_LENGTH_ZERO = 0;
33 static const uint32_t TEST_SRC_DATA = 4;
34 static const uint32_t TEST_UINT32_SIZE = 4;
35 static const uint32_t MAX_TLV_LENGTH = 32768;
36 static const uint32_t PARCEL_POS_0 = 0;
37 static const uint32_t PARCEL_POS_1 = 1;
38 const uint32_t PARCEL_UINT_MAX = 0xffffffffU;
39 static const char *TEST_JSON_STR = "{\"name\":\"test_name\", \"age\":18}";
40 static const char *TEST_JSON_STR_ARR = "[{\"name\":\"Tom1\",\"age\":18},{\"name\":\"Tom2\",\"age\":19}]";
41 static const char *TEST_STR = "test_str";
42 static const char TEST_CHAR = '0';
43
44 class CommonLibTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp();
49 void TearDown();
50 };
51
SetUpTestCase()52 void CommonLibTest::SetUpTestCase() {}
TearDownTestCase()53 void CommonLibTest::TearDownTestCase() {}
SetUp()54 void CommonLibTest::SetUp() {}
TearDown()55 void CommonLibTest::TearDown() {}
56
57 HWTEST_F(CommonLibTest, HcParcelNullPtrTest001, TestSize.Level0)
58 {
59 HcParcel *parcelNull = nullptr;
60 ClearParcel(parcelNull);
61 EXPECT_EQ(nullptr, parcelNull);
62 ResetParcel(parcelNull, 1, 1);
63 HcParcel parcel;
64 void *dstNull = nullptr;
65 HcBool ret = ParcelEraseBlock(&parcel, 1, 1, dstNull);
66 EXPECT_EQ(ret, HC_FALSE);
67 ret = ParcelIncrease(parcelNull, 1);
68 EXPECT_EQ(ret, HC_FALSE);
69 ret = ParcelIncrease(&parcel, 0);
70 EXPECT_EQ(ret, HC_FALSE);
71 ParcelRecycle(parcelNull);
72 const void *srcNull = nullptr;
73 ret = ParcelWrite(&parcel, srcNull, 1);
74 EXPECT_EQ(ret, HC_FALSE);
75 ret = ParcelPopBack(parcelNull, 1);
76 EXPECT_EQ(ret, HC_FALSE);
77 ret = ParcelPopBack(&parcel, 0);
78 EXPECT_EQ(ret, HC_FALSE);
79 ret = ParcelPopFront(parcelNull, 1);
80 EXPECT_EQ(ret, HC_FALSE);
81 ret = ParcelPopFront(&parcel, 0);
82 EXPECT_EQ(ret, HC_FALSE);
83 DataRevert(parcelNull, 0);
84 ret = ParcelCopy(&parcel, parcelNull);
85 EXPECT_EQ(ret, HC_FALSE);
86 ret = ParcelReadParcel(&parcel, parcelNull, 0, HC_TRUE);
87 EXPECT_EQ(ret, HC_FALSE);
88 }
89
90 HWTEST_F(CommonLibTest, HcParcelNullPtrTest002, TestSize.Level0)
91 {
92 HcParcel *parcelNull = nullptr;
93 HcParcel parcel;
94 uint32_t ret = GetParcelIncreaseSize(parcelNull, 1);
95 EXPECT_EQ(ret, 0);
96 parcel.allocUnit = 0;
97 ret = GetParcelIncreaseSize(&parcel, 1);
98 EXPECT_EQ(ret, 0);
99 }
100
101 HWTEST_F(CommonLibTest, HcParcelInValidDataSizeTest001, TestSize.Level0)
102 {
103 HcParcel parcel;
104 parcel.beginPos = PARCEL_POS_1;
105 parcel.endPos = PARCEL_POS_0;
106 int32_t ret = GetParcelDataSize(&parcel);
107 EXPECT_EQ(ret, 0);
108 const char *retStr = GetParcelLastChar(&parcel);
109 EXPECT_EQ(retStr, nullptr);
110 parcel.beginPos = PARCEL_POS_0;
111 parcel.endPos = PARCEL_POS_1;
112 parcel.allocUnit = 0;
113 ParcelRecycle(&parcel);
114 }
115
116 HWTEST_F(CommonLibTest, HcParcelInValidDataSizeTest002, TestSize.Level0)
117 {
118 HcParcel parcel;
119 uint32_t data = 1;
120 HcBool ret = ParcelEraseBlock(&parcel, 1, 0, &data);
121 EXPECT_EQ(ret, HC_FALSE);
122 ret = ParcelWriteRevert(&parcel, &data, 0);
123 EXPECT_EQ(ret, HC_FALSE);
124 parcel.length = 1;
125 ret = ParcelRealloc(&parcel, 0);
126 EXPECT_EQ(ret, HC_FALSE);
127 parcel.data = nullptr;
128 ret = ParcelIncrease(&parcel, 1);
129 EXPECT_EQ(ret, HC_FALSE);
130 }
131
132 HWTEST_F(CommonLibTest, HcParcelReadRevertTest001, TestSize.Level0)
133 {
134 HcParcel parcel = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
135 HcParcel *parcelNull = nullptr;
136 int32_t int32Dst = 0;
137 uint32_t uint32Dst = 0;
138 int16_t int16Dst = 0;
139 uint16_t uint16Dst = 0;
140 uint16_t *uint16DstNull = nullptr;
141 int64_t int64Dst = 0;
142 uint64_t uint64Dst = 0;
143
144 HcBool ret = ParcelReadInt32Revert(&parcel, &int32Dst);
145 EXPECT_EQ(ret, HC_FALSE);
146 ret = ParcelReadUint32Revert(&parcel, &uint32Dst);
147 EXPECT_EQ(ret, HC_FALSE);
148 ret = ParcelReadInt16Revert(&parcel, &int16Dst);
149 EXPECT_EQ(ret, HC_FALSE);
150 ret = ParcelReadUint16Revert(&parcel, &uint16Dst);
151 EXPECT_EQ(ret, HC_FALSE);
152 ret = ParcelReadUint16Revert(&parcel, uint16DstNull);
153 EXPECT_EQ(ret, HC_FALSE);
154 ret = ParcelReadUint16Revert(parcelNull, &uint16Dst);
155 EXPECT_EQ(ret, HC_FALSE);
156 ret = ParcelReadUint16Revert(&parcel, &uint16Dst);
157 EXPECT_EQ(ret, HC_FALSE);
158 ret = ParcelReadInt64Revert(&parcel, &int64Dst);
159 EXPECT_EQ(ret, HC_FALSE);
160 ret = ParcelReadUint64Revert(&parcel, &uint64Dst);
161 EXPECT_EQ(ret, HC_FALSE);
162 DeleteParcel(&parcel);
163 }
164
165 HWTEST_F(CommonLibTest, HcParcelCreateTest001, TestSize.Level0)
166 {
167 HcParcel parcelNullData = CreateParcel(TEST_INVALID_BUFFER_SIZE, PARCEL_DEFAULT_ALLOC_UNIT);
168 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, PARCEL_DEFAULT_ALLOC_UNIT);
169 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
170 uint32_t invalidLength = GetParcelDataSize(nullptr);
171 EXPECT_EQ(invalidLength, TEST_LENGTH_ZERO);
172 uint32_t validLength = GetParcelDataSize(&parcelWithData);
173 EXPECT_EQ(validLength, TEST_UINT32_SIZE);
174 const char *invalidData = GetParcelData(nullptr);
175 EXPECT_EQ(invalidData, nullptr);
176 const char *validData = GetParcelData(&parcelWithData);
177 EXPECT_NE(validData, nullptr);
178 const char *invalidLastChar = GetParcelLastChar(nullptr);
179 EXPECT_EQ(invalidLastChar, nullptr);
180 const char *validLastChar = GetParcelLastChar(&parcelWithData);
181 EXPECT_NE(validLastChar, nullptr);
182 ClearParcel(&parcelWithData);
183 ResetParcel(&parcelWithData, TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
184 DeleteParcel(nullptr);
185 DeleteParcel(&parcelNullData);
186 DeleteParcel(&parcelWithData);
187 }
188
189 HWTEST_F(CommonLibTest, HcParcelReadTest001, TestSize.Level0)
190 {
191 uint32_t num = 0;
192 uint32_t uintDataSize = sizeof(uint32_t);
193 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
194 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
195 HcBool ret = ParcelReadWithoutPopData(&parcelWithData, &num, uintDataSize);
196 EXPECT_EQ(ret, HC_TRUE);
197 ret = ParcelRead(nullptr, nullptr, uintDataSize);
198 EXPECT_EQ(ret, HC_FALSE);
199 ret = ParcelRead(&parcelWithData, &num, uintDataSize);
200 EXPECT_EQ(ret, HC_TRUE);
201 parcelWithData.beginPos = PARCEL_UINT_MAX - uintDataSize;
202 ret = ParcelRead(&parcelWithData, &num, uintDataSize);
203 parcelWithData.beginPos = 0;
204 parcelWithData.endPos = 0;
205 ret = ParcelRead(&parcelWithData, &num, uintDataSize);
206 EXPECT_EQ(ret, HC_FALSE);
207 DeleteParcel(&parcelWithData);
208 }
209
210 HWTEST_F(CommonLibTest, HcParcelEraseBlockTest001, TestSize.Level0)
211 {
212 uint32_t start = 0;
213 uint32_t num = 0;
214 uint32_t uintDataSize = sizeof(uint32_t);
215 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
216 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
217 HcBool ret = ParcelEraseBlock(nullptr, start, uintDataSize, &num);
218 EXPECT_EQ(ret, HC_FALSE);
219 ret = ParcelEraseBlock(&parcelWithData, PARCEL_UINT_MAX, uintDataSize, &num);
220 EXPECT_EQ(ret, HC_FALSE);
221 ret = ParcelEraseBlock(&parcelWithData, PARCEL_UINT_MAX - uintDataSize, uintDataSize, &num);
222 EXPECT_EQ(ret, HC_FALSE);
223 ret = ParcelEraseBlock(&parcelWithData, start, uintDataSize, &num);
224 EXPECT_EQ(ret, HC_TRUE);
225 DeleteParcel(&parcelWithData);
226 }
227
228 HWTEST_F(CommonLibTest, HcParcelRevertTest001, TestSize.Level0)
229 {
230 uint32_t num = 0;
231 uint32_t uintDataSize = sizeof(uint32_t);
232 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
233 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
234 HcBool ret = ParcelReadRevert(&parcelWithData, &num, TEST_LENGTH_ZERO);
235 EXPECT_EQ(ret, HC_FALSE);
236 ret = ParcelReadRevert(&parcelWithData, &num, uintDataSize);
237 EXPECT_EQ(ret, HC_TRUE);
238 ret = ParcelWriteRevert(nullptr, &num, uintDataSize);
239 DeleteParcel(&parcelWithData);
240 }
241
242 HWTEST_F(CommonLibTest, HcParcelReadWrite001, TestSize.Level0)
243 {
244 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
245 int32_t srcInt = 0;
246 int32_t dstInt = 0;
247 HcBool ret = ParcelWriteInt32(&parcelWithData, srcInt);
248 ret = ParcelReadInt32(&parcelWithData, &dstInt);
249 EXPECT_EQ(ret, HC_TRUE);
250 uint32_t srcUint32 = 0;
251 uint32_t dstUint32 = 0;
252 ret = ParcelWriteUint32(&parcelWithData, srcUint32);
253 ret = ParcelReadUint32(&parcelWithData, &dstUint32);
254 EXPECT_EQ(ret, HC_TRUE);
255 short srcInt16 = 0;
256 short dstInt16 = 0;
257 ret = ParcelWriteInt16(&parcelWithData, srcInt16);
258 ret = ParcelReadInt16(&parcelWithData, &dstInt16);
259 EXPECT_EQ(ret, HC_TRUE);
260 uint16_t srcUint16 = 0;
261 uint16_t dstUint16 = 0;
262 ret = ParcelWriteUint16(&parcelWithData, srcUint16);
263 ret = ParcelReadUint16(&parcelWithData, &dstUint16);
264 EXPECT_EQ(ret, HC_TRUE);
265 char srcInt8 = 0;
266 char dstInt8 = 0;
267 ret = ParcelWriteInt8(&parcelWithData, srcInt8);
268 ret = ParcelReadInt8(&parcelWithData, &dstInt8);
269 EXPECT_EQ(ret, HC_TRUE);
270 uint8_t srcUint8 = 0;
271 uint8_t dstUint8 = 0;
272 ret = ParcelWriteUint8(&parcelWithData, srcUint8);
273 ret = ParcelReadUint8(&parcelWithData, &dstUint8);
274 EXPECT_EQ(ret, HC_TRUE);
275 int64_t srcInt64 = 0;
276 int64_t dstInt64 = 0;
277 ret = ParcelWriteInt64(&parcelWithData, srcInt64);
278 ret = ParcelReadInt64(&parcelWithData, &dstInt64);
279 EXPECT_EQ(ret, HC_TRUE);
280 uint64_t srcUint64 = 0;
281 uint64_t dstUint64 = 0;
282 ret = ParcelWriteUint64(&parcelWithData, srcUint64);
283 ret = ParcelReadUint64(&parcelWithData, &dstUint64);
284 EXPECT_EQ(ret, HC_TRUE);
285 DeleteParcel(&parcelWithData);
286 }
287
288 HWTEST_F(CommonLibTest, HcParcelRealloc001, TestSize.Level0)
289 {
290 HcParcel parcelSrc = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
291 HcParcel parcelDst = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
292 HcBool ret = ParcelWriteInt32(&parcelSrc, TEST_SRC_DATA);
293 EXPECT_EQ(ret, HC_TRUE);
294 uint32_t data01 = 0;
295 uint64_t data02 = 0;
296 uint32_t validLen = sizeof(data01);
297 uint32_t invalidLen = sizeof(data02);
298 ret = ParcelReadParcel(nullptr, nullptr, validLen, HC_FALSE);
299 EXPECT_EQ(ret, HC_FALSE);
300 ret = ParcelReadParcel(&parcelSrc, &parcelDst, invalidLen, HC_FALSE);
301 EXPECT_EQ(ret, HC_FALSE);
302 ret = ParcelReadParcel(&parcelSrc, &parcelDst, TEST_LENGTH_ZERO, HC_FALSE);
303 EXPECT_EQ(ret, HC_FALSE);
304 ret = ParcelReadParcel(&parcelSrc, &parcelDst, validLen, HC_FALSE);
305 EXPECT_EQ(ret, HC_TRUE);
306 DeleteParcel(&parcelSrc);
307 DeleteParcel(&parcelDst);
308 }
309
310 HWTEST_F(CommonLibTest, HcParcelCopy001, TestSize.Level0)
311 {
312 HcParcel parcelSrc = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
313 HcParcel parcelDst = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
314 HcBool ret = ParcelCopy(nullptr, nullptr);
315 EXPECT_EQ(ret, HC_FALSE);
316 ret = ParcelCopy(&parcelSrc, &parcelDst);
317 EXPECT_EQ(ret, HC_TRUE);
318 ret = ParcelWriteInt32(&parcelSrc, TEST_SRC_DATA);
319 EXPECT_EQ(ret, HC_TRUE);
320 ret = ParcelCopy(&parcelSrc, &parcelDst);
321 EXPECT_EQ(ret, HC_TRUE);
322 DeleteParcel(&parcelSrc);
323 DeleteParcel(&parcelDst);
324 }
325
326 HWTEST_F(CommonLibTest, HcParcelReadWriteRevert001, TestSize.Level0)
327 {
328 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
329 int32_t srcInt = 0;
330 int32_t dstInt = 0;
331 HcBool ret = ParcelWriteInt32Revert(&parcelWithData, srcInt);
332 ret = ParcelReadInt32Revert(&parcelWithData, &dstInt);
333 EXPECT_EQ(ret, HC_TRUE);
334 uint32_t srcUint32 = 0;
335 uint32_t dstUint32 = 0;
336 ret = ParcelWriteUint32Revert(&parcelWithData, srcUint32);
337 ret = ParcelReadUint32Revert(&parcelWithData, &dstUint32);
338 EXPECT_EQ(ret, HC_TRUE);
339 short srcInt16 = 0;
340 short dstInt16 = 0;
341 ret = ParcelWriteInt16Revert(&parcelWithData, srcInt16);
342 ret = ParcelReadInt16Revert(&parcelWithData, &dstInt16);
343 EXPECT_EQ(ret, HC_TRUE);
344 uint16_t srcUint16 = 0;
345 uint16_t dstUint16 = 0;
346 ret = ParcelWriteUint16Revert(&parcelWithData, srcUint16);
347 ret = ParcelReadUint16Revert(&parcelWithData, &dstUint16);
348 EXPECT_EQ(ret, HC_TRUE);
349 char srcInt8 = 0;
350 char dstInt8 = 0;
351 ret = ParcelWriteInt8Revert(&parcelWithData, srcInt8);
352 ret = ParcelReadInt8Revert(&parcelWithData, &dstInt8);
353 EXPECT_EQ(ret, HC_TRUE);
354 uint8_t srcUint8 = 0;
355 uint8_t dstUint8 = 0;
356 ret = ParcelWriteUint8Revert(&parcelWithData, srcUint8);
357 ret = ParcelReadUint8Revert(&parcelWithData, &dstUint8);
358 EXPECT_EQ(ret, HC_TRUE);
359 int64_t srcInt64 = 0;
360 int64_t dstInt64 = 0;
361 ret = ParcelWriteInt64Revert(&parcelWithData, srcInt64);
362 ret = ParcelReadInt64Revert(&parcelWithData, &dstInt64);
363 EXPECT_EQ(ret, HC_TRUE);
364 uint64_t srcUint64 = 0;
365 uint64_t dstUint64 = 0;
366 ret = ParcelWriteUint64Revert(&parcelWithData, srcUint64);
367 ret = ParcelReadUint64Revert(&parcelWithData, &dstUint64);
368 EXPECT_EQ(ret, HC_TRUE);
369 DeleteParcel(&parcelWithData);
370 }
371
372 HWTEST_F(CommonLibTest, HcParcelPop001, TestSize.Level0)
373 {
374 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
375 HcBool ret = ParcelWriteInt32(&parcelWithData, TEST_SRC_DATA);
376 EXPECT_EQ(ret, HC_TRUE);
377 ret = ParcelPopBack(&parcelWithData, sizeof(uint32_t));
378 EXPECT_EQ(ret, HC_TRUE);
379 ret = ParcelPopBack(&parcelWithData, sizeof(uint32_t));
380 EXPECT_EQ(ret, HC_FALSE);
381 ret = ParcelWriteInt32(&parcelWithData, TEST_SRC_DATA);
382 EXPECT_EQ(ret, HC_TRUE);
383 ret = ParcelPopFront(&parcelWithData, sizeof(uint32_t));
384 EXPECT_EQ(ret, HC_TRUE);
385 ret = ParcelPopFront(&parcelWithData, sizeof(uint32_t));
386 EXPECT_EQ(ret, HC_FALSE);
387 DeleteParcel(&parcelWithData);
388 }
389
390 HWTEST_F(CommonLibTest, HcStringTest001, TestSize.Level0)
391 {
392 HcString selfStr = CreateString();
393 HcString srcStr = CreateString();
394 HcBool ret = StringSetPointer(&srcStr, TEST_STR);
395 EXPECT_EQ(ret, HC_TRUE);
396 ret = StringAppend(nullptr, srcStr);
397 EXPECT_EQ(ret, HC_FALSE);
398 ret = StringAppend(&selfStr, srcStr);
399 EXPECT_EQ(ret, HC_TRUE);
400 ret = StringAppendPointer(nullptr, TEST_STR);
401 EXPECT_EQ(ret, HC_FALSE);
402 ret = StringAppendPointer(&selfStr, TEST_STR);
403 EXPECT_EQ(ret, HC_TRUE);
404 ret = StringAppendChar(nullptr, TEST_CHAR);
405 EXPECT_EQ(ret, HC_FALSE);
406 ret = StringAppendChar(&selfStr, TEST_CHAR);
407 EXPECT_EQ(ret, HC_TRUE);
408 ret = StringSet(nullptr, srcStr);
409 EXPECT_EQ(ret, HC_FALSE);
410 ret = StringSet(&selfStr, srcStr);
411 EXPECT_EQ(ret, HC_TRUE);
412 ret = StringSetPointer(nullptr, TEST_STR);
413 EXPECT_EQ(ret, HC_FALSE);
414 ret = StringSetPointer(&selfStr, TEST_STR);
415 EXPECT_EQ(ret, HC_TRUE);
416 const char *retStr = StringGet(nullptr);
417 EXPECT_EQ(retStr, nullptr);
418 retStr = StringGet(&selfStr);
419 EXPECT_NE(retStr, nullptr);
420 uint32_t retLen = StringLength(nullptr);
421 EXPECT_EQ(retLen, 0);
422 retLen = StringLength(&selfStr);
423 EXPECT_NE(retLen, 0);
424 DeleteString(&selfStr);
425 retLen = StringLength(&selfStr);
426 EXPECT_EQ(retLen, 0);
427 DeleteString(&srcStr);
428 }
429
430 HWTEST_F(CommonLibTest, HcCreateJsonTest001, TestSize.Level0)
431 {
432 CJson *invalidJson = CreateJsonFromString(nullptr);
433 EXPECT_EQ(invalidJson, nullptr);
434 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
435 EXPECT_NE(validJson, nullptr);
436 invalidJson = DuplicateJson(nullptr);
437 EXPECT_EQ(invalidJson, nullptr);
438 FreeJson(validJson);
439 }
440
441 HWTEST_F(CommonLibTest, HcDeleteJsonTest001, TestSize.Level0)
442 {
443 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
444 EXPECT_NE(validJson, nullptr);
445 CJson *jsonItem = DetachItemFromJson(nullptr, "age");
446 EXPECT_EQ(jsonItem, nullptr);
447 jsonItem = DetachItemFromJson(validJson, "age");
448 EXPECT_NE(jsonItem, nullptr);
449 DeleteItemFromJson(nullptr, "name");
450 DeleteItemFromJson(validJson, "name");
451 DeleteAllItemExceptOne(nullptr, "name");
452 DeleteAllItemExceptOne(validJson, "name");
453 DeleteAllItem(nullptr);
454 DeleteAllItem(validJson);
455 FreeJson(validJson);
456 }
457
458 HWTEST_F(CommonLibTest, HcJsonGetTest001, TestSize.Level0)
459 {
460 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
461 EXPECT_NE(validJson, nullptr);
462 char *jsonStr = PackJsonToString(nullptr);
463 EXPECT_EQ(jsonStr, nullptr);
464 jsonStr = PackJsonToString(validJson);
465 EXPECT_NE(jsonStr, nullptr);
466 FreeJsonString(jsonStr);
467 int32_t itemNum = GetItemNum(nullptr);
468 EXPECT_EQ(itemNum, 0);
469 itemNum = GetItemNum(validJson);
470 EXPECT_NE(itemNum, 0);
471 const char *itemKey = GetItemKey(nullptr);
472 EXPECT_EQ(itemKey, nullptr);
473 itemKey = GetItemKey(validJson);
474 EXPECT_EQ(itemKey, nullptr);
475 CJson *jsonObj = GetObjFromJson(nullptr, "name");
476 EXPECT_EQ(jsonObj, nullptr);
477 jsonObj = GetObjFromJson(validJson, "name");
478 EXPECT_NE(jsonObj, nullptr);
479 jsonObj = GetItemFromArray(nullptr, 0);
480 EXPECT_EQ(jsonObj, nullptr);
481 jsonObj = GetItemFromArray(validJson, 0);
482 EXPECT_NE(jsonObj, nullptr);
483 FreeJson(validJson);
484 }
485
486 HWTEST_F(CommonLibTest, HcJsonGetTest002, TestSize.Level0)
487 {
488 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
489 EXPECT_NE(validJson, nullptr);
490 const char *strObj = GetStringFromJson(nullptr, "name");
491 EXPECT_EQ(strObj, nullptr);
492 strObj = GetStringFromJson(validJson, "name");
493 EXPECT_NE(strObj, nullptr);
494 char byteData[] = "test_byte";
495 int32_t ret = GetByteFromJson(nullptr, "name", nullptr, sizeof(byteData));
496 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
497 ret = GetByteFromJson(validJson, "gender", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
498 EXPECT_EQ(ret, CLIB_ERR_JSON_GET);
499 ret = GetByteFromJson(validJson, "name", reinterpret_cast<uint8_t *>(byteData), TEST_LENGTH_ZERO);
500 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
501 int32_t valueInt32 = 0;
502 ret = GetIntFromJson(nullptr, "age", &valueInt32);
503 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
504 uint32_t valueUint32 = 0;
505 ret = GetUnsignedIntFromJson(nullptr, "age", &valueUint32);
506 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
507 int64_t valueInt64 = 0;
508 ret = GetInt64FromJson(nullptr, "age", &valueInt64);
509 EXPECT_EQ(ret, CLIB_ERR_JSON_GET);
510 bool valueBool = false;
511 ret = GetBoolFromJson(nullptr, "age", &valueBool);
512 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
513 CJson *jsonObj = GetObjFromJson(validJson, "name");
514 char *valueStr = GetStringValue(jsonObj);
515 EXPECT_NE(valueStr, nullptr);
516 FreeJson(validJson);
517 }
518
519 HWTEST_F(CommonLibTest, HcJsonGetTest003, TestSize.Level0)
520 {
521 CJson *jsonObj = CreateJson();
522 int data = 1;
523 uint8_t value = 0;
524 int32_t ret = AddIntToJson(jsonObj, "name", data);
525 EXPECT_EQ(ret, CLIB_SUCCESS);
526 ret = GetUint8FromJson(nullptr, "name", &value);
527 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
528 ret = GetUint8FromJson(jsonObj, nullptr, &value);
529 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
530 ret = GetUint8FromJson(jsonObj, "name", nullptr);
531 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
532 ret = GetUint8FromJson(jsonObj, "name", &value);
533 EXPECT_EQ(ret, CLIB_SUCCESS);
534 DeleteItemFromJson(jsonObj, "name");
535 ret = GetUint8FromJson(jsonObj, "name", &value);
536 EXPECT_EQ(ret, CLIB_ERR_JSON_GET);
537 ret = GetBoolFromJson(jsonObj, nullptr, nullptr);
538 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
539 ret = GetBoolFromJson(jsonObj, "name", nullptr);
540 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
541 ret = GetUnsignedIntFromJson(jsonObj, nullptr, nullptr);
542 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
543 ret = GetUnsignedIntFromJson(jsonObj, "name", nullptr);
544 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
545 ret = GetIntFromJson(jsonObj, nullptr, nullptr);
546 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
547 ret = GetIntFromJson(jsonObj, "name", nullptr);
548 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
549 ret = GetByteFromJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
550 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
551 ret = GetByteFromJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
552 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
553 const char *retStr = GetStringFromJson(jsonObj, nullptr);
554 EXPECT_EQ(retStr, nullptr);
555 FreeJsonString(nullptr);
556 CJson *retJson = DetachItemFromJson(jsonObj, nullptr);
557 EXPECT_EQ(retJson, nullptr);
558 retJson = GetObjFromJson(jsonObj, nullptr);
559 EXPECT_EQ(retJson, nullptr);
560 DeleteAllItemExceptOne(jsonObj, nullptr);
561 DeleteItemFromJson(jsonObj, nullptr);
562 retJson = DuplicateJson(nullptr);
563 EXPECT_EQ(retJson, nullptr);
564 FreeJson(jsonObj);
565 }
566
567 HWTEST_F(CommonLibTest, HcJsonGetTest004, TestSize.Level0)
568 {
569 CJson *jsonObj = CreateJson();
570 uint32_t byteLen = 0;
571 char byteData[] = "test_byte";
572 int32_t ret = AddByteToJson(jsonObj, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
573 EXPECT_EQ(ret, CLIB_SUCCESS);
574 ret = GetByteLenFromJson(nullptr, "name", &byteLen);
575 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
576 ret = GetByteLenFromJson(jsonObj, nullptr, &byteLen);
577 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
578 ret = GetByteLenFromJson(jsonObj, "name", nullptr);
579 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
580 ret = GetByteLenFromJson(jsonObj, "name", &byteLen);
581 EXPECT_EQ(ret, CLIB_SUCCESS);
582 ret = GetByteLenFromJson(jsonObj, "test", &byteLen);
583 EXPECT_EQ(ret, CLIB_ERR_JSON_GET);
584 FreeJson(jsonObj);
585 }
586
587 HWTEST_F(CommonLibTest, HcJsonAddTest001, TestSize.Level0)
588 {
589 CJson *jsonArr = CreateJsonFromString(TEST_JSON_STR_ARR);
590 EXPECT_NE(jsonArr, nullptr);
591 CJson *childObj = CreateJsonFromString(TEST_JSON_STR);
592 EXPECT_NE(childObj, nullptr);
593 int32_t ret = AddObjToJson(nullptr, "name", nullptr);
594 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
595 ret = AddObjToJson(jsonArr, "gender", childObj);
596 EXPECT_EQ(ret, CLIB_SUCCESS);
597 ret = AddObjToJson(jsonArr, "name", childObj);
598 EXPECT_EQ(ret, CLIB_SUCCESS);
599 ret = AddObjToArray(nullptr, childObj);
600 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
601 ret = AddObjToArray(childObj, jsonArr);
602 EXPECT_EQ(ret, CLIB_ERR_INVALID_PARAM);
603 ret = AddObjToArray(jsonArr, childObj);
604 EXPECT_EQ(ret, CLIB_SUCCESS);
605 ret = AddStringToArray(nullptr, TEST_STR);
606 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
607 ret = AddStringToArray(childObj, TEST_STR);
608 EXPECT_EQ(ret, CLIB_ERR_INVALID_PARAM);
609 ret = AddStringToArray(jsonArr, TEST_STR);
610 EXPECT_EQ(ret, CLIB_SUCCESS);
611 ret = AddStringToJson(nullptr, "name", TEST_STR);
612 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
613 ret = AddStringToJson(childObj, "gender", TEST_STR);
614 EXPECT_EQ(ret, CLIB_SUCCESS);
615 ret = AddStringToJson(childObj, "name", TEST_STR);
616 EXPECT_EQ(ret, CLIB_SUCCESS);
617 FreeJson(jsonArr);
618 }
619
620 HWTEST_F(CommonLibTest, HcJsonAddTest002, TestSize.Level0)
621 {
622 CJson *childObj = CreateJsonFromString(TEST_JSON_STR);
623 EXPECT_NE(childObj, nullptr);
624 char byteData[] = "test_byte";
625 int32_t ret = AddByteToJson(nullptr, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
626 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
627 ret = AddByteToJson(childObj, "gender", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
628 EXPECT_EQ(ret, CLIB_SUCCESS);
629 ret = AddByteToJson(childObj, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
630 EXPECT_EQ(ret, CLIB_SUCCESS);
631 ret = AddBoolToJson(nullptr, "name", false);
632 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
633 ret = AddBoolToJson(childObj, "gender", false);
634 EXPECT_EQ(ret, CLIB_SUCCESS);
635 ret = AddBoolToJson(childObj, "name", false);
636 EXPECT_EQ(ret, CLIB_SUCCESS);
637 int32_t valueInt32 = 0;
638 ret = AddIntToJson(nullptr, "name", valueInt32);
639 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
640 ret = AddIntToJson(childObj, "gender", valueInt32);
641 EXPECT_EQ(ret, CLIB_SUCCESS);
642 ret = AddIntToJson(childObj, "name", valueInt32);
643 EXPECT_EQ(ret, CLIB_SUCCESS);
644 int64_t valueInt64 = 0;
645 ret = AddInt64StringToJson(nullptr, "name", valueInt64);
646 EXPECT_EQ(ret, CLIB_ERR_JSON_ADD);
647 ret = AddInt64StringToJson(childObj, "name", valueInt64);
648 EXPECT_EQ(ret, CLIB_SUCCESS);
649 const char *const strArr[] = {"first test data", "second test data"};
650 ret = AddStringArrayToJson(nullptr, "name", strArr, sizeof(strArr) / sizeof(strArr[0]));
651 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
652 ret = AddStringArrayToJson(childObj, "name", strArr, sizeof(strArr) / sizeof(strArr[0]));
653 EXPECT_EQ(ret, CLIB_SUCCESS);
654 }
655
656 HWTEST_F(CommonLibTest, HcJsonAddTest003, TestSize.Level0)
657 {
658 CJson *jsonObj = CreateJson();
659 int32_t ret = AddBoolToJson(jsonObj, nullptr, false);
660 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
661 ret = AddByteToJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
662 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
663 ret = AddByteToJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
664 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
665 ret = AddIntToJson(jsonObj, nullptr, 0);
666 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
667 ret = AddStringArrayToJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
668 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
669 ret = AddStringArrayToJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
670 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
671 ret = AddStringToJson(jsonObj, nullptr, nullptr);
672 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
673 ret = AddStringToJson(jsonObj, "name", nullptr);
674 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
675 ret = AddStringToArray(jsonObj, nullptr);
676 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
677 ret = AddObjToArray(jsonObj, nullptr);
678 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
679 ret = AddObjToJson(jsonObj, nullptr, nullptr);
680 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
681 ret = AddObjToJson(jsonObj, "name", nullptr);
682 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
683 FreeJson(jsonObj);
684 }
685
686 HWTEST_F(CommonLibTest, HcClearJsonTest001, TestSize.Level0)
687 {
688 CJson *jsonObj = CreateJsonFromString(TEST_JSON_STR);
689 EXPECT_NE(jsonObj, nullptr);
690 ClearSensitiveStringInJson(nullptr, "name");
691 ClearSensitiveStringInJson(jsonObj, "gender");
692 ClearSensitiveStringInJson(jsonObj, "name");
693 ClearSensitiveStringInJson(jsonObj, nullptr);
694 FreeJson(jsonObj);
695 }
696
697 HWTEST_F(CommonLibTest, HcClearJsonTest002, TestSize.Level0)
698 {
699 CJson *jsonObj = CreateJsonFromString(TEST_JSON_STR);
700 EXPECT_NE(jsonObj, nullptr);
701 char *jsonStr = PackJsonToString(jsonObj);
702 EXPECT_NE(jsonStr, nullptr);
703 ClearAndFreeJsonString(nullptr);
704 ClearAndFreeJsonString(jsonStr);
705 FreeJson(jsonObj);
706 }
707
708 HWTEST_F(CommonLibTest, HcStringUtilTest001, TestSize.Level0)
709 {
710 const uint8_t byteData[] = "1234";
711 const char hexData[] = "ABCD";
712 const char invalidData[] = "GHJK";
713 const char inValidLenData[] = "ABC";
714 uint32_t byteSize = sizeof(byteData);
715 char hexStr[TEST_BUFFER_SIZE] = { 0 };
716 int32_t ret = ByteToHexString(nullptr, byteSize, hexStr, TEST_BUFFER_SIZE);
717 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
718 ret = ByteToHexString(byteData, byteSize, nullptr, TEST_BUFFER_SIZE);
719 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
720 ret = ByteToHexString(byteData, byteSize, hexStr, TEST_LENGTH_ZERO);
721 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
722 ret = ByteToHexString(byteData, byteSize, hexStr, TEST_BUFFER_SIZE);
723 EXPECT_EQ(ret, CLIB_SUCCESS);
724 uint8_t byteStr[TEST_BUFFER_SIZE] = { 0 };
725 ret = HexStringToByte(nullptr, byteStr, TEST_BUFFER_SIZE);
726 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
727 ret = HexStringToByte(hexData, nullptr, TEST_BUFFER_SIZE);
728 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
729 ret = HexStringToByte(inValidLenData, byteStr, TEST_BUFFER_SIZE);
730 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
731 ret = HexStringToByte(hexData, byteStr, TEST_LENGTH_ZERO);
732 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
733 ret = HexStringToByte(invalidData, byteStr, TEST_BUFFER_SIZE);
734 EXPECT_EQ(ret, CLIB_ERR_INVALID_PARAM);
735 ret = HexStringToByte(hexData, byteStr, TEST_BUFFER_SIZE);
736 EXPECT_EQ(ret, CLIB_SUCCESS);
737 const char intStr[] = "10";
738 int64_t int64Res = StringToInt64(intStr);
739 EXPECT_EQ(int64Res, 10);
740 int64Res = StringToInt64(nullptr);
741 EXPECT_EQ(int64Res, 0);
742 }
743
744 HWTEST_F(CommonLibTest, HcStringUtilTest002, TestSize.Level0)
745 {
746 const char oriData[] = "abcd";
747 const char inValidData[] = "";
748 char *desData = nullptr;
749 int32_t ret = ToUpperCase(nullptr, &desData);
750 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
751 ret = ToUpperCase(oriData, nullptr);
752 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
753 ret = DeepCopyString(nullptr, &desData);
754 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
755 ret = DeepCopyString(inValidData, &desData);
756 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
757 }
758
759 HWTEST_F(CommonLibTest, HcStringUtilTest003, TestSize.Level0)
760 {
761 const uint8_t byteData[] = "1234";
762 uint32_t byteSize = sizeof(byteData);
763 const char tag[] = "TEST";
764 PrintBuffer(byteData, byteSize, tag);
765 EXPECT_NE(byteData, nullptr);
766 }
767
768 HWTEST_F(CommonLibTest, HcStringUtilTest004, TestSize.Level0)
769 {
770 const char oriData[] = "abcd";
771 char anonymousData[TEST_MIN_ANONYMOUS_LEN + 2] = { 0 };
772 int32_t ret = GetAnonymousString(oriData, nullptr, TEST_MIN_ANONYMOUS_LEN + 1);
773 EXPECT_EQ(ret, CLIB_ERR_NULL_PTR);
774 ret = GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN - 1);
775 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
776 ret = GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN + 1);
777 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
778 ret = GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN + 2);
779 EXPECT_EQ(ret, CLIB_ERR_INVALID_LEN);
780 }
781
782 HWTEST_F(CommonLibTest, ParseTlvHeadTest001, TestSize.Level0)
783 {
784 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
785 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
786 TlvBase tlvBase = {
787 .tag = 0,
788 .length = 0,
789 .checkTag = 1,
790 };
791 HcBool ret = ParseTlvHead(&tlvBase, nullptr);
792 EXPECT_EQ(ret, HC_FALSE);
793 ret = ParseTlvHead(&tlvBase, &parcelWithData);
794 EXPECT_EQ(ret, HC_FALSE);
795 parcelWithData.beginPos = PARCEL_UINT_MAX;
796 tlvBase.checkTag = tlvBase.length;
797 ret = ParseTlvHead(&tlvBase, &parcelWithData);
798 EXPECT_EQ(ret, HC_FALSE);
799 parcelWithData.beginPos = 0;
800 tlvBase.length = MAX_TLV_LENGTH + 1;
801 ret = ParseTlvHead(&tlvBase, &parcelWithData);
802 EXPECT_EQ(ret, HC_FALSE);
803 tlvBase.length = 0;
804 ret = ParseTlvHead(&tlvBase, &parcelWithData);
805 EXPECT_EQ(ret, HC_FALSE);
806 DeleteParcel(&parcelWithData);
807 }
808
809 HWTEST_F(CommonLibTest, ParseTlvNodeTest001, TestSize.Level0)
810 {
811 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
812 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
813 TlvBase tlvBase = {
814 .tag = 0,
815 .length = GetParcelDataSize(&parcelWithData) + 1,
816 .checkTag = 1,
817 };
818 int32_t ret = ParseTlvNode(nullptr, &parcelWithData, true);
819 EXPECT_EQ(ret, TLV_FAIL);
820 ret = ParseTlvNode(&tlvBase, &parcelWithData, true);
821 EXPECT_EQ(ret, TLV_FAIL);
822 DeleteParcel(&parcelWithData);
823 }
824
825 HWTEST_F(CommonLibTest, IsStrEqualTest001, TestSize.Level0)
826 {
827 EXPECT_EQ(IsStrEqual(nullptr, nullptr), false);
828 EXPECT_EQ(IsStrEqual("123", nullptr), false);
829 EXPECT_EQ(IsStrEqual(nullptr, "123"), false);
830 EXPECT_EQ(IsStrEqual("123", "123"), true);
831 EXPECT_EQ(IsStrEqual("123", "1234"), false);
832 EXPECT_EQ(IsStrEqual("1234", "123"), false);
833 EXPECT_EQ(IsStrEqual("", ""), true);
834 EXPECT_EQ(IsStrEqual("", "123"), false);
835 EXPECT_EQ(IsStrEqual("123", ""), false);
836 }
837 }