• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 
10 #include <iostream>
11 #include <map>
12 #include <memory>
13 #include <random>
14 #include <cstring>
15 #include <gtest/gtest.h>
16 #include <hdf_sbuf.h>
17 using namespace testing::ext;
18 
19 static const int DEFAULT_SBUF_SIZE = 256;
20 static const int DEFAULT_LOOP_COUNT = 500;
21 static const int DEFAULT_BIG_LOOP_COUNT = 1000;
22 static const int DATA_MOD = 26;
23 
24 class HdfSBufTest : public ::testing::Test {
25 protected:
SetUp()26     void SetUp() override {}
27 
TearDown()28     void TearDown() override
29     {
30         dataTable.clear();
31     }
32 
GenDataTable()33     void GenDataTable()
34     {
35         dataTable[UINT8] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint8_t)));
36         dataTable[UINT16] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint16_t)));
37         dataTable[UINT32] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint32_t)));
38         dataTable[UINT64] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint64_t)));
39         dataTable[INT8] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint8_t)));
40         dataTable[INT16] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint16_t)));
41         dataTable[INT32] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint32_t)));
42         dataTable[INT64] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint64_t)));
43         dataTable[BUFFER] = std::unique_ptr<SbufData>(new SbufData((rd() % UINT8_MAX) + 1));
44         dataTable[STRING] = std::unique_ptr<SbufData>(new SbufData((rd() % UINT8_MAX) + 1));
45         dataTable[STRING]->data[dataTable[STRING]->size - 1] = '\0';
46     }
47 
GenDataSequence(int seqSize)48     void GenDataSequence(int seqSize)
49     {
50         dataSequence.clear();
51         std::random_device rnd;
52         for (int i = 0; i < seqSize; ++i) {
53             dataSequence.push_back(rnd() % TYPE_MAX);
54         }
55     }
56 
PushDataSequence(HdfSBuf * sbuf)57     bool PushDataSequence(HdfSBuf *sbuf)
58     {
59         for (auto type : dataSequence) {
60             bool ret = false;
61             switch (type) {
62                 case UINT8:
63                     ret = HdfSbufWriteUint8(sbuf, *(uint8_t *)dataTable[type]->data);
64                     break;
65                 case UINT16:
66                     ret = HdfSbufWriteUint16(sbuf, *(uint16_t *)dataTable[type]->data);
67                     break;
68                 case UINT32:
69                     ret = HdfSbufWriteUint32(sbuf, *(uint32_t *)dataTable[type]->data);
70                     break;
71                 case UINT64:
72                     ret = HdfSbufWriteUint64(sbuf, *(uint64_t *)dataTable[type]->data);
73                     break;
74                 case INT8:
75                     ret = HdfSbufWriteUint8(sbuf, *(int8_t *)dataTable[type]->data);
76                     break;
77                 case INT16:
78                     ret = HdfSbufWriteUint16(sbuf, *(uint16_t *)dataTable[type]->data);
79                     break;
80                 case INT32:
81                     ret = HdfSbufWriteUint32(sbuf, *(uint32_t *)dataTable[type]->data);
82                     break;
83                 case INT64:
84                     ret = HdfSbufWriteUint64(sbuf, *(uint64_t *)dataTable[type]->data);
85                     break;
86                 case BUFFER:
87                     ret = HdfSbufWriteBuffer(sbuf, (uint8_t *)dataTable[type]->data, dataTable[type]->size);
88                     break;
89                 case STRING:
90                     ret = HdfSbufWriteString(sbuf, (char *)dataTable[type]->data);
91                     break;
92                 default:
93                     break;
94             }
95             if (!ret) {
96                 std::cout << "write type " << type << " fail" << std::endl;
97                 return ret;
98             }
99         }
100         return true;
101     }
102 
DataCompare(const void * s,const void * t,uint32_t size)103     static bool DataCompare(const void *s, const void *t, uint32_t size)
104     {
105         return memcmp(s, t, size) == 0;
106     }
107 
PullDataSequence(HdfSBuf * sbuf)108     bool PullDataSequence(HdfSBuf *sbuf)
109     {
110         for (auto type : dataSequence) {
111             bool ret = false;
112             switch (type) {
113                 case UINT8: {
114                     uint8_t val = 0;
115                     ret = HdfSbufReadUint8(sbuf, &val);
116                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
117                     EXPECT_EQ(true, ret);
118                     break;
119                 }
120                 case UINT16: {
121                     uint16_t val = 0;
122                     ret = HdfSbufReadUint16(sbuf, &val);
123                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
124                     EXPECT_EQ(true, ret);
125                     break;
126                 }
127                 case UINT32: {
128                     uint32_t val = 0;
129                     ret = HdfSbufReadUint32(sbuf, &val);
130                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
131                     EXPECT_EQ(true, ret);
132                     break;
133                 }
134                 case UINT64: {
135                     uint64_t val = 0;
136                     ret = HdfSbufReadUint64(sbuf, &val);
137                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
138                     EXPECT_EQ(true, ret);
139                     break;
140                 }
141                 case INT8: {
142                     int8_t val = 0;
143                     ret = HdfSbufReadInt8(sbuf, &val);
144                     EXPECT_EQ(true, ret);
145                     ret = DataCompare(&val, dataTable[type]->data, dataTable[type]->size);
146                     EXPECT_EQ(true, ret);
147                     break;
148                 }
149                 case INT16: {
150                     int16_t val = 0;
151                     ret = HdfSbufReadInt16(sbuf, &val);
152                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
153                     EXPECT_EQ(true, ret);
154                     break;
155                 }
156                 case INT32: {
157                     int32_t val = 0;
158                     ret = HdfSbufReadInt32(sbuf, &val);
159                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
160                     EXPECT_EQ(true, ret);
161                     break;
162                 }
163                 case INT64: {
164                     int64_t val = 0;
165                     ret = HdfSbufReadInt64(sbuf, &val);
166                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
167                     EXPECT_EQ(true, ret);
168                     break;
169                 }
170                 case BUFFER: {
171                     const char *buf = nullptr;
172                     uint32_t readSize = 0;
173                     ret = HdfSbufReadBuffer(sbuf, reinterpret_cast<const void **>(&buf), &readSize);
174                     EXPECT_EQ(true, DataCompare(buf, dataTable[type]->data, dataTable[type]->size));
175                     EXPECT_EQ(true, ret);
176                     break;
177                 }
178                 case STRING: {
179                     auto val = HdfSbufReadString(sbuf);
180                     EXPECT_NE(nullptr, val);
181                     if (val == nullptr) {
182                         return false;
183                     }
184                     EXPECT_EQ(strlen(val), dataTable[type]->size - 1);
185                     EXPECT_EQ(true, DataCompare(val, dataTable[type]->data, dataTable[type]->size));
186                     ret = true;
187                     break;
188                 }
189                 default:
190                     break;
191             }
192             if (!ret) {
193                 std::cout << "write type " << type << " fail" << std::endl;
194                 return ret;
195             }
196         }
197         return true;
198     }
199 
200     enum SbufDataType {
201         UINT8,
202         UINT16,
203         UINT32,
204         UINT64,
205         INT8,
206         INT16,
207         INT32,
208         INT64,
209         BUFFER,
210         STRING,
211         TYPE_MAX,
212     };
213 
214     class SbufData {
215     public:
SbufData(uint32_t dataSize)216         explicit SbufData(uint32_t dataSize) : data(nullptr), size(dataSize)
217         {
218             std::random_device rnd;
219             data = new uint8_t[dataSize];
220             for (uint32_t i = 0; i < dataSize; ++i) {
221                 data[i] = 'A' + rnd() % DATA_MOD;
222             }
223         }
224 
~SbufData()225         ~SbufData()
226         {
227             if (data != nullptr) {
228                 delete[] data;
229             }
230         }
231         uint8_t *data;
232         uint32_t size;
233     };
234 
235     std::map<int, std::unique_ptr<SbufData>> dataTable;
236     std::vector<int> dataSequence;
237     std::random_device rd;
238 };
239 
240 /**
241   * @tc.name: SbufTestObtain001
242   * @tc.desc: obtain sbuf
243   * @tc.type: FUNC
244   * @tc.require: AR000F869B
245   */
246 HWTEST_F(HdfSBufTest, SbufTestObtain001, TestSize.Level1)
247 {
248     HdfSBuf *sBuf = HdfSbufObtain(DEFAULT_SBUF_SIZE);
249     ASSERT_NE(sBuf, nullptr);
250     HdfSbufRecycle(sBuf);
251 }
252 
253 /**
254   * @tc.name: SbufTestWriteUint64002
255   * @tc.desc: write uint64 data
256   * @tc.type: FUNC
257   * @tc.require: AR000F869B
258   */
259 HWTEST_F(HdfSBufTest, SbufTestWriteUint64002, TestSize.Level1)
260 {
261     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
262     ASSERT_NE(sBuf, nullptr);
263     auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
264     ASSERT_EQ(ret, true);
265     HdfSbufRecycle(sBuf);
266 }
267 
268 /**
269   * @tc.name: SbufTestWriteUint64Loop003
270   * @tc.desc: write uint64 data sequence
271   * @tc.type: FUNC
272   * @tc.require: AR000F869B
273   */
274 HWTEST_F(HdfSBufTest, SbufTestWriteUint64Loop003, TestSize.Level1)
275 {
276     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
277     ASSERT_NE(sBuf, nullptr);
278     for (int i = 0; i < DEFAULT_BIG_LOOP_COUNT; ++i) {
279         auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
280         ASSERT_EQ(ret, true);
281     }
282     HdfSbufRecycle(sBuf);
283 }
284 
285 /**
286   * @tc.name: SbufTestReadUint64Loop004
287   * @tc.desc: read after write uint64 data sequence
288   * @tc.type: FUNC
289   * @tc.require: AR000F869B
290   */
291 HWTEST_F(HdfSBufTest, SbufTestReadUint64Loop004, TestSize.Level1)
292 {
293     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
294     ASSERT_NE(sBuf, nullptr);
295     int loop = DEFAULT_BIG_LOOP_COUNT;
296     for (int i = 0; i < loop; ++i) {
297         auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
298         ASSERT_EQ(ret, true);
299     }
300     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
301     ASSERT_NE(readBuf, nullptr);
302     uint64_t val = 0;
303     for (int j = 0; j < loop; ++j) {
304         val = 0;
305         auto ret = HdfSbufReadUint64(readBuf, &val);
306         ASSERT_EQ(ret, true);
307         ASSERT_EQ(val, (uint64_t)INT64_MAX);
308     }
309     auto ret = HdfSbufReadUint64(readBuf, &val);
310     ASSERT_EQ(ret, false);
311     HdfSbufRecycle(readBuf);
312     HdfSbufRecycle(sBuf);
313 }
314 
315 /**
316   * @tc.name: SbufTestInt8005
317   * @tc.desc: read write int8 data
318   * @tc.type: FUNC
319   * @tc.require: AR000F869B
320   */
321 HWTEST_F(HdfSBufTest, SbufTestInt8005, TestSize.Level1)
322 {
323     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
324     ASSERT_NE(sBuf, nullptr);
325     bool ret;
326     int loop = DEFAULT_LOOP_COUNT;
327     for (int i = 0; i < loop; ++i) {
328         ret = HdfSbufWriteInt8(sBuf, INT8_MAX);
329         ASSERT_EQ(ret, true);
330     }
331     size_t dataSize = HdfSbufGetDataSize(sBuf);
332     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
333 
334     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
335     ASSERT_NE(readBuf, nullptr);
336 
337     int8_t val = 0;
338     for (int j = 0; j < loop; ++j) {
339         val = 0;
340         ret = HdfSbufReadInt8(readBuf, &val);
341         ASSERT_EQ(ret, true);
342         ASSERT_EQ(val, INT8_MAX);
343     }
344     HdfSbufRecycle(readBuf);
345     HdfSbufRecycle(sBuf);
346 }
347 
348 /**
349   * @tc.name: SbufTestInt16006
350   * @tc.desc: read write int16 data
351   * @tc.type: FUNC
352   * @tc.require: AR000F869B
353   */
354 HWTEST_F(HdfSBufTest, SbufTestInt16006, TestSize.Level1)
355 {
356     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
357     ASSERT_NE(sBuf, nullptr);
358     bool ret;
359     int loop = DEFAULT_LOOP_COUNT;
360     for (int i = 0; i < loop; ++i) {
361         ret = HdfSbufWriteInt16(sBuf, INT16_MAX);
362         ASSERT_EQ(ret, true);
363     }
364     size_t dataSize = HdfSbufGetDataSize(sBuf);
365     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
366 
367     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
368     ASSERT_NE(readBuf, nullptr);
369 
370     int16_t val = 0;
371     for (int j = 0; j < loop; ++j) {
372         val = 0;
373         ret = HdfSbufReadInt16(readBuf, &val);
374         ASSERT_EQ(ret, true);
375         ASSERT_EQ(val, INT16_MAX);
376     }
377     HdfSbufRecycle(readBuf);
378     HdfSbufRecycle(sBuf);
379 }
380 
381 /**
382   * @tc.name: SbufTestInt32007
383   * @tc.desc: read write int32 data
384   * @tc.type: FUNC
385   * @tc.require: AR000F869B
386   */
387 HWTEST_F(HdfSBufTest, SbufTestInt32007, TestSize.Level1)
388 {
389     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
390     ASSERT_NE(sBuf, nullptr);
391     bool ret;
392     int loop = DEFAULT_LOOP_COUNT;
393     for (int i = 0; i < loop; ++i) {
394         ret = HdfSbufWriteInt32(sBuf, INT32_MAX);
395         ASSERT_EQ(ret, true);
396     }
397     size_t dataSize = HdfSbufGetDataSize(sBuf);
398     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
399 
400     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
401     ASSERT_NE(readBuf, nullptr);
402 
403     int32_t val = 0;
404     for (int j = 0; j < loop; ++j) {
405         val = 0;
406         ret = HdfSbufReadInt32(readBuf, &val);
407         ASSERT_EQ(ret, true);
408         ASSERT_EQ(val, INT32_MAX);
409     }
410     HdfSbufRecycle(readBuf);
411     HdfSbufRecycle(sBuf);
412 }
413 
414 /**
415   * @tc.name: SbufTestInt64008
416   * @tc.desc: read write int64 data
417   * @tc.type: FUNC
418   * @tc.require: AR000F869B
419   */
420 HWTEST_F(HdfSBufTest, SbufTestInt64008, TestSize.Level1)
421 {
422     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
423     ASSERT_NE(sBuf, nullptr);
424     bool ret;
425     int loop = DEFAULT_LOOP_COUNT;
426     for (int i = 0; i < loop; ++i) {
427         ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
428         ASSERT_EQ(ret, true);
429     }
430     size_t dataSize = HdfSbufGetDataSize(sBuf);
431     ASSERT_EQ(dataSize, loop * sizeof(uint64_t));
432 
433     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
434     ASSERT_NE(readBuf, nullptr);
435 
436     int64_t val = 0;
437     for (int j = 0; j < loop; ++j) {
438         val = 0;
439         ret = HdfSbufReadInt64(readBuf, &val);
440         ASSERT_EQ(ret, true);
441         ASSERT_EQ(val, INT64_MAX);
442     }
443     HdfSbufRecycle(readBuf);
444     HdfSbufRecycle(sBuf);
445 }
446 
447 /**
448   * @tc.name: SbufTestUInt32009
449   * @tc.desc: read write uint32 data
450   * @tc.type: FUNC
451   * @tc.require: AR000F869B
452   */
453 HWTEST_F(HdfSBufTest, SbufTestUInt32009, TestSize.Level1)
454 {
455     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
456     ASSERT_NE(sBuf, nullptr);
457     bool ret;
458     int loop = DEFAULT_LOOP_COUNT;
459     for (int i = 0; i < loop; ++i) {
460         ret = HdfSbufWriteUint32(sBuf, UINT32_MAX);
461         ASSERT_EQ(ret, true);
462     }
463     size_t dataSize = HdfSbufGetDataSize(sBuf);
464     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
465 
466     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
467     ASSERT_NE(readBuf, nullptr);
468 
469     uint32_t val = 0;
470     for (int j = 0; j < loop; ++j) {
471         val = 0;
472         ret = HdfSbufReadUint32(readBuf, &val);
473         ASSERT_EQ(ret, true);
474         ASSERT_EQ(val, UINT32_MAX);
475     }
476     HdfSbufRecycle(readBuf);
477     HdfSbufRecycle(sBuf);
478 }
479 
480 /**
481   * @tc.name: SbufTestUInt16010
482   * @tc.desc: read write uint16 data
483   * @tc.type: FUNC
484   * @tc.require: AR000F869B
485   */
486 HWTEST_F(HdfSBufTest, SbufTestUInt16010, TestSize.Level1)
487 {
488     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
489     ASSERT_NE(sBuf, nullptr);
490     bool ret;
491     int loop = DEFAULT_LOOP_COUNT;
492     for (int i = 0; i < loop; ++i) {
493         ret = HdfSbufWriteUint16(sBuf, UINT16_MAX);
494         ASSERT_EQ(ret, true);
495     }
496     size_t dataSize = HdfSbufGetDataSize(sBuf);
497     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
498 
499     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
500     ASSERT_NE(readBuf, nullptr);
501 
502     uint16_t val = 0;
503     for (int j = 0; j < loop; ++j) {
504         val = 0;
505         ret = HdfSbufReadUint16(readBuf, &val);
506         ASSERT_EQ(ret, true);
507         ASSERT_EQ(val, UINT16_MAX);
508     }
509     HdfSbufRecycle(readBuf);
510     HdfSbufRecycle(sBuf);
511 }
512 
513 /**
514   * @tc.name: SbufTestUInt8011
515   * @tc.desc: read write uint8 data
516   * @tc.type: FUNC
517   * @tc.require: AR000F869B
518   */
519 HWTEST_F(HdfSBufTest, SbufTestUInt8011, TestSize.Level1)
520 {
521     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
522     ASSERT_NE(sBuf, nullptr);
523     bool ret;
524     int loop = DEFAULT_LOOP_COUNT;
525     for (int i = 0; i < loop; ++i) {
526         ret = HdfSbufWriteUint8(sBuf, UINT8_MAX);
527         ASSERT_EQ(ret, true);
528     }
529     size_t dataSize = HdfSbufGetDataSize(sBuf);
530     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
531 
532     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
533     ASSERT_NE(readBuf, nullptr);
534 
535     uint8_t val = 0;
536     for (int j = 0; j < loop; ++j) {
537         val = 0;
538         ret = HdfSbufReadUint8(readBuf, &val);
539         ASSERT_EQ(ret, true);
540         ASSERT_EQ(val, UINT8_MAX);
541     }
542     HdfSbufRecycle(readBuf);
543     HdfSbufRecycle(sBuf);
544 }
545 
546 /**
547   * @tc.name: SbufTestString012
548   * @tc.desc: read write string data
549   * @tc.type: FUNC
550   * @tc.require: AR000F869B
551   */
552 HWTEST_F(HdfSBufTest, SbufTestString012, TestSize.Level1)
553 {
554     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
555     ASSERT_NE(sBuf, nullptr);
556     bool ret;
557     int loop = DEFAULT_LOOP_COUNT;
558     std::string str("test");
559     for (int i = 0; i < loop; ++i) {
560         ret = HdfSbufWriteString(sBuf, str.data());
561         ASSERT_EQ(ret, true);
562     }
563 
564     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
565     ASSERT_NE(readBuf, nullptr);
566 
567     for (int j = 0; j < loop; ++j) {
568         const char *readStr = HdfSbufReadString(readBuf);
569         ASSERT_EQ(std::string(readStr), str);
570     }
571     HdfSbufRecycle(readBuf);
572     HdfSbufRecycle(sBuf);
573 }
574 
575 /**
576   * @tc.name: SbufTestNullString013
577   * @tc.desc: read write bullptr string data test
578   * @tc.type: FUNC
579   * @tc.require: AR000F869B
580   */
581 HWTEST_F(HdfSBufTest, SbufTestNullString013, TestSize.Level1)
582 {
583     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
584     ASSERT_NE(sBuf, nullptr);
585     auto ret = HdfSbufWriteString(sBuf, nullptr);
586     ASSERT_EQ(true, ret);
587     ret = HdfSbufWriteInt32(sBuf, INT32_MIN);
588     ASSERT_EQ(true, ret);
589     size_t dataSize = HdfSbufGetDataSize(sBuf);
590     ASSERT_NE((size_t)0, dataSize);
591     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
592     ASSERT_NE(readBuf, nullptr);
593     auto val = HdfSbufReadString(readBuf);
594     ASSERT_EQ(nullptr, val);
595     int32_t intVal = 0;
596     ret = HdfSbufReadInt32(readBuf, &intVal);
597     ASSERT_EQ(true, ret);
598     ASSERT_EQ(INT32_MIN, intVal);
599     HdfSbufRecycle(readBuf);
600     HdfSbufRecycle(sBuf);
601 }
602 
603 /**
604   * @tc.name: SbufTestBuffer014
605   * @tc.desc: read write buffer test
606   * @tc.type: FUNC
607   * @tc.require: AR000F869B
608   */
609 HWTEST_F(HdfSBufTest, SbufTestBuffer014, TestSize.Level1)
610 {
611     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
612     ASSERT_NE(sBuf, nullptr);
613     bool ret;
614     int loop = 1;
615     std::string str("test");
616     for (int i = 0; i < loop; ++i) {
617         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
618         ASSERT_EQ(ret, true);
619     }
620 
621     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
622     ASSERT_NE(readBuf, nullptr);
623 
624     for (int j = 0; j < loop; ++j) {
625         const char *data = nullptr;
626         uint32_t readSize = 0;
627         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
628         ASSERT_EQ(ret, true);
629         ASSERT_EQ(readSize, str.size() + 1);
630         ASSERT_EQ(std::string(data), str);
631     }
632     HdfSbufRecycle(readBuf);
633     HdfSbufRecycle(sBuf);
634 }
635 
636 /**
637   * @tc.name: SbufTestNullBuffer015
638   * @tc.desc: read write nullptr buffer data
639   * @tc.type: FUNC
640   * @tc.require: AR000F869B
641   */
642 HWTEST_F(HdfSBufTest, SbufTestNullBuffer015, TestSize.Level1)
643 {
644     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
645     ASSERT_NE(sBuf, nullptr);
646     auto ret = HdfSbufWriteBuffer(sBuf, nullptr, 0);
647     ASSERT_EQ(true, ret);
648     ret = HdfSbufWriteInt16(sBuf, INT16_MIN);
649     ASSERT_EQ(true, ret);
650     size_t dataSize = HdfSbufGetDataSize(sBuf);
651     ASSERT_NE((size_t)0, dataSize);
652     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
653     ASSERT_NE(readBuf, nullptr);
654     const uint8_t *buffVal = nullptr;
655     uint32_t buffLen = 0;
656     ret = HdfSbufReadBuffer(readBuf, (const void **)(&buffVal), &buffLen);
657     ASSERT_EQ(true, ret);
658     ASSERT_EQ((uint32_t)0, buffLen);
659     dataSize = HdfSbufGetDataSize(sBuf);
660     ASSERT_NE((size_t)0, dataSize);
661     int16_t intVal = 0;
662     ret = HdfSbufReadInt16(readBuf, &intVal);
663     ASSERT_EQ(true, ret);
664     ASSERT_EQ(INT16_MIN, intVal);
665     HdfSbufRecycle(sBuf);
666     HdfSbufRecycle(readBuf);
667 }
668 
669 /**
670   * @tc.name: SbufTestRandomDataSeq016
671   * @tc.desc: read write random data test
672   * @tc.type: FUNC
673   * @tc.require: AR000F869B
674   */
675 HWTEST_F(HdfSBufTest, SbufTestRandomDataSeq016, TestSize.Level0)
676 {
677     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
678     ASSERT_NE(sBuf, nullptr);
679 
680     GenDataTable();
681     GenDataSequence(100);
682     bool ret = PushDataSequence(sBuf);
683     ASSERT_EQ(true, ret);
684 
685     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
686     ASSERT_NE(readBuf, nullptr);
687 
688     ret = PullDataSequence(readBuf);
689     ASSERT_EQ(true, ret);
690     HdfSbufRecycle(sBuf);
691     HdfSbufRecycle(readBuf);
692 }
693 
694 /**
695   * @tc.name: SbufTestRandomRWDataSeq017
696   * @tc.desc: read write random data sequence test
697   * @tc.type: FUNC
698   * @tc.require: AR000F869B
699   */
700 HWTEST_F(HdfSBufTest, SbufTestRandomRWDataSeq017, TestSize.Level0)
701 {
702     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
703     ASSERT_NE(sBuf, nullptr);
704 
705     GenDataTable();
706     GenDataSequence(100);
707     bool ret = PushDataSequence(sBuf);
708     ASSERT_EQ(true, ret);
709 
710     ret = PullDataSequence(sBuf);
711     ASSERT_EQ(true, ret);
712 
713     ret = PushDataSequence(sBuf);
714     ASSERT_EQ(true, ret);
715 
716     ret = PullDataSequence(sBuf);
717     ASSERT_EQ(true, ret);
718 
719     uint8_t val = 0;
720     ret = HdfSbufReadUint8(sBuf, &val);
721     ASSERT_EQ(false, ret);
722     ASSERT_EQ(0, val);
723 
724     HdfSbufRecycle(sBuf);
725 }
726 
727 /**
728   * @tc.name: SbufTestSbufMove018
729   * @tc.desc: move sbuf test
730   * @tc.type: FUNC
731   * @tc.require: AR000F869B
732   */
733 HWTEST_F(HdfSBufTest, SbufTestSbufMove018, TestSize.Level1)
734 {
735     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
736     ASSERT_NE(sBuf, nullptr);
737 
738     GenDataTable();
739     GenDataSequence(100);
740 
741     bool ret;
742     int loop = 1;
743     std::string str("test");
744     for (int i = 0; i < loop; ++i) {
745         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
746         ASSERT_EQ(ret, true);
747     }
748 
749     HdfSBuf *readBuf = HdfSbufMove(sBuf);
750     ASSERT_NE(readBuf, nullptr);
751 
752     for (int j = 0; j < loop; ++j) {
753         const char *data = nullptr;
754         uint32_t readSize = 0;
755         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
756         ASSERT_EQ(ret, true);
757         ASSERT_EQ(readSize, str.size() + 1);
758         ASSERT_EQ(std::string(data), str);
759     }
760     HdfSbufRecycle(sBuf);
761     HdfSbufRecycle(readBuf);
762 }
763 
764 /**
765   * @tc.name: SbufTestSbufMoveHalf019
766   * @tc.desc: move sbuf after read test
767   * @tc.type: FUNC
768   * @tc.require: AR000F869B
769   */
770 HWTEST_F(HdfSBufTest, SbufTestSbufMoveHalf019, TestSize.Level1)
771 {
772     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
773     ASSERT_NE(sBuf, nullptr);
774 
775     bool ret;
776     int loop = 1;
777     std::string str("test");
778     for (int i = 0; i < loop; ++i) {
779         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
780         ASSERT_EQ(ret, true);
781     }
782     for (int j = 0; j < loop/2; ++j) {
783         const char *data = nullptr;
784         uint32_t readSize = 0;
785         ret = HdfSbufReadBuffer(sBuf, (const void **)(&data), &readSize);
786         ASSERT_EQ(ret, true);
787         ASSERT_EQ(readSize, str.size() + 1);
788         ASSERT_EQ(std::string(data), str);
789     }
790 
791     HdfSBuf *readBuf = HdfSbufMove(sBuf);
792     ASSERT_NE(readBuf, nullptr);
793 
794     for (int j = 0; j < loop; ++j) {
795         const char *data = nullptr;
796         uint32_t readSize = 0;
797         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
798         ASSERT_EQ(ret, true);
799         ASSERT_EQ(readSize, str.size() + 1);
800         ASSERT_EQ(std::string(data), str);
801     }
802 
803     const char *data = nullptr;
804     uint32_t readSize = 0;
805     ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
806     ASSERT_EQ(ret, false);
807 
808     HdfSbufRecycle(sBuf);
809     HdfSbufRecycle(readBuf);
810 }
811