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 <cmath>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include <hdf_sbuf.h>
20 #include <iostream>
21 #include <map>
22 #include <memory>
23 #include <random>
24 
25 #ifndef __LITEOS__
26 #include "hdf_remote_adapter_if.h"
27 #include "hdf_sbuf_ipc.h"
28 #endif
29 
30 namespace OHOS {
31 using namespace testing::ext;
32 
33 static const int DEFAULT_SBUF_SIZE = 256;
34 static const int DEFAULT_LOOP_COUNT = 500;
35 static const int DEFAULT_BIG_LOOP_COUNT = 1000;
36 static const int DATA_MOD = 26;
37 
38 class HdfSBufTest : public ::testing::Test {
39 protected:
40     void SetUp() override {}
41 
42     void TearDown() override
43     {
44         dataTable.clear();
45     }
46 
GenDataTable()47     void GenDataTable()
48     {
49         dataTable[UINT8] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint8_t)));
50         dataTable[UINT16] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint16_t)));
51         dataTable[UINT32] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint32_t)));
52         dataTable[UINT64] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint64_t)));
53         dataTable[INT8] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint8_t)));
54         dataTable[INT16] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint16_t)));
55         dataTable[INT32] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint32_t)));
56         dataTable[INT64] = std::unique_ptr<SbufData>(new SbufData(sizeof(uint64_t)));
57         dataTable[BUFFER] = std::unique_ptr<SbufData>(new SbufData((rd() % UINT8_MAX) + 1));
58         dataTable[STRING] = std::unique_ptr<SbufData>(new SbufData((rd() % UINT8_MAX) + 1));
59         dataTable[STRING]->data[dataTable[STRING]->size - 1] = '\0';
60     }
61 
GenDataSequence(int seqSize)62     void GenDataSequence(int seqSize)
63     {
64         dataSequence.clear();
65         std::random_device rnd;
66         for (int i = 0; i < seqSize; ++i) {
67             dataSequence.push_back(rnd() % TYPE_MAX);
68         }
69     }
70 
PushDataSequence(HdfSBuf *sbuf)71     bool PushDataSequence(HdfSBuf *sbuf)
72     {
73         for (auto type : dataSequence) {
74             bool ret = false;
75             switch (type) {
76                 case UINT8:
77                     ret = HdfSbufWriteUint8(sbuf, *(uint8_t *)dataTable[type]->data);
78                     break;
79                 case UINT16:
80                     ret = HdfSbufWriteUint16(sbuf, *(uint16_t *)dataTable[type]->data);
81                     break;
82                 case UINT32:
83                     ret = HdfSbufWriteUint32(sbuf, *(uint32_t *)dataTable[type]->data);
84                     break;
85                 case UINT64:
86                     ret = HdfSbufWriteUint64(sbuf, *(uint64_t *)dataTable[type]->data);
87                     break;
88                 case INT8:
89                     ret = HdfSbufWriteUint8(sbuf, *(int8_t *)dataTable[type]->data);
90                     break;
91                 case INT16:
92                     ret = HdfSbufWriteUint16(sbuf, *(uint16_t *)dataTable[type]->data);
93                     break;
94                 case INT32:
95                     ret = HdfSbufWriteUint32(sbuf, *(uint32_t *)dataTable[type]->data);
96                     break;
97                 case INT64:
98                     ret = HdfSbufWriteUint64(sbuf, *(uint64_t *)dataTable[type]->data);
99                     break;
100                 case BUFFER:
101                     ret = HdfSbufWriteBuffer(sbuf, (uint8_t *)dataTable[type]->data, dataTable[type]->size);
102                     break;
103                 case STRING:
104                     ret = HdfSbufWriteString(sbuf, (char *)dataTable[type]->data);
105                     break;
106                 default:
107                     break;
108             }
109             if (!ret) {
110                 std::cout << "write type " << type << " fail" << std::endl;
111                 return ret;
112             }
113         }
114         return true;
115     }
116 
DataCompare(const void *s, const void *t, uint32_t size)117     static bool DataCompare(const void *s, const void *t, uint32_t size)
118     {
119         return memcmp(s, t, size) == 0;
120     }
121 
PullDataSequence(HdfSBuf *sbuf)122     bool PullDataSequence(HdfSBuf *sbuf)
123     {
124         for (auto type : dataSequence) {
125             bool ret = false;
126             switch (type) {
127                 case UINT8: {
128                     uint8_t val = 0;
129                     ret = HdfSbufReadUint8(sbuf, &val);
130                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
131                     EXPECT_EQ(true, ret);
132                     break;
133                 }
134                 case UINT16: {
135                     uint16_t val = 0;
136                     ret = HdfSbufReadUint16(sbuf, &val);
137                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
138                     EXPECT_EQ(true, ret);
139                     break;
140                 }
141                 case UINT32: {
142                     uint32_t val = 0;
143                     ret = HdfSbufReadUint32(sbuf, &val);
144                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
145                     EXPECT_EQ(true, ret);
146                     break;
147                 }
148                 case UINT64: {
149                     uint64_t val = 0;
150                     ret = HdfSbufReadUint64(sbuf, &val);
151                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
152                     EXPECT_EQ(true, ret);
153                     break;
154                 }
155                 case INT8: {
156                     int8_t val = 0;
157                     ret = HdfSbufReadInt8(sbuf, &val);
158                     EXPECT_EQ(true, ret);
159                     ret = DataCompare(&val, dataTable[type]->data, dataTable[type]->size);
160                     EXPECT_EQ(true, ret);
161                     break;
162                 }
163                 case INT16: {
164                     int16_t val = 0;
165                     ret = HdfSbufReadInt16(sbuf, &val);
166                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
167                     EXPECT_EQ(true, ret);
168                     break;
169                 }
170                 case INT32: {
171                     int32_t val = 0;
172                     ret = HdfSbufReadInt32(sbuf, &val);
173                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
174                     EXPECT_EQ(true, ret);
175                     break;
176                 }
177                 case INT64: {
178                     int64_t val = 0;
179                     ret = HdfSbufReadInt64(sbuf, &val);
180                     EXPECT_EQ(true, DataCompare(&val, dataTable[type]->data, dataTable[type]->size));
181                     EXPECT_EQ(true, ret);
182                     break;
183                 }
184                 case BUFFER: {
185                     const char *buf = nullptr;
186                     uint32_t readSize = 0;
187                     ret = HdfSbufReadBuffer(sbuf, reinterpret_cast<const void **>(&buf), &readSize);
188                     EXPECT_EQ(true, DataCompare(buf, dataTable[type]->data, dataTable[type]->size));
189                     EXPECT_EQ(true, ret);
190                     break;
191                 }
192                 case STRING: {
193                     auto val = HdfSbufReadString(sbuf);
194                     EXPECT_NE(nullptr, val);
195                     if (val == nullptr) {
196                         return false;
197                     }
198                     EXPECT_EQ(strlen(val), dataTable[type]->size - 1);
199                     EXPECT_EQ(true, DataCompare(val, dataTable[type]->data, dataTable[type]->size));
200                     ret = true;
201                     break;
202                 }
203                 default:
204                     break;
205             }
206             if (!ret) {
207                 std::cout << "write type " << type << " fail" << std::endl;
208                 return ret;
209             }
210         }
211         return true;
212     }
213 
214     enum SbufDataType {
215         UINT8,
216         UINT16,
217         UINT32,
218         UINT64,
219         INT8,
220         INT16,
221         INT32,
222         INT64,
223         BUFFER,
224         STRING,
225         TYPE_MAX,
226     };
227 
228     class SbufData {
229     public:
SbufData(uint32_t dataSize)230         explicit SbufData(uint32_t dataSize) : data(nullptr), size(dataSize)
231         {
232             std::random_device rnd;
233             data = new uint8_t[dataSize];
234             for (uint32_t i = 0; i < dataSize; ++i) {
235                 data[i] = 'A' + rnd() % DATA_MOD;
236             }
237         }
238 
~SbufData()239         ~SbufData()
240         {
241             if (data != nullptr) {
242                 delete[] data;
243             }
244         }
245         uint8_t *data;
246         uint32_t size;
247     };
248 
249     std::map<int, std::unique_ptr<SbufData>> dataTable;
250     std::vector<int> dataSequence;
251     std::random_device rd;
252 };
253 
254 /**
255   * @tc.name: SbufTestObtain001
256   * @tc.desc: obtain sbuf
257   * @tc.type: FUNC
258   * @tc.require: AR000F869B
259   */
HWTEST_F(HdfSBufTest, SbufTestObtain001, TestSize.Level1)260 HWTEST_F(HdfSBufTest, SbufTestObtain001, TestSize.Level1)
261 {
262     HdfSBuf *sBuf = HdfSbufObtain(DEFAULT_SBUF_SIZE);
263     ASSERT_NE(sBuf, nullptr);
264     HdfSbufRecycle(sBuf);
265 }
266 
267 /**
268   * @tc.name: SbufTestWriteUint64002
269   * @tc.desc: write uint64 data
270   * @tc.type: FUNC
271   * @tc.require: AR000F869B
272   */
HWTEST_F(HdfSBufTest, SbufTestWriteUint64002, TestSize.Level1)273 HWTEST_F(HdfSBufTest, SbufTestWriteUint64002, TestSize.Level1)
274 {
275     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
276     ASSERT_NE(sBuf, nullptr);
277     auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
278     ASSERT_EQ(ret, true);
279     HdfSbufRecycle(sBuf);
280 }
281 
282 /**
283   * @tc.name: SbufTestWriteUint64Loop003
284   * @tc.desc: write uint64 data sequence
285   * @tc.type: FUNC
286   * @tc.require: AR000F869B
287   */
HWTEST_F(HdfSBufTest, SbufTestWriteUint64Loop003, TestSize.Level1)288 HWTEST_F(HdfSBufTest, SbufTestWriteUint64Loop003, TestSize.Level1)
289 {
290     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
291     ASSERT_NE(sBuf, nullptr);
292     for (int i = 0; i < DEFAULT_BIG_LOOP_COUNT; ++i) {
293         auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
294         ASSERT_EQ(ret, true);
295     }
296     HdfSbufRecycle(sBuf);
297 }
298 
299 /**
300   * @tc.name: SbufTestReadUint64Loop004
301   * @tc.desc: read after write uint64 data sequence
302   * @tc.type: FUNC
303   * @tc.require: AR000F869B
304   */
HWTEST_F(HdfSBufTest, SbufTestReadUint64Loop004, TestSize.Level1)305 HWTEST_F(HdfSBufTest, SbufTestReadUint64Loop004, TestSize.Level1)
306 {
307     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
308     ASSERT_NE(sBuf, nullptr);
309     int loop = DEFAULT_BIG_LOOP_COUNT;
310     for (int i = 0; i < loop; ++i) {
311         auto ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
312         ASSERT_EQ(ret, true);
313     }
314     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
315     ASSERT_NE(readBuf, nullptr);
316     uint64_t val = 0;
317     for (int j = 0; j < loop; ++j) {
318         val = 0;
319         auto ret = HdfSbufReadUint64(readBuf, &val);
320         ASSERT_EQ(ret, true);
321         ASSERT_EQ(val, static_cast<uint64_t>INT64_MAX);
322     }
323     auto ret = HdfSbufReadUint64(readBuf, &val);
324     ASSERT_EQ(ret, false);
325     HdfSbufRecycle(readBuf);
326     HdfSbufRecycle(sBuf);
327 }
328 
329 /**
330   * @tc.name: SbufTestInt8005
331   * @tc.desc: read write int8 data
332   * @tc.type: FUNC
333   * @tc.require: AR000F869B
334   */
HWTEST_F(HdfSBufTest, SbufTestInt8005, TestSize.Level1)335 HWTEST_F(HdfSBufTest, SbufTestInt8005, TestSize.Level1)
336 {
337     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
338     ASSERT_NE(sBuf, nullptr);
339     bool ret;
340     int loop = DEFAULT_LOOP_COUNT;
341     for (int i = 0; i < loop; ++i) {
342         ret = HdfSbufWriteInt8(sBuf, INT8_MAX);
343         ASSERT_EQ(ret, true);
344     }
345     size_t dataSize = HdfSbufGetDataSize(sBuf);
346     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
347 
348     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
349     ASSERT_NE(readBuf, nullptr);
350 
351     int8_t val = 0;
352     for (int j = 0; j < loop; ++j) {
353         val = 0;
354         ret = HdfSbufReadInt8(readBuf, &val);
355         ASSERT_EQ(ret, true);
356         ASSERT_EQ(val, INT8_MAX);
357     }
358     HdfSbufRecycle(readBuf);
359     HdfSbufRecycle(sBuf);
360 }
361 
362 /**
363   * @tc.name: SbufTestInt16006
364   * @tc.desc: read write int16 data
365   * @tc.type: FUNC
366   * @tc.require: AR000F869B
367   */
HWTEST_F(HdfSBufTest, SbufTestInt16006, TestSize.Level1)368 HWTEST_F(HdfSBufTest, SbufTestInt16006, TestSize.Level1)
369 {
370     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
371     ASSERT_NE(sBuf, nullptr);
372     bool ret;
373     int loop = DEFAULT_LOOP_COUNT;
374     for (int i = 0; i < loop; ++i) {
375         ret = HdfSbufWriteInt16(sBuf, INT16_MAX);
376         ASSERT_EQ(ret, true);
377     }
378     size_t dataSize = HdfSbufGetDataSize(sBuf);
379     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
380 
381     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
382     ASSERT_NE(readBuf, nullptr);
383 
384     int16_t val = 0;
385     for (int j = 0; j < loop; ++j) {
386         val = 0;
387         ret = HdfSbufReadInt16(readBuf, &val);
388         ASSERT_EQ(ret, true);
389         ASSERT_EQ(val, INT16_MAX);
390     }
391     HdfSbufRecycle(readBuf);
392     HdfSbufRecycle(sBuf);
393 }
394 
395 /**
396   * @tc.name: SbufTestInt32007
397   * @tc.desc: read write int32 data
398   * @tc.type: FUNC
399   * @tc.require: AR000F869B
400   */
HWTEST_F(HdfSBufTest, SbufTestInt32007, TestSize.Level1)401 HWTEST_F(HdfSBufTest, SbufTestInt32007, TestSize.Level1)
402 {
403     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
404     ASSERT_NE(sBuf, nullptr);
405     bool ret;
406     int loop = DEFAULT_LOOP_COUNT;
407     for (int i = 0; i < loop; ++i) {
408         ret = HdfSbufWriteInt32(sBuf, INT32_MAX);
409         ASSERT_EQ(ret, true);
410     }
411     size_t dataSize = HdfSbufGetDataSize(sBuf);
412     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
413 
414     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
415     ASSERT_NE(readBuf, nullptr);
416 
417     int32_t val = 0;
418     for (int j = 0; j < loop; ++j) {
419         val = 0;
420         ret = HdfSbufReadInt32(readBuf, &val);
421         ASSERT_EQ(ret, true);
422         ASSERT_EQ(val, INT32_MAX);
423     }
424     HdfSbufRecycle(readBuf);
425     HdfSbufRecycle(sBuf);
426 }
427 
428 /**
429   * @tc.name: SbufTestInt64008
430   * @tc.desc: read write int64 data
431   * @tc.type: FUNC
432   * @tc.require: AR000F869B
433   */
HWTEST_F(HdfSBufTest, SbufTestInt64008, TestSize.Level1)434 HWTEST_F(HdfSBufTest, SbufTestInt64008, TestSize.Level1)
435 {
436     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
437     ASSERT_NE(sBuf, nullptr);
438     bool ret;
439     int loop = DEFAULT_LOOP_COUNT;
440     for (int i = 0; i < loop; ++i) {
441         ret = HdfSbufWriteInt64(sBuf, INT64_MAX);
442         ASSERT_EQ(ret, true);
443     }
444     size_t dataSize = HdfSbufGetDataSize(sBuf);
445     ASSERT_EQ(dataSize, loop * sizeof(uint64_t));
446 
447     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
448     ASSERT_NE(readBuf, nullptr);
449 
450     int64_t val = 0;
451     for (int j = 0; j < loop; ++j) {
452         val = 0;
453         ret = HdfSbufReadInt64(readBuf, &val);
454         ASSERT_EQ(ret, true);
455         ASSERT_EQ(val, INT64_MAX);
456     }
457     HdfSbufRecycle(readBuf);
458     HdfSbufRecycle(sBuf);
459 }
460 
461 /**
462   * @tc.name: SbufTestUInt32009
463   * @tc.desc: read write uint32 data
464   * @tc.type: FUNC
465   * @tc.require: AR000F869B
466   */
HWTEST_F(HdfSBufTest, SbufTestUInt32009, TestSize.Level1)467 HWTEST_F(HdfSBufTest, SbufTestUInt32009, TestSize.Level1)
468 {
469     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
470     ASSERT_NE(sBuf, nullptr);
471     bool ret;
472     int loop = DEFAULT_LOOP_COUNT;
473     for (int i = 0; i < loop; ++i) {
474         ret = HdfSbufWriteUint32(sBuf, UINT32_MAX);
475         ASSERT_EQ(ret, true);
476     }
477     size_t dataSize = HdfSbufGetDataSize(sBuf);
478     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
479 
480     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
481     ASSERT_NE(readBuf, nullptr);
482 
483     uint32_t val = 0;
484     for (int j = 0; j < loop; ++j) {
485         val = 0;
486         ret = HdfSbufReadUint32(readBuf, &val);
487         ASSERT_EQ(ret, true);
488         ASSERT_EQ(val, UINT32_MAX);
489     }
490     HdfSbufRecycle(readBuf);
491     HdfSbufRecycle(sBuf);
492 }
493 
494 /**
495   * @tc.name: SbufTestUInt16010
496   * @tc.desc: read write uint16 data
497   * @tc.type: FUNC
498   * @tc.require: AR000F869B
499   */
HWTEST_F(HdfSBufTest, SbufTestUInt16010, TestSize.Level1)500 HWTEST_F(HdfSBufTest, SbufTestUInt16010, TestSize.Level1)
501 {
502     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
503     ASSERT_NE(sBuf, nullptr);
504     bool ret;
505     int loop = DEFAULT_LOOP_COUNT;
506     for (int i = 0; i < loop; ++i) {
507         ret = HdfSbufWriteUint16(sBuf, UINT16_MAX);
508         ASSERT_EQ(ret, true);
509     }
510     size_t dataSize = HdfSbufGetDataSize(sBuf);
511     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
512 
513     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
514     ASSERT_NE(readBuf, nullptr);
515 
516     uint16_t val = 0;
517     for (int j = 0; j < loop; ++j) {
518         val = 0;
519         ret = HdfSbufReadUint16(readBuf, &val);
520         ASSERT_EQ(ret, true);
521         ASSERT_EQ(val, UINT16_MAX);
522     }
523     HdfSbufRecycle(readBuf);
524     HdfSbufRecycle(sBuf);
525 }
526 
527 /**
528   * @tc.name: SbufTestUInt8011
529   * @tc.desc: read write uint8 data
530   * @tc.type: FUNC
531   * @tc.require: AR000F869B
532   */
HWTEST_F(HdfSBufTest, SbufTestUInt8011, TestSize.Level1)533 HWTEST_F(HdfSBufTest, SbufTestUInt8011, TestSize.Level1)
534 {
535     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
536     ASSERT_NE(sBuf, nullptr);
537     bool ret;
538     int loop = DEFAULT_LOOP_COUNT;
539     for (int i = 0; i < loop; ++i) {
540         ret = HdfSbufWriteUint8(sBuf, UINT8_MAX);
541         ASSERT_EQ(ret, true);
542     }
543     size_t dataSize = HdfSbufGetDataSize(sBuf);
544     ASSERT_EQ(dataSize, loop * sizeof(uint32_t));
545 
546     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
547     ASSERT_NE(readBuf, nullptr);
548 
549     uint8_t val = 0;
550     for (int j = 0; j < loop; ++j) {
551         val = 0;
552         ret = HdfSbufReadUint8(readBuf, &val);
553         ASSERT_EQ(ret, true);
554         ASSERT_EQ(val, UINT8_MAX);
555     }
556     HdfSbufRecycle(readBuf);
557     HdfSbufRecycle(sBuf);
558 }
559 
560 /**
561   * @tc.name: SbufTestString012
562   * @tc.desc: read write string data
563   * @tc.type: FUNC
564   * @tc.require: AR000F869B
565   */
HWTEST_F(HdfSBufTest, SbufTestString012, TestSize.Level1)566 HWTEST_F(HdfSBufTest, SbufTestString012, TestSize.Level1)
567 {
568     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
569     ASSERT_NE(sBuf, nullptr);
570     bool ret;
571     int loop = DEFAULT_LOOP_COUNT;
572     std::string str("test");
573     for (int i = 0; i < loop; ++i) {
574         ret = HdfSbufWriteString(sBuf, str.data());
575         ASSERT_EQ(ret, true);
576     }
577 
578     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
579     ASSERT_NE(readBuf, nullptr);
580 
581     for (int j = 0; j < loop; ++j) {
582         const char *readStr = HdfSbufReadString(readBuf);
583         ASSERT_EQ(std::string(readStr), str);
584     }
585     HdfSbufRecycle(readBuf);
586     HdfSbufRecycle(sBuf);
587 }
588 
589 /**
590   * @tc.name: SbufTestNullString013
591   * @tc.desc: read write bullptr string data test
592   * @tc.type: FUNC
593   * @tc.require: AR000F869B
594   */
HWTEST_F(HdfSBufTest, SbufTestNullString013, TestSize.Level1)595 HWTEST_F(HdfSBufTest, SbufTestNullString013, TestSize.Level1)
596 {
597     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
598     ASSERT_NE(sBuf, nullptr);
599     auto ret = HdfSbufWriteString(sBuf, nullptr);
600     ASSERT_EQ(true, ret);
601     ret = HdfSbufWriteInt32(sBuf, INT32_MIN);
602     ASSERT_EQ(true, ret);
603     size_t dataSize = HdfSbufGetDataSize(sBuf);
604     ASSERT_NE(static_cast<size_t>(0), dataSize);
605     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
606     ASSERT_NE(readBuf, nullptr);
607     auto val = HdfSbufReadString(readBuf);
608     ASSERT_EQ(nullptr, val);
609     int32_t intVal = 0;
610     ret = HdfSbufReadInt32(readBuf, &intVal);
611     ASSERT_EQ(true, ret);
612     ASSERT_EQ(INT32_MIN, intVal);
613     HdfSbufRecycle(readBuf);
614     HdfSbufRecycle(sBuf);
615 }
616 
617 /**
618   * @tc.name: SbufTestBuffer014
619   * @tc.desc: read write buffer test
620   * @tc.type: FUNC
621   * @tc.require: AR000F869B
622   */
HWTEST_F(HdfSBufTest, SbufTestBuffer014, TestSize.Level1)623 HWTEST_F(HdfSBufTest, SbufTestBuffer014, TestSize.Level1)
624 {
625     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
626     ASSERT_NE(sBuf, nullptr);
627     bool ret;
628     int loop = 1;
629     std::string str("test");
630     for (int i = 0; i < loop; ++i) {
631         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
632         ASSERT_EQ(ret, true);
633     }
634 
635     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
636     ASSERT_NE(readBuf, nullptr);
637 
638     for (int j = 0; j < loop; ++j) {
639         const char *data = nullptr;
640         uint32_t readSize = 0;
641         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
642         ASSERT_EQ(ret, true);
643         ASSERT_EQ(readSize, str.size() + 1);
644         ASSERT_EQ(std::string(data), str);
645     }
646     HdfSbufRecycle(readBuf);
647     HdfSbufRecycle(sBuf);
648 }
649 
650 /**
651   * @tc.name: SbufTestNullBuffer015
652   * @tc.desc: read write nullptr buffer data
653   * @tc.type: FUNC
654   * @tc.require: AR000F869B
655   */
HWTEST_F(HdfSBufTest, SbufTestNullBuffer015, TestSize.Level1)656 HWTEST_F(HdfSBufTest, SbufTestNullBuffer015, TestSize.Level1)
657 {
658     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
659     ASSERT_NE(sBuf, nullptr);
660     auto ret = HdfSbufWriteBuffer(sBuf, nullptr, 0);
661     ASSERT_EQ(true, ret);
662     ret = HdfSbufWriteInt16(sBuf, INT16_MIN);
663     ASSERT_EQ(true, ret);
664     size_t dataSize = HdfSbufGetDataSize(sBuf);
665     ASSERT_NE(static_cast<size_t>(0), dataSize);
666     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
667     ASSERT_NE(readBuf, nullptr);
668     const uint8_t *buffVal = nullptr;
669     uint32_t buffLen = 0;
670     ret = HdfSbufReadBuffer(readBuf, (const void **)(&buffVal), &buffLen);
671     ASSERT_EQ(true, ret);
672     ASSERT_EQ(static_cast<uint32_t>(0), buffLen);
673     dataSize = HdfSbufGetDataSize(sBuf);
674     ASSERT_NE(static_cast<size_t>(0), dataSize);
675     int16_t intVal = 0;
676     ret = HdfSbufReadInt16(readBuf, &intVal);
677     ASSERT_EQ(true, ret);
678     ASSERT_EQ(INT16_MIN, intVal);
679     HdfSbufRecycle(sBuf);
680     HdfSbufRecycle(readBuf);
681 }
682 
683 /**
684   * @tc.name: SbufTestRandomDataSeq016
685   * @tc.desc: read write random data test
686   * @tc.type: FUNC
687   * @tc.require: AR000F869B
688   */
HWTEST_F(HdfSBufTest, SbufTestRandomDataSeq016, TestSize.Level0)689 HWTEST_F(HdfSBufTest, SbufTestRandomDataSeq016, TestSize.Level0)
690 {
691     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
692     ASSERT_NE(sBuf, nullptr);
693 
694     GenDataTable();
695     GenDataSequence(100);
696     bool ret = PushDataSequence(sBuf);
697     ASSERT_EQ(true, ret);
698 
699     HdfSBuf *readBuf = HdfSbufBind((uintptr_t)HdfSbufGetData(sBuf), HdfSbufGetDataSize(sBuf));
700     ASSERT_NE(readBuf, nullptr);
701 
702     ret = PullDataSequence(readBuf);
703     ASSERT_EQ(true, ret);
704     HdfSbufRecycle(sBuf);
705     HdfSbufRecycle(readBuf);
706 }
707 
708 /**
709   * @tc.name: SbufTestRandomRWDataSeq017
710   * @tc.desc: read write random data sequence test
711   * @tc.type: FUNC
712   * @tc.require: AR000F869B
713   */
HWTEST_F(HdfSBufTest, SbufTestRandomRWDataSeq017, TestSize.Level0)714 HWTEST_F(HdfSBufTest, SbufTestRandomRWDataSeq017, TestSize.Level0)
715 {
716     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
717     ASSERT_NE(sBuf, nullptr);
718 
719     GenDataTable();
720     GenDataSequence(100);
721     bool ret = PushDataSequence(sBuf);
722     ASSERT_EQ(true, ret);
723 
724     ret = PullDataSequence(sBuf);
725     ASSERT_EQ(true, ret);
726 
727     ret = PushDataSequence(sBuf);
728     ASSERT_EQ(true, ret);
729 
730     ret = PullDataSequence(sBuf);
731     ASSERT_EQ(true, ret);
732 
733     uint8_t val = 0;
734     ret = HdfSbufReadUint8(sBuf, &val);
735     ASSERT_EQ(false, ret);
736     ASSERT_EQ(0, val);
737 
738     HdfSbufRecycle(sBuf);
739 }
740 
741 /**
742   * @tc.name: SbufTestSbufMove018
743   * @tc.desc: move sbuf test
744   * @tc.type: FUNC
745   * @tc.require: AR000F869B
746   */
HWTEST_F(HdfSBufTest, SbufTestSbufMove018, TestSize.Level1)747 HWTEST_F(HdfSBufTest, SbufTestSbufMove018, TestSize.Level1)
748 {
749     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
750     ASSERT_NE(sBuf, nullptr);
751 
752     GenDataTable();
753     GenDataSequence(100);
754 
755     bool ret;
756     int loop = 1;
757     std::string str("test");
758     for (int i = 0; i < loop; ++i) {
759         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
760         ASSERT_EQ(ret, true);
761     }
762 
763     HdfSBuf *readBuf = HdfSbufMove(sBuf);
764     ASSERT_NE(readBuf, nullptr);
765 
766     for (int j = 0; j < loop; ++j) {
767         const char *data = nullptr;
768         uint32_t readSize = 0;
769         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
770         ASSERT_EQ(ret, true);
771         ASSERT_EQ(readSize, str.size() + 1);
772         ASSERT_EQ(std::string(data), str);
773     }
774     HdfSbufRecycle(sBuf);
775     HdfSbufRecycle(readBuf);
776 }
777 
778 /**
779   * @tc.name: SbufTestSbufMoveHalf019
780   * @tc.desc: move sbuf after read test
781   * @tc.type: FUNC
782   * @tc.require: AR000F869B
783   */
HWTEST_F(HdfSBufTest, SbufTestSbufMoveHalf019, TestSize.Level1)784 HWTEST_F(HdfSBufTest, SbufTestSbufMoveHalf019, TestSize.Level1)
785 {
786     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
787     ASSERT_NE(sBuf, nullptr);
788 
789     bool ret;
790     int loop = 1;
791     std::string str("test");
792     for (int i = 0; i < loop; ++i) {
793         ret = HdfSbufWriteBuffer(sBuf, str.data(), str.size() + 1);
794         ASSERT_EQ(ret, true);
795     }
796     for (int j = 0; j < loop / 2; ++j) {
797         const char *data = nullptr;
798         uint32_t readSize = 0;
799         ret = HdfSbufReadBuffer(sBuf, (const void **)(&data), &readSize);
800         ASSERT_EQ(ret, true);
801         ASSERT_EQ(readSize, str.size() + 1);
802         ASSERT_EQ(std::string(data), str);
803     }
804 
805     HdfSBuf *readBuf = HdfSbufMove(sBuf);
806     ASSERT_NE(readBuf, nullptr);
807 
808     for (int j = 0; j < loop; ++j) {
809         const char *data = nullptr;
810         uint32_t readSize = 0;
811         ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
812         ASSERT_EQ(ret, true);
813         ASSERT_EQ(readSize, str.size() + 1);
814         ASSERT_EQ(std::string(data), str);
815     }
816 
817     const char *data = nullptr;
818     uint32_t readSize = 0;
819     ret = HdfSbufReadBuffer(readBuf, (const void **)(&data), &readSize);
820     ASSERT_EQ(ret, false);
821 
822     HdfSbufRecycle(sBuf);
823     HdfSbufRecycle(readBuf);
824 }
825 
826 #ifndef __LITEOS__
HWTEST_F(HdfSBufTest, SbufTestSbufString020, TestSize.Level1)827 HWTEST_F(HdfSBufTest, SbufTestSbufString020, TestSize.Level1)
828 {
829     const char16_t *str = u"test";
830     std::u16string strStr(str);
831     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
832     ASSERT_NE(sBuf, nullptr);
833     bool ret = HdfSbufWriteString16(sBuf, str, strStr.size());
834     ASSERT_EQ(ret, true);
835     const char16_t *readStr = HdfSbufReadString16(sBuf);
836     std::u16string readStrStr(readStr);
837     ASSERT_EQ(strStr.compare(readStrStr), 0);
838     HdfSbufRecycle(sBuf);
839 }
840 
HWTEST_F(HdfSBufTest, SbufTestSbufDouble021, TestSize.Level1)841 HWTEST_F(HdfSBufTest, SbufTestSbufDouble021, TestSize.Level1)
842 {
843     constexpr double eps = 1e-6;
844     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
845     ASSERT_NE(sBuf, nullptr);
846     double data = 1;
847     bool ret = HdfSbufWriteDouble(sBuf, data);
848     ASSERT_EQ(ret, true);
849     double readData = 0;
850     ret = HdfSbufReadDouble(sBuf, &readData);
851     ASSERT_EQ(ret, true);
852     ASSERT_EQ(fabs(data - readData) < eps, true);
853     HdfSbufRecycle(sBuf);
854 }
855 
856 HWTEST_F(HdfSBufTest, SbufTestSbufFloat022, TestSize.Level1)
857 {
858     constexpr float eps = 1e-6;
859     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
860     ASSERT_NE(sBuf, nullptr);
861     float data = 1;
862     bool ret = HdfSbufWriteFloat(sBuf, data);
863     ASSERT_EQ(ret, true);
864     float readData = 0;
865     ret = HdfSbufReadFloat(sBuf, &readData);
866     ASSERT_EQ(ret, true);
867     ASSERT_EQ(fabs(data - readData) < eps, true);
868     HdfSbufRecycle(sBuf);
869     HdfRemoteAdapterAddService(nullptr, nullptr);
870 }
871 
872 HWTEST_F(HdfSBufTest, SbufTestSbufFileDescriptor023, TestSize.Level1)
873 {
874     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
875     ASSERT_NE(sBuf, nullptr);
876     int fd = 0;
877     bool ret = HdfSbufWriteFileDescriptor(sBuf, fd);
878     ASSERT_EQ(ret, true);
879     int readFd = HdfSbufReadFileDescriptor(sBuf);
880     ASSERT_TRUE(readFd >= 0);
881     HdfSbufRecycle(sBuf);
882 }
883 
884 HWTEST_F(HdfSBufTest, SbufTestSbufGetCapacity024, TestSize.Level1)
885 {
886     constexpr int hdfSbufDefaultSize = 256;
887     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
888     ASSERT_NE(sBuf, nullptr);
889     size_t capacity = HdfSbufGetCapacity(sBuf);
890     ASSERT_EQ(capacity, hdfSbufDefaultSize);
891     HdfSbufRecycle(sBuf);
892 }
893 
894 HWTEST_F(HdfSBufTest, SbufTestSbufSetDataSize025, TestSize.Level1)
895 {
896     constexpr int hdfSbufTestSize = 128;
897     HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
898     ASSERT_NE(sBuf, nullptr);
899     HdfSbufSetDataSize(sBuf, hdfSbufTestSize);
900     ASSERT_EQ(HdfSbufGetDataSize(sBuf), hdfSbufTestSize);
901     HdfSbufRecycle(sBuf);
902 }
903 
904 HWTEST_F(HdfSBufTest, SbufTestSbufInt8026, TestSize.Level1)
905 {
906     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
907     ASSERT_NE(sBuf, nullptr);
908     int8_t data = 1;
909     bool ret = HdfSbufWriteInt8(sBuf, data);
910     ASSERT_EQ(ret, true);
911     int8_t readData;
912     HdfSbufReadInt8(sBuf, &readData);
913     ASSERT_TRUE(readData == data);
914     HdfSbufRecycle(sBuf);
915 }
916 
917 HWTEST_F(HdfSBufTest, SbufTestSbufInt16027, TestSize.Level1)
918 {
919     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
920     ASSERT_NE(sBuf, nullptr);
921     int16_t data = 1;
922     bool ret = HdfSbufWriteInt16(sBuf, data);
923     ASSERT_EQ(ret, true);
924     int16_t readData;
925     HdfSbufReadInt16(sBuf, &readData);
926     ASSERT_TRUE(readData == data);
927     HdfSbufRecycle(sBuf);
928 }
929 
930 HWTEST_F(HdfSBufTest, SbufTestSbufInt64028, TestSize.Level1)
931 {
932     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
933     ASSERT_NE(sBuf, nullptr);
934     int64_t data = 1;
935     bool ret = HdfSbufWriteInt64(sBuf, data);
936     ASSERT_EQ(ret, true);
937     int64_t readData;
938     HdfSbufReadInt64(sBuf, &readData);
939     ASSERT_TRUE(readData == data);
940     HdfSbufRecycle(sBuf);
941 }
942 
943 HWTEST_F(HdfSBufTest, SbufTestSbufGetCapacity029, TestSize.Level1)
944 {
945     constexpr size_t hdfSbufTestSize = 64;
946     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
947     ASSERT_NE(sBuf, nullptr);
948     int64_t data = 1;
949     bool ret = HdfSbufWriteInt64(sBuf, data);
950     ASSERT_EQ(ret, true);
951     size_t capacity = HdfSbufGetCapacity(sBuf);
952     ASSERT_EQ(capacity, hdfSbufTestSize);
953     HdfSbufRecycle(sBuf);
954 }
955 
956 HWTEST_F(HdfSBufTest, SbufTestSbufDataSize030, TestSize.Level1)
957 {
958     constexpr size_t hdfSbufTestSize = 0;
959     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
960     ASSERT_NE(sBuf, nullptr);
961     HdfSbufSetDataSize(sBuf, hdfSbufTestSize);
962     ASSERT_EQ(HdfSbufGetDataSize(sBuf), hdfSbufTestSize);
963     HdfSbufRecycle(sBuf);
964 }
965 
966 HWTEST_F(HdfSBufTest, SbufTestRead031, TestSize.Level1)
967 {
968     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
969     ASSERT_NE(sBuf, nullptr);
970     int ret = HdfSbufReadFloat(sBuf, NULL);
971     ASSERT_EQ(ret, false);
972     ret = HdfSbufReadDouble(sBuf, NULL);
973     ASSERT_EQ(ret, false);
974     ret = HdfSbufReadUint64(sBuf, NULL);
975     ASSERT_EQ(ret, false);
976     ret = HdfSbufReadUint32(sBuf, NULL);
977     ASSERT_EQ(ret, false);
978     ret = HdfSbufReadUint16(sBuf, NULL);
979     ASSERT_EQ(ret, false);
980     ret = HdfSbufReadUint8(sBuf, NULL);
981     ASSERT_EQ(ret, false);
982     ret = HdfSbufReadInt64(sBuf, NULL);
983     ASSERT_EQ(ret, false);
984     ret = HdfSbufReadInt32(sBuf, NULL);
985     ASSERT_EQ(ret, false);
986     ret = HdfSbufReadInt16(sBuf, NULL);
987     ASSERT_EQ(ret, false);
988     ret = HdfSbufReadInt8(sBuf, NULL);
989     ASSERT_EQ(ret, false);
990     HdfSbufRecycle(sBuf);
991 }
992 
993 HWTEST_F(HdfSBufTest, SbufTestReadBuffer032, TestSize.Level1)
994 {
995     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
996     ASSERT_NE(sBuf, nullptr);
997     int ret = HdfSbufReadBuffer(sBuf, NULL, NULL);
998     ASSERT_EQ(ret, false);
999     HdfSBuf *sBufRead = HdfSbufTypedObtain(SBUF_IPC);
1000     ASSERT_NE(sBufRead, nullptr);
1001     ret = HdfSbufReadBuffer(sBuf, (const void **)(&sBufRead), NULL);
1002     ASSERT_EQ(ret, false);
1003     HdfSbufRecycle(sBuf);
1004     HdfSbufRecycle(sBufRead);
1005 }
1006 
1007 HWTEST_F(HdfSBufTest, SbufTestWrite033, TestSize.Level1)
1008 {
1009     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
1010     ASSERT_NE(sBuf, nullptr);
1011     int ret = HdfSbufWriteRemoteService(sBuf, NULL);
1012     ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
1013     HdfSbufRecycle(sBuf);
1014 }
1015 
1016 HWTEST_F(HdfSBufTest, SbufTestGetData034, TestSize.Level1)
1017 {
1018     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
1019     ASSERT_NE(sBuf, nullptr);
1020     uint8_t *ret = HdfSbufGetData(sBuf);
1021     ASSERT_EQ(ret, nullptr);
1022     HdfSbufRecycle(sBuf);
1023 }
1024 
1025 HWTEST_F(HdfSBufTest, SbufTestSbufToParcel035, TestSize.Level1)
1026 {
1027     HdfSBuf *sBuf = HdfSbufTypedObtain(SBUF_IPC);
1028     ASSERT_NE(sBuf, nullptr);
1029     int ret = SbufToParcel(sBuf, NULL);
1030     ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
1031     ret = SbufToParcel(NULL, NULL);
1032     ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
1033     OHOS::MessageParcel *parcel = nullptr;
1034     ret = SbufToParcel(sBuf, &parcel);
1035     ASSERT_EQ(ret, HDF_SUCCESS);
1036     HdfSBuf *sBufPar = ParcelToSbuf(parcel);
1037     ASSERT_NE(sBufPar, nullptr);
1038     HdfSbufRecycle(sBuf);
1039     HdfSbufRecycle(sBufPar);
1040 }
1041 #endif
1042 } // namespace OHOS
1043