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