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: SetUp()40 void SetUp() override {} 41 TearDown()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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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__ 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 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