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 <gtest/gtest.h> 17#include <algorithm> 18#include <fstream> 19#include <iostream> 20#include "directory_ex.h" 21#include "parcel.h" 22#include "refbase.h" 23#include "securec.h" 24using namespace testing::ext; 25using namespace std; 26 27namespace OHOS { 28namespace { 29static const int BINDER_TYPE_HANDLE = 0x73682a85; // binder header type handle 30static const int BINDER_TYPE_FD = 0x66642a85; // binder header type fd 31const int MAX_PARCEL_SIZE = 1000; 32char g_data[MAX_PARCEL_SIZE]; 33class UtilsParcelTest : public testing::Test { 34public: 35 static constexpr size_t DEFAULT_CPACITY = 204800; // 200K 36 static constexpr size_t CAPACITY_THRESHOLD = 4096; // 4k 37 static void TearDownTestCase(void); 38}; 39 40void UtilsParcelTest::TearDownTestCase(void) 41{ 42 for (int i = 0; i < MAX_PARCEL_SIZE; i++) { 43 g_data[i] = 0; 44 } 45} 46 47class RemoteObject : public virtual Parcelable { 48public: 49 RemoteObject() { asRemote_ = true; }; 50 bool Marshalling(Parcel &parcel) const override; 51 static sptr<RemoteObject> Unmarshalling(Parcel &parcel); 52}; 53 54bool RemoteObject::Marshalling(Parcel &parcel) const 55{ 56 parcel_flat_binder_object flat; 57 flat.hdr.type = 0xff; 58 flat.flags = 0x7f; 59 flat.binder = 0; 60 flat.handle = (uint32_t)(-1); 61 flat.cookie = reinterpret_cast<uintptr_t>(this); 62 bool status = parcel.WriteBuffer(&flat, sizeof(parcel_flat_binder_object)); 63 if (!status) { 64 return false; 65 } 66 return true; 67} 68 69sptr<RemoteObject> RemoteObject::Unmarshalling(Parcel &parcel) 70{ 71 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object), false); 72 if (buffer == nullptr) { 73 return nullptr; 74 } 75 sptr<RemoteObject> obj = new RemoteObject(); 76 return obj; 77} 78 79class RemoteFdObject : public virtual Parcelable { 80public: 81 RemoteFdObject() { asRemote_ = true; }; 82 bool Marshalling(Parcel &parcel) const override; 83 static sptr<RemoteFdObject> Unmarshalling(Parcel &parcel); 84}; 85 86bool RemoteFdObject::Marshalling(Parcel &parcel) const 87{ 88 parcel_flat_binder_object flat; 89 flat.hdr.type = BINDER_TYPE_FD; 90 flat.flags = 0x7f; 91 flat.binder = 0; 92 flat.handle = (uint32_t)(-1); 93 flat.cookie = reinterpret_cast<uintptr_t>(this); 94 bool status = parcel.WriteBuffer(&flat, sizeof(parcel_flat_binder_object)); 95 if (!status) { 96 return false; 97 } 98 return true; 99} 100 101sptr<RemoteFdObject> RemoteFdObject::Unmarshalling(Parcel &parcel) 102{ 103 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object), false); 104 if (buffer == nullptr) { 105 return nullptr; 106 } 107 sptr<RemoteFdObject> obj = new RemoteFdObject(); 108 return obj; 109} 110 111class RemoteHandleObject : public virtual Parcelable { 112public: 113 RemoteHandleObject() { asRemote_ = true; }; 114 bool Marshalling(Parcel &parcel) const override; 115 static sptr<RemoteHandleObject> Unmarshalling(Parcel &parcel); 116}; 117 118bool RemoteHandleObject::Marshalling(Parcel &parcel) const 119{ 120 parcel_flat_binder_object flat; 121 flat.hdr.type = BINDER_TYPE_HANDLE; 122 flat.flags = 0x7f; 123 flat.binder = 0; 124 flat.handle = (uint32_t)(-1); 125 flat.cookie = reinterpret_cast<uintptr_t>(this); 126 bool status = parcel.WriteBuffer(&flat, sizeof(parcel_flat_binder_object)); 127 if (!status) { 128 return false; 129 } 130 return true; 131} 132 133sptr<RemoteHandleObject> RemoteHandleObject::Unmarshalling(Parcel &parcel) 134{ 135 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object), false); 136 if (buffer == nullptr) { 137 return nullptr; 138 } 139 sptr<RemoteHandleObject> obj = new RemoteHandleObject(); 140 return obj; 141} 142 143/*-------------------------------base data------------------------------------*/ 144 145struct TestData { 146 bool booltest; 147 int8_t int8test; 148 int16_t int16test; 149 int32_t int32test; 150 uint8_t uint8test; 151 uint16_t uint16test; 152 uint32_t uint32test; 153}; 154 155void WriteTestData(Parcel &parcel, const struct TestData &data) 156{ 157 bool result = false; 158 159 result = parcel.WriteBool(data.booltest); 160 EXPECT_EQ(result, true); 161 162 result = parcel.WriteInt8(data.int8test); 163 EXPECT_EQ(result, true); 164 165 result = parcel.WriteInt16(data.int16test); 166 EXPECT_EQ(result, true); 167 168 result = parcel.WriteInt32(data.int32test); 169 EXPECT_EQ(result, true); 170 171 result = parcel.WriteUint8(data.uint8test); 172 EXPECT_EQ(result, true); 173 174 result = parcel.WriteUint16(data.uint16test); 175 EXPECT_EQ(result, true); 176 177 result = parcel.WriteUint32(data.uint32test); 178 EXPECT_EQ(result, true); 179} 180 181void WriteUnalignedTestData(Parcel &parcel, const struct TestData &data) 182{ 183 bool result = false; 184 185 result = parcel.WriteBoolUnaligned(data.booltest); 186 EXPECT_EQ(result, true); 187 188 result = parcel.WriteInt8Unaligned(data.int8test); 189 EXPECT_EQ(result, true); 190 191 result = parcel.WriteInt16Unaligned(data.int16test); 192 EXPECT_EQ(result, true); 193 194 result = parcel.WriteUint8Unaligned(data.uint8test); 195 EXPECT_EQ(result, true); 196 197 result = parcel.WriteUint16Unaligned(data.uint16test); 198 EXPECT_EQ(result, true); 199} 200 201void ReadTestData(Parcel &parcel, const struct TestData &data) 202{ 203 bool readbool = parcel.ReadBool(); 204 EXPECT_EQ(readbool, data.booltest); 205 206 int8_t readint8 = parcel.ReadInt8(); 207 EXPECT_EQ(readint8, data.int8test); 208 209 int16_t readint16 = parcel.ReadInt16(); 210 EXPECT_EQ(readint16, data.int16test); 211 212 int32_t readint32 = parcel.ReadInt32(); 213 EXPECT_EQ(readint32, data.int32test); 214 215 uint8_t readuint8 = parcel.ReadUint8(); 216 EXPECT_EQ(readuint8, data.uint8test); 217 218 uint16_t readuint16 = parcel.ReadUint16(); 219 EXPECT_EQ(readuint16, data.uint16test); 220 221 uint32_t readuint32 = parcel.ReadUint32(); 222 EXPECT_EQ(readuint32, data.uint32test); 223} 224 225void ReadUnalignedTestData(Parcel &parcel, const struct TestData &data) 226{ 227 bool readbool = parcel.ReadBoolUnaligned(); 228 EXPECT_EQ(readbool, data.booltest); 229 230 int8_t readint8; 231 EXPECT_TRUE(parcel.ReadInt8Unaligned(readint8)); 232 EXPECT_EQ(readint8, data.int8test); 233 234 int16_t readint16; 235 EXPECT_TRUE(parcel.ReadInt16Unaligned(readint16)); 236 EXPECT_EQ(readint16, data.int16test); 237 238 uint8_t readuint8; 239 EXPECT_TRUE(parcel.ReadUint8Unaligned(readuint8)); 240 EXPECT_EQ(readuint8, data.uint8test); 241 242 uint16_t readuint16; 243 EXPECT_TRUE(parcel.ReadUint16Unaligned(readuint16)); 244 EXPECT_EQ(readuint16, data.uint16test); 245} 246 247void ReadTestDataWithTarget(Parcel &parcel, const struct TestData &data) 248{ 249 bool result = false; 250 bool boolVal = true; 251 result = parcel.ReadBool(boolVal); 252 EXPECT_EQ(result, true); 253 EXPECT_EQ(boolVal, data.booltest); 254 255 int8_t int8Val; 256 result = parcel.ReadInt8(int8Val); 257 EXPECT_EQ(result, true); 258 EXPECT_EQ(int8Val, data.int8test); 259 260 int16_t int16Val; 261 result = parcel.ReadInt16(int16Val); 262 EXPECT_EQ(result, true); 263 EXPECT_EQ(int16Val, data.int16test); 264 265 int32_t int32Val; 266 result = parcel.ReadInt32(int32Val); 267 EXPECT_EQ(result, true); 268 EXPECT_EQ(int32Val, data.int32test); 269 270 uint8_t uint8Val; 271 result = parcel.ReadUint8(uint8Val); 272 EXPECT_EQ(result, true); 273 EXPECT_EQ(uint8Val, data.uint8test); 274 275 uint16_t uint16Val; 276 result = parcel.ReadUint16(uint16Val); 277 EXPECT_EQ(result, true); 278 EXPECT_EQ(uint16Val, data.uint16test); 279 280 uint32_t uint32Val; 281 result = parcel.ReadUint32(uint32Val); 282 EXPECT_EQ(result, true); 283 EXPECT_EQ(uint32Val, data.uint32test); 284} 285 286/** 287 * Here to simulate the scenario of ipc sending data, the buffer will be released when the Parcel object is destructed. 288*/ 289bool SendData(void *&buffer, size_t size, const uint8_t *data) 290{ 291 if (size <= 0) { 292 return false; 293 } 294 buffer = malloc(size); 295 if (buffer == nullptr) { 296 return false; 297 } 298 if (memcpy_s(buffer, size, data, size) != EOK) { 299 return false; 300 } 301 return true; 302} 303 304/** 305 * @tc.name: test_parcel_001 306 * @tc.desc: test parcel CheckOffsets, WriteRemoteObject, RewindRead and 307 * RewindWrite failed. 308 * @tc.type: FUNC 309 */ 310HWTEST_F(UtilsParcelTest, test_parcel_001, TestSize.Level0) 311{ 312 Parcel parcel; 313 bool result = parcel.CheckOffsets(); 314 EXPECT_EQ(result, false); 315 result = parcel.WriteRemoteObject(nullptr); 316 EXPECT_EQ(result, false); 317 result = parcel.RewindRead(parcel.GetDataSize() + 1); 318 EXPECT_EQ(result, false); 319 result = parcel.RewindWrite(parcel.GetDataSize() + 1); 320 EXPECT_EQ(result, false); 321} 322 323/** 324 * @tc.name: test_parcel_readvec_001 325 * @tc.desc: test parcel read vector failed with invlalid input. 326 * @tc.type: FUNC 327 */ 328HWTEST_F(UtilsParcelTest, test_parcel_readvec_001, TestSize.Level0) 329{ 330 Parcel parcel; 331 332 bool result = parcel.ReadBoolVector(nullptr); 333 EXPECT_EQ(result, false); 334 335 result = parcel.ReadInt8Vector(nullptr); 336 EXPECT_EQ(result, false); 337 338 result = parcel.ReadInt16Vector(nullptr); 339 EXPECT_EQ(result, false); 340 341 result = parcel.ReadInt32Vector(nullptr); 342 EXPECT_EQ(result, false); 343 344 result = parcel.ReadInt64Vector(nullptr); 345 EXPECT_EQ(result, false); 346 347 result = parcel.ReadUInt8Vector(nullptr); 348 EXPECT_EQ(result, false); 349 350 result = parcel.ReadUInt16Vector(nullptr); 351 EXPECT_EQ(result, false); 352 353 result = parcel.ReadUInt32Vector(nullptr); 354 EXPECT_EQ(result, false); 355 356 result = parcel.ReadUInt64Vector(nullptr); 357 EXPECT_EQ(result, false); 358 359 result = parcel.ReadFloatVector(nullptr); 360 EXPECT_EQ(result, false); 361 362 result = parcel.ReadDoubleVector(nullptr); 363 EXPECT_EQ(result, false); 364 365 result = parcel.ReadStringVector(nullptr); 366 EXPECT_EQ(result, false); 367 368 result = parcel.ReadString16Vector(nullptr); 369 EXPECT_EQ(result, false); 370} 371 372static void ReadvecTestTwoFunc01() 373{ 374 Parcel parcel1; 375 parcel1.WriteInt32(-1); 376 std::vector<bool> val1; 377 bool x1 = true; 378 val1.push_back(x1); 379 bool result = parcel1.ReadBoolVector(&val1); 380 EXPECT_EQ(result, false); 381 382 Parcel parcel2; 383 parcel2.WriteInt32(-1); 384 std::vector<int8_t> val2; 385 int8_t x2 = 1; 386 val2.push_back(x2); 387 result = parcel2.ReadInt8Vector(&val2); 388 EXPECT_EQ(result, false); 389 390 Parcel parcel3; 391 parcel3.WriteInt32(-1); 392 std::vector<int16_t> val3; 393 int16_t x3 = 1; 394 val3.push_back(x3); 395 result = parcel3.ReadInt16Vector(&val3); 396 EXPECT_EQ(result, false); 397 398 Parcel parcel4; 399 parcel4.WriteInt32(-1); 400 std::vector<int32_t> val4; 401 int32_t x4 = 1; 402 val4.push_back(x4); 403 result = parcel4.ReadInt32Vector(&val4); 404 EXPECT_EQ(result, false); 405} 406 407static void ReadvecTestTwoFunc02() 408{ 409 Parcel parcel1; 410 parcel1.WriteInt32(-1); 411 std::vector<int64_t> val1; 412 int64_t x1 = 1; 413 val1.push_back(x1); 414 bool result = parcel1.ReadInt64Vector(&val1); 415 EXPECT_EQ(result, false); 416 417 Parcel parcel2; 418 parcel2.WriteInt32(-1); 419 std::vector<uint8_t> val2; 420 uint8_t x2 = 1; 421 val2.push_back(x2); 422 result = parcel2.ReadUInt8Vector(&val2); 423 EXPECT_EQ(result, false); 424 425 Parcel parcel3; 426 parcel3.WriteInt32(-1); 427 std::vector<uint16_t> val3; 428 uint16_t x3 = 1; 429 val3.push_back(x3); 430 result = parcel3.ReadUInt16Vector(&val3); 431 EXPECT_EQ(result, false); 432 433 Parcel parcel4; 434 parcel4.WriteInt32(-1); 435 std::vector<uint32_t> val4; 436 uint32_t x4 = 1; 437 val4.push_back(x4); 438 result = parcel4.ReadUInt32Vector(&val4); 439 EXPECT_EQ(result, false); 440} 441 442static void ReadvecTestTwoFunc03() 443{ 444 Parcel parcel1; 445 parcel1.WriteInt32(-1); 446 std::vector<uint64_t> val1; 447 uint64_t x1 = 1; 448 val1.push_back(x1); 449 bool result = parcel1.ReadUInt64Vector(&val1); 450 EXPECT_EQ(result, false); 451 452 Parcel parcel2; 453 parcel2.WriteInt32(-1); 454 std::vector<float> val2; 455 float x2 = 1; 456 val2.push_back(x2); 457 result = parcel2.ReadFloatVector(&val2); 458 EXPECT_EQ(result, false); 459 460 Parcel parcel3; 461 parcel3.WriteInt32(-1); 462 std::vector<double> val3; 463 double x3 = 1; 464 val3.push_back(x3); 465 result = parcel3.ReadDoubleVector(&val3); 466 EXPECT_EQ(result, false); 467 468 Parcel parcel4; 469 parcel4.WriteInt32(-1); 470 std::vector<std::string> val4; 471 std::string x4 = "test"; 472 val4.push_back(x4); 473 result = parcel4.ReadStringVector(&val4); 474 EXPECT_EQ(result, false); 475 476 Parcel parcel5; 477 parcel5.WriteInt32(-1); 478 std::vector<std::u16string> val5; 479 std::u16string x5 = u"test"; 480 val5.push_back(x5); 481 result = parcel5.ReadString16Vector(&val5); 482 EXPECT_EQ(result, false); 483} 484 485/** 486 * @tc.name: test_parcel_readvec_002 487 * @tc.desc: test parcel read vector failed with invlalid vector length -1. 488 * @tc.type: FUNC 489 */ 490HWTEST_F(UtilsParcelTest, test_parcel_readvec_002, TestSize.Level0) 491{ 492 ReadvecTestTwoFunc01(); 493 ReadvecTestTwoFunc02(); 494 ReadvecTestTwoFunc03(); 495} 496 497static void ReadvecTestThreeFunc01() 498{ 499 Parcel parcel1; 500 std::vector<bool> val1; 501 bool x1 = true; 502 val1.push_back(x1); 503 parcel1.WriteInt32(val1.max_size()); 504 bool result = parcel1.ReadBoolVector(&val1); 505 EXPECT_EQ(result, false); 506 507 Parcel parcel2; 508 std::vector<int8_t> val2; 509 int8_t x2 = 1; 510 val2.push_back(x2); 511 parcel2.WriteInt32(val2.max_size()); 512 result = parcel2.ReadInt8Vector(&val2); 513 EXPECT_EQ(result, false); 514 515 Parcel parcel3; 516 std::vector<int16_t> val3; 517 int16_t x3 = 1; 518 val3.push_back(x3); 519 parcel3.WriteInt32(val3.max_size()); 520 result = parcel3.ReadInt16Vector(&val3); 521 EXPECT_EQ(result, false); 522 523 Parcel parcel4; 524 std::vector<int32_t> val4; 525 int32_t x4 = 1; 526 val4.push_back(x4); 527 parcel4.WriteInt32(val4.max_size()); 528 result = parcel4.ReadInt32Vector(&val4); 529 EXPECT_EQ(result, false); 530} 531 532static void ReadvecTestThreeFunc02() 533{ 534 Parcel parcel1; 535 std::vector<int64_t> val1; 536 int64_t x1 = 1; 537 val1.push_back(x1); 538 parcel1.WriteInt32(val1.max_size()); 539 bool result = parcel1.ReadInt64Vector(&val1); 540 EXPECT_EQ(result, false); 541 542 Parcel parcel2; 543 std::vector<uint8_t> val2; 544 uint8_t x2 = 1; 545 val2.push_back(x2); 546 parcel2.WriteInt32(val2.max_size()); 547 result = parcel2.ReadUInt8Vector(&val2); 548 EXPECT_EQ(result, false); 549 550 Parcel parcel3; 551 std::vector<uint16_t> val3; 552 uint16_t x3 = 1; 553 val3.push_back(x3); 554 parcel3.WriteInt32(val3.max_size()); 555 result = parcel3.ReadUInt16Vector(&val3); 556 EXPECT_EQ(result, false); 557 558 Parcel parcel4; 559 std::vector<uint32_t> val4; 560 uint32_t x4 = 1; 561 val4.push_back(x4); 562 parcel4.WriteInt32(val4.max_size()); 563 result = parcel4.ReadUInt32Vector(&val4); 564 EXPECT_EQ(result, false); 565} 566 567static void ReadvecTestThreeFunc03() 568{ 569 Parcel parcel1; 570 std::vector<uint64_t> val1; 571 uint64_t x1 = 1; 572 val1.push_back(x1); 573 parcel1.WriteInt32(val1.max_size()); 574 bool result = parcel1.ReadUInt64Vector(&val1); 575 EXPECT_EQ(result, false); 576 577 Parcel parcel2; 578 std::vector<float> val2; 579 float x2 = 1; 580 val2.push_back(x2); 581 parcel2.WriteInt32(val2.max_size()); 582 result = parcel2.ReadFloatVector(&val2); 583 EXPECT_EQ(result, false); 584 585 Parcel parcel3; 586 std::vector<double> val3; 587 double x3 = 1; 588 val3.push_back(x3); 589 parcel3.WriteInt32(val3.max_size()); 590 result = parcel3.ReadDoubleVector(&val3); 591 EXPECT_EQ(result, false); 592 593 Parcel parcel4; 594 std::vector<std::string> val4; 595 std::string x4 = "test"; 596 val4.push_back(x4); 597 parcel4.WriteInt32(val4.max_size()); 598 result = parcel4.ReadStringVector(&val4); 599 EXPECT_EQ(result, false); 600 601 Parcel parcel5; 602 std::vector<std::u16string> val5; 603 std::u16string x5 = u"test"; 604 val5.push_back(x5); 605 parcel5.WriteInt32(val5.max_size()); 606 result = parcel5.ReadString16Vector(&val5); 607 EXPECT_EQ(result, false); 608} 609 610/** 611 * @tc.name: test_parcel_readvec_003 612 * @tc.desc: test parcel read vector failed with invlalid vector length 613 * std::vector::max_size(). 614 * @tc.type: FUNC 615 */ 616HWTEST_F(UtilsParcelTest, test_parcel_readvec_003, TestSize.Level0) 617{ 618 ReadvecTestThreeFunc01(); 619 ReadvecTestThreeFunc02(); 620 ReadvecTestThreeFunc03(); 621} 622 623static void WritevecTestOneFunc01(const size_t cap) 624{ 625 Parcel parcel(nullptr); 626 std::vector<bool> val1; 627 bool x1 = true; 628 for (int i = 0; i < cap / sizeof(bool); i++) { 629 val1.push_back(x1); 630 } 631 bool result = parcel.WriteBoolVector(val1); 632 EXPECT_EQ(result, false); 633 634 parcel.FlushBuffer(); 635 std::vector<int8_t> val2; 636 int8_t x2 = 1; 637 for (int i = 0; i < cap / sizeof(int8_t); i++) { 638 val2.push_back(x2); 639 } 640 result = parcel.WriteInt8Vector(val2); 641 EXPECT_EQ(result, false); 642 643 parcel.FlushBuffer(); 644 std::vector<int16_t> val3; 645 int16_t x3 = 1; 646 for (int i = 0; i < cap / sizeof(int16_t); i++) { 647 val3.push_back(x3); 648 } 649 result = parcel.WriteInt16Vector(val3); 650 EXPECT_EQ(result, false); 651 652 parcel.FlushBuffer(); 653 std::vector<int32_t> val4; 654 int32_t x4 = 1; 655 for (int i = 0; i < cap / sizeof(int32_t); i++) { 656 val4.push_back(x4); 657 } 658 result = parcel.WriteInt32Vector(val4); 659 EXPECT_EQ(result, false); 660} 661 662static void WritevecTestOneFunc02(const size_t cap) 663{ 664 Parcel parcel(nullptr); 665 std::vector<int64_t> val1; 666 int64_t x1 = 1; 667 for (int i = 0; i < cap / sizeof(int64_t); i++) { 668 val1.push_back(x1); 669 } 670 bool result = parcel.WriteInt64Vector(val1); 671 EXPECT_EQ(result, false); 672 673 parcel.FlushBuffer(); 674 std::vector<uint8_t> val2; 675 uint8_t x2 = 1; 676 for (int i = 0; i < cap / sizeof(uint8_t); i++) { 677 val2.push_back(x2); 678 } 679 result = parcel.WriteUInt8Vector(val2); 680 EXPECT_EQ(result, false); 681 682 parcel.FlushBuffer(); 683 std::vector<uint16_t> val3; 684 uint16_t x3 = 1; 685 for (int i = 0; i < cap / sizeof(uint16_t); i++) { 686 val3.push_back(x3); 687 } 688 result = parcel.WriteUInt16Vector(val3); 689 EXPECT_EQ(result, false); 690 691 parcel.FlushBuffer(); 692 std::vector<uint32_t> val4; 693 uint32_t x4 = 1; 694 for (int i = 0; i < cap / sizeof(uint32_t); i++) { 695 val4.push_back(x4); 696 } 697 result = parcel.WriteUInt32Vector(val4); 698 EXPECT_EQ(result, false); 699} 700 701static void WritevecTestOneFunc03(const size_t cap) 702{ 703 Parcel parcel(nullptr); 704 std::vector<uint64_t> val1; 705 uint64_t x1 = 1; 706 for (int i = 0; i < cap / sizeof(uint64_t); i++) { 707 val1.push_back(x1); 708 } 709 bool result = parcel.WriteUInt64Vector(val1); 710 EXPECT_EQ(result, false); 711 712 parcel.FlushBuffer(); 713 std::vector<float> val2; 714 float x2 = 1; 715 for (int i = 0; i < cap / sizeof(float); i++) { 716 val2.push_back(x2); 717 } 718 result = parcel.WriteFloatVector(val2); 719 EXPECT_EQ(result, false); 720 721 parcel.FlushBuffer(); 722 std::vector<double> val3; 723 double x3 = 1; 724 for (int i = 0; i < cap / sizeof(double); i++) { 725 val3.push_back(x3); 726 } 727 result = parcel.WriteDoubleVector(val3); 728 EXPECT_EQ(result, false); 729 730 parcel.FlushBuffer(); 731 std::vector<std::string> val4; 732 std::string x4((cap / sizeof(char)), 't'); 733 val4.push_back(x4); 734 result = parcel.WriteStringVector(val4); 735 EXPECT_EQ(result, false); 736 737 parcel.FlushBuffer(); 738 std::vector<std::u16string> val5; 739 std::u16string x5((cap / sizeof(char16_t)), u't'); 740 val5.push_back(x5); 741 result = parcel.WriteString16Vector(val5); 742 EXPECT_EQ(result, false); 743} 744 745/** 746 * @tc.name: test_parcel_writevec_001 747 * @tc.desc: test parcel write vector failed with writting data out of the 748 * maximum capacity. 749 * @tc.type: FUNC 750 */ 751HWTEST_F(UtilsParcelTest, test_parcel_writevec_001, TestSize.Level0) 752{ 753 size_t cap = DEFAULT_CPACITY; 754 755 WritevecTestOneFunc01(cap); 756 WritevecTestOneFunc02(cap); 757 WritevecTestOneFunc03(cap); 758} 759 760/** 761 * @tc.name: test_parcel_SetMaxCapacity_001 762 * @tc.desc: test parcel primary type read write. 763 * @tc.type: FUNC 764 */ 765HWTEST_F(UtilsParcelTest, test_parcel_SetMaxCapacity_001, TestSize.Level0) 766{ 767 size_t cap = DEFAULT_CPACITY; 768 Parcel parcel(nullptr); 769 EXPECT_TRUE(parcel.SetMaxCapacity(cap + 1)); 770 EXPECT_FALSE(parcel.SetMaxCapacity(cap - 1)); 771} 772 773/** 774 * @tc.name: test_parcel_SetAllocator_001 775 * @tc.desc: test setting allocator to parcels with and without existed allocator. 776 * @tc.type: FUNC 777 */ 778HWTEST_F(UtilsParcelTest, test_parcel_SetAllocator_001, TestSize.Level0) 779{ 780 Allocator* alloc = new DefaultAllocator(); 781 Parcel parcel(alloc); 782 EXPECT_FALSE(parcel.SetAllocator(alloc)); 783 EXPECT_FALSE(parcel.SetAllocator(nullptr)); 784 785 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; 786 787 WriteTestData(parcel, data); 788 parcel.SetAllocator(new DefaultAllocator()); 789 ReadTestData(parcel, data); 790} 791 792/** 793 * @tc.name: test_parcel_write_001 794 * @tc.desc: test parcel write failed. 795 * @tc.type: FUNC 796 */ 797HWTEST_F(UtilsParcelTest, test_parcel_write_001, TestSize.Level0) 798{ 799 Parcel parcel1; 800 parcel1.WriteBool(true); 801 Parcel parcel2; 802 void *buffer = nullptr; 803 size_t size = parcel1.GetDataSize(); 804 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 805 ASSERT_FALSE(false); 806 } 807 parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 808 809 string str8write; 810 bool result = parcel2.WriteString(str8write); 811 EXPECT_EQ(result, false); 812 813 u16string str16Write; 814 result = parcel2.WriteString16(str16Write); 815 EXPECT_EQ(result, false); 816 817 result = parcel2.WriteBool(false); 818 EXPECT_EQ(result, false); 819 820 result = parcel2.WriteBoolUnaligned(false); 821 EXPECT_EQ(result, false); 822 823 result = parcel2.WriteInt8(false); 824 EXPECT_EQ(result, false); 825 826 result = parcel2.WriteInt8Unaligned(false); 827 EXPECT_EQ(result, false); 828 829 result = parcel2.WriteInt32(false); 830 EXPECT_EQ(result, false); 831 832 result = parcel2.WriteInt64(false); 833 EXPECT_EQ(result, false); 834 835 result = parcel2.WriteUint8(false); 836 EXPECT_EQ(result, false); 837 838 result = parcel2.WriteUint16(false); 839 EXPECT_EQ(result, false); 840 841 result = parcel2.WriteUint8Unaligned(false); 842 EXPECT_EQ(result, false); 843 844 result = parcel2.WriteUint16Unaligned(false); 845 EXPECT_EQ(result, false); 846 847 result = parcel2.WriteUint32(false); 848 EXPECT_EQ(result, false); 849 850 result = parcel2.WriteUint64(false); 851 EXPECT_EQ(result, false); 852 853 result = parcel2.WriteFloat(false); 854 EXPECT_EQ(result, false); 855 856 result = parcel2.WriteDouble(false); 857 EXPECT_EQ(result, false); 858 859 result = parcel2.WritePointer(false); 860 EXPECT_EQ(result, false); 861} 862 863/** 864 * @tc.name: test_parcel_WriteAndRead_001 865 * @tc.desc: test parcel primary type read write. 866 * @tc.type: FUNC 867 */ 868HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_001, TestSize.Level0) 869{ 870 Parcel parcel(nullptr); 871 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; 872 WriteTestData(parcel, data); 873 ReadTestData(parcel, data); 874 875 WriteUnalignedTestData(parcel, data); 876 ReadUnalignedTestData(parcel, data); 877} 878 879/** 880 * @tc.name: test_parcel_WriteAndRead_002 881 * @tc.desc: test parcel primary type read write. 882 * @tc.type: FUNC 883 */ 884HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_002, TestSize.Level0) 885{ 886 Parcel parcel1(nullptr); 887 Parcel parcel2(nullptr); 888 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; 889 WriteTestData(parcel1, data); 890 WriteUnalignedTestData(parcel1, data); 891 892 void *buffer = nullptr; 893 size_t size = parcel1.GetDataSize(); 894 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 895 ASSERT_FALSE(false); 896 } 897 898 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 899 EXPECT_EQ(result, true); 900 901 ReadTestData(parcel2, data); 902 ReadUnalignedTestData(parcel2, data); 903} 904 905/** 906 * @tc.name: test_parcel_WriteAndRead_003 907 * @tc.desc: test parcel primary type read write. 908 * @tc.type: FUNC 909 */ 910HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_003, TestSize.Level0) 911{ 912 Parcel parcel1(nullptr); 913 Parcel parcel2(nullptr); 914 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; 915 WriteTestData(parcel1, data); 916 917 void *buffer = nullptr; 918 size_t size = parcel1.GetDataSize(); 919 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 920 ASSERT_FALSE(false); 921 } 922 923 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 924 EXPECT_EQ(result, true); 925 926 ReadTestDataWithTarget(parcel2, data); 927} 928 929/** 930 * @tc.name: test_parcel_WriteAndRead_004 931 * @tc.desc: test parcel primary type read write. 932 * @tc.type: FUNC 933 */ 934HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_004, TestSize.Level0) 935{ 936 Parcel parcel1(nullptr); 937 938 int64_t int64test = -0x1234567887654321; 939 bool result = parcel1.WriteInt64(int64test); 940 EXPECT_EQ(result, true); 941 942 uint64_t uint64test = 0x1234567887654321; 943 result = parcel1.WriteUint64(uint64test); 944 EXPECT_EQ(result, true); 945 946 int64_t readint64 = parcel1.ReadInt64(); 947 EXPECT_EQ(readint64, int64test); 948 949 uint64_t readuint64 = parcel1.ReadUint64(); 950 EXPECT_EQ(readuint64, uint64test); 951 952 Parcel parcel2(nullptr); 953 954 void *buffer = nullptr; 955 size_t size = parcel1.GetDataSize(); 956 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 957 ASSERT_FALSE(false); 958 } 959 960 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 961 962 readint64 = parcel2.ReadInt64(); 963 EXPECT_EQ(readint64, int64test); 964 965 readuint64 = parcel2.ReadUint64(); 966 EXPECT_EQ(readuint64, uint64test); 967} 968 969/** 970 * @tc.name: test_parcel_WriteAndRead_String_001 971 * @tc.desc: test parcel string read write. 972 * @tc.type: FUNC 973 */ 974HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_001, TestSize.Level0) 975{ 976 Parcel parcel1(nullptr); 977 978 string strWrite = "test"; 979 bool result = parcel1.WriteString(strWrite); 980 EXPECT_EQ(result, true); 981 982 string strWrite1 = 983 "test for write string padded**********************************************************##################"; 984 result = parcel1.WriteString(strWrite1); 985 EXPECT_EQ(result, true); 986 987 string strWrite2 = 988 "test for write string padded**********************************************************##################"; 989 result = parcel1.WriteString(strWrite2); 990 EXPECT_EQ(result, true); 991 992 string strRead = parcel1.ReadString(); 993 string strRead1 = parcel1.ReadString(); 994 string strRead2 = parcel1.ReadString(); 995 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 996 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str())); 997 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str())); 998 999 Parcel parcel2(nullptr); 1000 1001 void *buffer = nullptr; 1002 size_t size = parcel1.GetDataSize(); 1003 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1004 ASSERT_FALSE(false); 1005 } 1006 1007 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1008 1009 strRead = parcel2.ReadString(); 1010 strRead1 = parcel2.ReadString(); 1011 strRead2 = parcel2.ReadString(); 1012 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 1013 EXPECT_EQ(0, strcmp(strRead1.c_str(), strWrite1.c_str())); 1014 EXPECT_EQ(0, strcmp(strRead2.c_str(), strWrite2.c_str())); 1015} 1016 1017/** 1018 * @tc.name: test_parcel_WriteAndRead_String_002 1019 * @tc.desc: test parcel string read write. 1020 * @tc.type: FUNC 1021 */ 1022HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_002, TestSize.Level0) 1023{ 1024 Parcel parcel1(nullptr); 1025 1026 u16string str16Write = u"12345"; 1027 bool result = parcel1.WriteString16(str16Write); 1028 EXPECT_EQ(result, true); 1029 1030 u16string str16Write2 = u"12345 test for write16string padded*********"; 1031 result = parcel1.WriteString16(str16Write2); 1032 EXPECT_EQ(result, true); 1033 1034 u16string str16Read = parcel1.ReadString16(); 1035 u16string str16Read2 = parcel1.ReadString16(); 1036 EXPECT_EQ(0, str16Read.compare(str16Write)); 1037 EXPECT_EQ(0, str16Read2.compare(str16Write2)); 1038 1039 Parcel parcel2(nullptr); 1040 1041 void *buffer = nullptr; 1042 size_t size = parcel1.GetDataSize(); 1043 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1044 ASSERT_FALSE(false); 1045 } 1046 1047 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1048 1049 str16Read = parcel2.ReadString16(); 1050 str16Read2 = parcel2.ReadString16(); 1051 EXPECT_EQ(0, str16Read.compare(str16Write)); 1052 EXPECT_EQ(0, str16Read2.compare(str16Write2)); 1053} 1054 1055/** 1056 * @tc.name: test_parcel_WriteAndRead_String_003 1057 * @tc.desc: test parcel CString read write. 1058 * @tc.type: FUNC 1059 */ 1060HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_003, TestSize.Level0) 1061{ 1062 Parcel parcel(nullptr); 1063 string test1 = "12345"; 1064 string test2 = "23456"; 1065 string test3 = "34567"; 1066 string test4 = "45678"; 1067 bool result = parcel.WriteCString(nullptr); 1068 EXPECT_FALSE(result); 1069 result = parcel.WriteCString(test1.c_str()); 1070 EXPECT_TRUE(result); 1071 result = parcel.WriteCString(test2.c_str()); 1072 EXPECT_TRUE(result); 1073 result = parcel.WriteCString(test3.c_str()); 1074 EXPECT_TRUE(result); 1075 result = parcel.WriteCString(test4.c_str()); 1076 EXPECT_TRUE(result); 1077 1078 EXPECT_EQ(0, strcmp(test1.c_str(), parcel.ReadCString())); 1079 EXPECT_EQ(0, strcmp(test2.c_str(), parcel.ReadCString())); 1080 EXPECT_EQ(0, strcmp(test3.c_str(), parcel.ReadCString())); 1081 EXPECT_EQ(0, strcmp(test4.c_str(), parcel.ReadCString())); 1082} 1083 1084/** 1085 * @tc.name: test_parcel_WriteAndRead_String004 1086 * @tc.desc: test parcel CString read write. 1087 * @tc.type: FUNC 1088 */ 1089HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String004, TestSize.Level0) 1090{ 1091 Parcel parcel1(nullptr); 1092 bool result = false; 1093 1094 // write from Java, read from C++ 1095 result = parcel1.WriteString16WithLength(nullptr, 0); 1096 EXPECT_EQ(result, true); 1097 1098 u16string str16write = u"12345"; 1099 char16_t *value1 = str16write.data(); 1100 result = parcel1.WriteString16WithLength(value1, str16write.length()); 1101 EXPECT_EQ(result, true); 1102 1103 u16string str16write2 = u"12345 test for write16string padded*********"; 1104 char16_t *value2 = str16write2.data(); 1105 result = parcel1.WriteString16WithLength(value2, str16write2.length()); 1106 EXPECT_EQ(result, true); 1107 1108 u16string str16readNull = parcel1.ReadString16(); 1109 u16string str16read1 = parcel1.ReadString16(); 1110 u16string str16read2 = parcel1.ReadString16(); 1111 EXPECT_EQ(0, str16readNull.compare(std::u16string())); 1112 EXPECT_EQ(0, str16read1.compare(str16write)); 1113 EXPECT_EQ(0, str16read2.compare(str16write2)); 1114 1115 // write from C++, read from Java 1116 result = parcel1.WriteString16(str16write); 1117 EXPECT_EQ(result, true); 1118 1119 result = parcel1.WriteString16(str16write2); 1120 EXPECT_EQ(result, true); 1121 1122 int32_t readLength1 = 0; 1123 u16string str16read3 = parcel1.ReadString16WithLength(readLength1); 1124 EXPECT_EQ(readLength1, static_cast<int32_t>(str16write.length())); 1125 1126 int32_t readLength2 = 0; 1127 u16string str16read4 = parcel1.ReadString16WithLength(readLength2); 1128 EXPECT_EQ(readLength2, static_cast<int32_t>(str16write2.length())); 1129 1130 EXPECT_EQ(0, str16read3.compare(str16write)); 1131 EXPECT_EQ(0, str16read4.compare(str16write2)); 1132} 1133 1134/** 1135 * @tc.name: test_parcel_WriteAndRead_String005 1136 * @tc.desc: test parcel CString read write. 1137 * @tc.type: FUNC 1138 */ 1139HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String005, TestSize.Level0) 1140{ 1141 Parcel parcel1(nullptr); 1142 bool result = false; 1143 1144 // write from Java, read from C++ 1145 result = parcel1.WriteString8WithLength(nullptr, 0); 1146 EXPECT_EQ(result, true); 1147 1148 string str8write = "12345"; 1149 char *value1 = str8write.data(); 1150 result = parcel1.WriteString8WithLength(value1, str8write.length()); 1151 EXPECT_EQ(result, true); 1152 1153 string str8write2 = "12345 test for write16string padded*********"; 1154 char *value2 = str8write2.data(); 1155 result = parcel1.WriteString8WithLength(value2, str8write2.length()); 1156 EXPECT_EQ(result, true); 1157 1158 string str8readNull = parcel1.ReadString(); 1159 string str8read1 = parcel1.ReadString(); 1160 string str8read2 = parcel1.ReadString(); 1161 EXPECT_EQ(0, str8readNull.compare(std::string())); 1162 EXPECT_EQ(0, str8read1.compare(str8write)); 1163 EXPECT_EQ(0, str8read2.compare(str8write2)); 1164 1165 // write from C++, read from Java 1166 result = parcel1.WriteString(str8write); 1167 EXPECT_EQ(result, true); 1168 1169 result = parcel1.WriteString(str8write2); 1170 EXPECT_EQ(result, true); 1171 1172 int32_t readLength1 = 0; 1173 string str8read3 = parcel1.ReadString8WithLength(readLength1); 1174 EXPECT_EQ(readLength1, static_cast<int32_t>(str8write.length())); 1175 1176 int32_t readLength2 = 0; 1177 string str8read4 = parcel1.ReadString8WithLength(readLength2); 1178 EXPECT_EQ(readLength2, static_cast<int32_t>(str8write2.length())); 1179 1180 EXPECT_EQ(0, str8read3.compare(str8write)); 1181 EXPECT_EQ(0, str8read4.compare(str8write2)); 1182} 1183 1184/** 1185 * @tc.name: test_parcel_WriteAndRead_Float_001 1186 * @tc.desc: test parcel float types read write. 1187 * @tc.type: FUNC 1188 */ 1189HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_Float_001, TestSize.Level0) 1190{ 1191 Parcel parcel1(nullptr); 1192 1193 float floatwrite = 12.345678f; 1194 bool result = parcel1.WriteFloat(floatwrite); 1195 EXPECT_EQ(result, true); 1196 1197 double doublewrite = 1345.7653; 1198 result = parcel1.WriteDouble(doublewrite); 1199 EXPECT_EQ(result, true); 1200 1201 float floatread; 1202 result = parcel1.ReadFloat(floatread); 1203 EXPECT_EQ(result, true); 1204 EXPECT_EQ(floatwrite, floatread); 1205 1206 double doubleread; 1207 doubleread = parcel1.ReadDouble(); 1208 EXPECT_EQ(doublewrite, doubleread); 1209 1210 Parcel parcel2(nullptr); 1211 1212 void *buffer = nullptr; 1213 size_t size = parcel1.GetDataSize(); 1214 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1215 ASSERT_FALSE(false); 1216 } 1217 1218 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1219 result = parcel2.ReadFloat(floatread); 1220 EXPECT_EQ(result, true); 1221 EXPECT_EQ(floatwrite, floatread); 1222 1223 doubleread = parcel2.ReadDouble(); 1224 EXPECT_EQ(doublewrite, doubleread); 1225} 1226 1227/** 1228 * @tc.name: test_parcel_WriteAndRead_String_005 1229 * @tc.desc: test parcel String type read write. 1230 * @tc.type: FUNC 1231 */ 1232HWTEST_F(UtilsParcelTest, test_parcel_WriteAndRead_String_005, TestSize.Level0) 1233{ 1234 Parcel parcel1(nullptr); 1235 1236 string strwrite = "test"; 1237 bool result = parcel1.WriteString(strwrite); 1238 EXPECT_EQ(result, true); 1239 1240 string strwrite1 = 1241 "test for write string padded**********************************************************##################"; 1242 result = parcel1.WriteString(strwrite1); 1243 EXPECT_EQ(result, true); 1244 1245 string strwrite2 = 1246 "test for write string padded**********************************************************##################"; 1247 result = parcel1.WriteString(strwrite2); 1248 EXPECT_EQ(result, true); 1249 1250 string strread; 1251 string strread1; 1252 string strread2; 1253 result = parcel1.ReadString(strread); 1254 EXPECT_EQ(result, true); 1255 result = parcel1.ReadString(strread1); 1256 EXPECT_EQ(result, true); 1257 result = parcel1.ReadString(strread2); 1258 EXPECT_EQ(result, true); 1259 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str())); 1260 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str())); 1261 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str())); 1262 1263 Parcel parcel2(nullptr); 1264 1265 void *buffer = nullptr; 1266 size_t size = parcel1.GetDataSize(); 1267 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1268 ASSERT_FALSE(false); 1269 } 1270 1271 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1272 EXPECT_EQ(result, true); 1273 1274 result = parcel2.ReadString(strread); 1275 EXPECT_EQ(result, true); 1276 result = parcel2.ReadString(strread1); 1277 EXPECT_EQ(result, true); 1278 result = parcel2.ReadString(strread2); 1279 EXPECT_EQ(result, true); 1280 EXPECT_EQ(0, strcmp(strread.c_str(), strwrite.c_str())); 1281 EXPECT_EQ(0, strcmp(strread1.c_str(), strwrite1.c_str())); 1282 EXPECT_EQ(0, strcmp(strread2.c_str(), strwrite2.c_str())); 1283} 1284 1285struct Padded { 1286 char title; 1287 int32_t handle; 1288 uint64_t cookie; 1289}; 1290 1291struct Unpadded { 1292 char tip; 1293}; 1294 1295void ValidatePadded(const struct Padded &left, const struct Padded &right) 1296{ 1297 EXPECT_EQ(left.title, right.title); 1298 EXPECT_EQ(left.handle, right.handle); 1299 EXPECT_EQ(left.cookie, right.cookie); 1300} 1301 1302void ValidateUnpadded(const struct Unpadded &left, const struct Unpadded &right) 1303{ 1304 EXPECT_EQ(left.tip, right.tip); 1305} 1306 1307/** 1308 * @tc.name: test_CalcNewCapacity_001 1309 * @tc.desc: test kinds of input to CalcNewCapacity. 1310 * @tc.type: FUNC 1311 */ 1312HWTEST_F(UtilsParcelTest, test_CalcNewCapacity_001, TestSize.Level0) 1313{ 1314 Parcel parcel; 1315 1316 size_t newMaxCapacity; 1317 size_t minNewCapacity = CAPACITY_THRESHOLD; 1318 const string strLenThreshd = string(minNewCapacity, 't'); 1319 bool ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLenThreshd.data()), minNewCapacity); 1320 EXPECT_EQ(true, ret); // calculated capacity = CAPACITY_THRESHOLD 1321 1322 newMaxCapacity = CAPACITY_THRESHOLD - 1; 1323 minNewCapacity = newMaxCapacity; 1324 const string strLessThreshd = string(minNewCapacity, 'l'); 1325 parcel.SetMaxCapacity(newMaxCapacity); 1326 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strLessThreshd.data()), minNewCapacity); 1327 EXPECT_EQ(true, ret); // calculated capacity = newMaxCapacity 1328 1329 newMaxCapacity = -1; // minNewCapacity = CAPACITY_THRESHOLD - 1 1330 const string strNoMaxCap = string(minNewCapacity, 'n'); 1331 parcel.SetMaxCapacity(newMaxCapacity); 1332 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strNoMaxCap.data()), minNewCapacity); 1333 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD 1334 1335 minNewCapacity = CAPACITY_THRESHOLD + 1; // newMaxCapacity = -1 1336 const string strExtThreshd = string(minNewCapacity, 'e'); 1337 parcel.SetMaxCapacity(newMaxCapacity); 1338 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strExtThreshd.data()), minNewCapacity); 1339 EXPECT_EQ(ret, true); // calculated capacity = 2 * CAPACITY_THRESHOLD 1340 1341 newMaxCapacity = CAPACITY_THRESHOLD; // minNewCapacity = CAPACITY_THRESHOLD + 1 1342 const string strCapThreshd = string(minNewCapacity, 'e'); 1343 parcel.SetMaxCapacity(newMaxCapacity); 1344 ret = parcel.WriteUnpadBuffer(static_cast<const void *>(strCapThreshd.data()), minNewCapacity); 1345 EXPECT_EQ(ret, true); // calculated capacity = CAPACITY_THRESHOLD 1346} 1347 1348/** 1349 * @tc.name: test_SetDataCapacity_001 1350 * @tc.desc: test kinds of input to SetDataCapacity. 1351 * @tc.type: FUNC 1352 */ 1353HWTEST_F(UtilsParcelTest, test_SetDataCapacity_001, TestSize.Level0) 1354{ 1355 Parcel parcel; 1356 struct TestData data = { true, -0x34, 0x5634, -0x12345678, 0x34, 0x5634, 0x12345678 }; 1357 1358 WriteTestData(parcel, data); 1359 bool result = parcel.SetDataCapacity(0); 1360 EXPECT_FALSE(result); 1361} 1362 1363/** 1364 * @tc.name: test_SetDataSize_001 1365 * @tc.desc: test kinds of input to SetDataSize. 1366 * @tc.type: FUNC 1367 */ 1368HWTEST_F(UtilsParcelTest, test_SetDataSize_001, TestSize.Level0) 1369{ 1370 Parcel parcel; 1371 1372 bool result = parcel.SetDataCapacity(sizeof(bool)); 1373 EXPECT_TRUE(result); 1374 result = parcel.WriteBool(true); 1375 EXPECT_TRUE(result); 1376 result = parcel.SetDataSize(DEFAULT_CPACITY + 1); 1377 EXPECT_FALSE(result); 1378} 1379 1380/** 1381 * @tc.name: test_parcel_Data_Structure_001 1382 * @tc.desc: test parcel struct data related function. 1383 * @tc.type: FUNC 1384 */ 1385HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_001, TestSize.Level0) 1386{ 1387 Parcel parcel(nullptr); 1388 1389 const struct Padded pad = { 'p', 0x34567890, -0x2345678998765432 }; 1390 const struct Unpadded unpad = { 'u' }; 1391 1392 bool result = parcel.WriteBuffer(static_cast<const void *>(&pad), sizeof(struct Padded)); 1393 EXPECT_EQ(true, result); 1394 const struct Padded *padRead = reinterpret_cast<const struct Padded *>(parcel.ReadBuffer(sizeof(struct Padded))); 1395 ValidatePadded(*padRead, pad); 1396 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition()); 1397 1398 result = parcel.WriteBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded)); 1399 const struct Unpadded *unpadRead = 1400 reinterpret_cast<const struct Unpadded *>(parcel.ReadBuffer(sizeof(struct Unpadded))); 1401 ValidateUnpadded(*unpadRead, unpad); 1402 EXPECT_NE(parcel.GetWritePosition(), parcel.GetReadPosition()); 1403 1404 parcel.RewindRead(0); 1405 parcel.RewindWrite(0); 1406 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition()); 1407 1408 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&pad), sizeof(struct Padded)); 1409 EXPECT_EQ(true, result); 1410 const struct Padded *padReadNew = 1411 reinterpret_cast<const struct Padded *>(parcel.ReadUnpadBuffer(sizeof(struct Padded))); 1412 ValidatePadded(*padReadNew, pad); 1413 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition()); 1414 1415 result = parcel.WriteUnpadBuffer(static_cast<const void *>(&unpad), sizeof(struct Unpadded)); 1416 EXPECT_EQ(true, result); 1417 const struct Unpadded *unpadReadNew = 1418 reinterpret_cast<const struct Unpadded *>(parcel.ReadUnpadBuffer(sizeof(struct Unpadded))); 1419 ValidateUnpadded(*unpadReadNew, unpad); 1420 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetReadPosition()); 1421} 1422 1423/** 1424 * @tc.name: test_parcel_Data_Structure_002 1425 * @tc.desc: test invalid input to WriteBuffer and WriteBufferAddTerminator. 1426 * @tc.type: FUNC 1427 */ 1428HWTEST_F(UtilsParcelTest, test_parcel_Data_Structure_002, TestSize.Level0) 1429{ 1430 Parcel parcel(nullptr); 1431 1432 const string str = "test invalid input"; 1433 const string strOverflow = "test write with SIZE_MAX bytes"; 1434 const string strWriteFail = string((DEFAULT_CPACITY + 1) / sizeof(char), 'f'); 1435 const string strWriteTermFail = string((DEFAULT_CPACITY - 2) / sizeof(char), 't'); 1436 1437 bool result = parcel.WriteBuffer(nullptr, sizeof(string)); 1438 EXPECT_EQ(false, result); 1439 result = parcel.WriteBufferAddTerminator(nullptr, sizeof(string), sizeof(char)); 1440 EXPECT_EQ(false, result); 1441 1442 result = parcel.WriteBuffer(static_cast<const void *>(str.data()), 0); 1443 EXPECT_EQ(false, result); 1444 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), 0, sizeof(char)); 1445 EXPECT_EQ(false, result); 1446 1447 result = parcel.WriteBuffer(static_cast<const void *>(strWriteFail.data()), strWriteFail.length()); 1448 EXPECT_EQ(false, result); 1449 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(strWriteFail.data()), 1450 strWriteFail.length(), sizeof(char)); 1451 EXPECT_EQ(false, result); 1452 1453 result = parcel.WriteBufferAddTerminator(static_cast<const void *>(str.data()), str.length(), sizeof(char)); 1454 EXPECT_EQ(true, result); 1455 1456 Parcel recvParcel(nullptr); 1457 void *buffer = nullptr; 1458 size_t size = parcel.GetDataSize(); 1459 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel.GetData()))) { 1460 ASSERT_FALSE(false); 1461 } 1462 result = recvParcel.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel.GetDataSize()); 1463 EXPECT_EQ(result, true); 1464 result = recvParcel.WriteBufferAddTerminator(static_cast<const void *>(&str), str.length() + 1, sizeof(char)); 1465 EXPECT_EQ(result, false); 1466} 1467 1468struct VectorTestData { 1469 vector<bool> booltest = { false, false, true, false, true }; 1470 vector<int8_t> int8test = { 0x01, 0x10, -0x20, 0x30, 0x40 }; 1471 vector<int16_t> int16test = { 0x1234, -0x2345, 0x3456, -0x4567, 0x5678 }; 1472 vector<int32_t> int32test = { 0x12345678, -0x23456789, 0x34567890, -0x45678901 }; 1473 vector<int64_t> int64test = { 0x1234567887654321, -0x2345678998765432 }; 1474 vector<uint8_t> uint8test = { 0x01, 0x10, 0x20, 0x30, 0x40 }; 1475 vector<uint16_t> uint16test = { 0x1234, 0x2345, 0x3456, 0x4567, 0x5678 }; 1476 vector<uint32_t> uint32test = { 0x12345678, 0x23456789, 0x34567890, 0x45678901 }; 1477 vector<uint64_t> uint64test = { 0x1234567887654321, 0x2345678998765432 }; 1478}; 1479 1480void WriteVectorTestData(Parcel &parcel, const VectorTestData &data) 1481{ 1482 bool result = parcel.WriteBoolVector(data.booltest); 1483 EXPECT_EQ(result, true); 1484 result = parcel.WriteInt8Vector(data.int8test); 1485 EXPECT_EQ(result, true); 1486 result = parcel.WriteInt16Vector(data.int16test); 1487 EXPECT_EQ(result, true); 1488 result = parcel.WriteInt32Vector(data.int32test); 1489 EXPECT_EQ(result, true); 1490 result = parcel.WriteInt64Vector(data.int64test); 1491 EXPECT_EQ(result, true); 1492 result = parcel.WriteUInt8Vector(data.uint8test); 1493 EXPECT_EQ(result, true); 1494 result = parcel.WriteUInt16Vector(data.uint16test); 1495 EXPECT_EQ(result, true); 1496 result = parcel.WriteUInt32Vector(data.uint32test); 1497 EXPECT_EQ(result, true); 1498 result = parcel.WriteUInt64Vector(data.uint64test); 1499 EXPECT_EQ(result, true); 1500} 1501 1502void ReadVectorTestDataFunc01(Parcel &parcel, const VectorTestData &data) 1503{ 1504 vector<bool> boolread; 1505 vector<int8_t> int8read; 1506 vector<int16_t> int16read; 1507 vector<int32_t> int32read; 1508 vector<int64_t> int64read; 1509 1510 bool result = parcel.ReadBoolVector(&boolread); 1511 EXPECT_EQ(result, true); 1512 for (size_t i = 0; i < data.booltest.size(); i++) { 1513 EXPECT_EQ(data.booltest[i], boolread[i]); 1514 } 1515 1516 result = parcel.ReadInt8Vector(&int8read); 1517 EXPECT_EQ(result, true); 1518 for (size_t i = 0; i < data.int8test.size(); i++) { 1519 EXPECT_EQ(data.int8test[i], int8read[i]); 1520 } 1521 1522 result = parcel.ReadInt16Vector(&int16read); 1523 EXPECT_EQ(result, true); 1524 for (size_t i = 0; i < data.int16test.size(); i++) { 1525 EXPECT_EQ(data.int16test[i], int16read[i]); 1526 } 1527 1528 result = parcel.ReadInt32Vector(&int32read); 1529 EXPECT_EQ(result, true); 1530 for (size_t i = 0; i < data.int32test.size(); i++) { 1531 EXPECT_EQ(data.int32test[i], int32read[i]); 1532 } 1533 1534 result = parcel.ReadInt64Vector(&int64read); 1535 EXPECT_EQ(result, true); 1536 for (size_t i = 0; i < data.int64test.size(); i++) { 1537 EXPECT_EQ(data.int64test[i], int64read[i]); 1538 } 1539} 1540 1541void ReadVectorTestDataFunc02(Parcel &parcel, const VectorTestData &data) 1542{ 1543 vector<uint8_t> uint8read; 1544 vector<uint16_t> uint16read; 1545 vector<uint32_t> uint32read; 1546 vector<uint64_t> uint64read; 1547 1548 bool result = parcel.ReadUInt8Vector(&uint8read); 1549 EXPECT_EQ(result, true); 1550 for (size_t i = 0; i < data.uint8test.size(); i++) { 1551 EXPECT_EQ(data.uint8test[i], uint8read[i]); 1552 } 1553 1554 result = parcel.ReadUInt16Vector(&uint16read); 1555 EXPECT_EQ(result, true); 1556 for (size_t i = 0; i < data.uint16test.size(); i++) { 1557 EXPECT_EQ(data.uint16test[i], uint16read[i]); 1558 } 1559 1560 result = parcel.ReadUInt32Vector(&uint32read); 1561 EXPECT_EQ(result, true); 1562 for (size_t i = 0; i < data.uint32test.size(); i++) { 1563 EXPECT_EQ(data.uint32test[i], uint32read[i]); 1564 } 1565 1566 result = parcel.ReadUInt64Vector(&uint64read); 1567 EXPECT_EQ(result, true); 1568 for (size_t i = 0; i < data.uint64test.size(); i++) { 1569 EXPECT_EQ(data.uint64test[i], uint64read[i]); 1570 } 1571} 1572 1573void ReadVectorTestData(Parcel &parcel, const VectorTestData &data) 1574{ 1575 ReadVectorTestDataFunc01(parcel, data); 1576 ReadVectorTestDataFunc02(parcel, data); 1577} 1578 1579/** 1580 * @tc.name: test_parcel_WriteAndReadVector_001 1581 * @tc.desc: test vector parcel read and write. 1582 * @tc.type: FUNC 1583 */ 1584HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_001, TestSize.Level0) 1585{ 1586 Parcel parcel(nullptr); 1587 struct VectorTestData data; 1588 1589 WriteVectorTestData(parcel, data); 1590 ReadVectorTestData(parcel, data); 1591} 1592 1593/** 1594 * @tc.name: test_parcel_WriteAndReadVector_002 1595 * @tc.desc: test vector parcel read and write. 1596 * @tc.type: FUNC 1597 */ 1598HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_002, TestSize.Level0) 1599{ 1600 Parcel parcel1(nullptr); 1601 struct VectorTestData data; 1602 WriteVectorTestData(parcel1, data); 1603 1604 Parcel parcel2(nullptr); 1605 1606 void *buffer = nullptr; 1607 size_t size = parcel1.GetDataSize(); 1608 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1609 ASSERT_FALSE(false); 1610 } 1611 1612 bool result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1613 EXPECT_EQ(result, true); 1614 ReadVectorTestData(parcel2, data); 1615} 1616 1617/** 1618 * @tc.name: test_parcel_WriteAndReadVector_003 1619 * @tc.desc: test vector parcel read and write. 1620 * @tc.type: FUNC 1621 */ 1622HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_003, TestSize.Level0) 1623{ 1624 Parcel parcel1(nullptr); 1625 Parcel parcel2(nullptr); 1626 1627 vector<string> stringtest{ "test", "test for", "test for write", "test for write vector" }; 1628 vector<u16string> string16test{ u"test", u"test for", u"test for write", u"test for write vector" }; 1629 1630 bool result = parcel1.WriteStringVector(stringtest); 1631 EXPECT_EQ(result, true); 1632 result = parcel1.WriteString16Vector(string16test); 1633 EXPECT_EQ(result, true); 1634 1635 vector<string> stringread; 1636 result = parcel1.ReadStringVector(&stringread); 1637 EXPECT_EQ(result, true); 1638 for (size_t i = 0; i < stringtest.size(); i++) { 1639 EXPECT_EQ(stringtest[i], stringread[i]); 1640 } 1641 1642 vector<u16string> u16stringread; 1643 result = parcel1.ReadString16Vector(&u16stringread); 1644 EXPECT_EQ(result, true); 1645 for (size_t i = 0; i < string16test.size(); i++) { 1646 EXPECT_EQ(0, string16test[i].compare(u16stringread[i])); 1647 } 1648 1649 void *buffer = nullptr; 1650 size_t size = parcel1.GetDataSize(); 1651 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1652 ASSERT_FALSE(false); 1653 } 1654 1655 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1656 result = parcel2.ReadStringVector(&stringread); 1657 EXPECT_EQ(result, true); 1658 for (size_t i = 0; i < stringtest.size(); i++) { 1659 EXPECT_EQ(stringtest[i], stringread[i]); 1660 } 1661 1662 result = parcel2.ReadString16Vector(&u16stringread); 1663 EXPECT_EQ(result, true); 1664 for (size_t i = 0; i < string16test.size(); i++) { 1665 EXPECT_EQ(0, string16test[i].compare(u16stringread[i])); 1666 } 1667} 1668 1669/** 1670 * @tc.name: test_parcel_WriteAndReadVector_004 1671 * @tc.desc: test vector parcel read and write. 1672 * @tc.type: FUNC 1673 */ 1674HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_004, TestSize.Level0) 1675{ 1676 Parcel parcel1(nullptr); 1677 Parcel parcel2(nullptr); 1678 1679 vector<float> floattest{ 11221.132313, 11221.45678 }; 1680 vector<double> doubletest{ 1122.132313, 1122.45678 }; 1681 1682 bool result = parcel1.WriteFloatVector(floattest); 1683 EXPECT_EQ(result, true); 1684 1685 result = parcel1.WriteDoubleVector(doubletest); 1686 EXPECT_EQ(result, true); 1687 1688 vector<float> floatread; 1689 vector<double> doubleread; 1690 1691 result = parcel1.ReadFloatVector(&floatread); 1692 EXPECT_EQ(result, true); 1693 for (size_t i = 0; i < floattest.size(); i++) { 1694 EXPECT_EQ(floattest[i], floatread[i]); 1695 } 1696 1697 result = parcel1.ReadDoubleVector(&doubleread); 1698 EXPECT_EQ(result, true); 1699 for (size_t i = 0; i < doubletest.size(); i++) { 1700 EXPECT_EQ(doubletest[i], doubleread[i]); 1701 } 1702} 1703 1704bool CallWriteVector(Parcel &parcel, const std::vector<bool> &vectorTest) 1705{ 1706 return parcel.WriteBoolVector(vectorTest); 1707} 1708 1709bool CallWriteVector(Parcel &parcel, const std::vector<int8_t> &vectorTest) 1710{ 1711 return parcel.WriteInt8Vector(vectorTest); 1712} 1713 1714bool CallWriteVector(Parcel &parcel, const std::vector<int16_t> &vectorTest) 1715{ 1716 return parcel.WriteInt16Vector(vectorTest); 1717} 1718 1719bool CallWriteVector(Parcel &parcel, const std::vector<int32_t> &vectorTest) 1720{ 1721 return parcel.WriteInt32Vector(vectorTest); 1722} 1723 1724bool CallWriteVector(Parcel &parcel, const std::vector<int64_t> &vectorTest) 1725{ 1726 return parcel.WriteInt64Vector(vectorTest); 1727} 1728 1729bool CallWriteVector(Parcel &parcel, const std::vector<uint8_t> &vectorTest) 1730{ 1731 return parcel.WriteUInt8Vector(vectorTest); 1732} 1733 1734bool CallWriteVector(Parcel &parcel, const std::vector<uint16_t> &vectorTest) 1735{ 1736 return parcel.WriteUInt16Vector(vectorTest); 1737} 1738 1739bool CallWriteVector(Parcel &parcel, const std::vector<uint32_t> &vectorTest) 1740{ 1741 return parcel.WriteUInt32Vector(vectorTest); 1742} 1743 1744bool CallWriteVector(Parcel &parcel, const std::vector<uint64_t> &vectorTest) 1745{ 1746 return parcel.WriteUInt64Vector(vectorTest); 1747} 1748 1749bool CallWriteVector(Parcel &parcel, const std::vector<float> &vectorTest) 1750{ 1751 return parcel.WriteFloatVector(vectorTest); 1752} 1753 1754bool CallWriteVector(Parcel &parcel, const std::vector<double> &vectorTest) 1755{ 1756 return parcel.WriteDoubleVector(vectorTest); 1757} 1758 1759bool CallWriteVector(Parcel &parcel, const std::vector<std::string> &vectorTest) 1760{ 1761 return parcel.WriteStringVector(vectorTest); 1762} 1763 1764bool CallWriteVector(Parcel &parcel, const std::vector<std::u16string> &vectorTest) 1765{ 1766 return parcel.WriteString16Vector(vectorTest); 1767} 1768 1769template <typename T> 1770void ParcelWriteVector(const std::vector<T> &vectorTest) 1771{ 1772 Parcel parcel1(nullptr); 1773 Parcel parcel2(nullptr); 1774 bool result = CallWriteVector(parcel1, vectorTest); 1775 EXPECT_EQ(result, true); 1776 1777 void *buffer = nullptr; 1778 size_t size = parcel1.GetDataSize(); 1779 if (!SendData(buffer, size, reinterpret_cast<const uint8_t *>(parcel1.GetData()))) { 1780 ASSERT_FALSE(false); 1781 } 1782 result = parcel2.ParseFrom(reinterpret_cast<uintptr_t>(buffer), parcel1.GetDataSize()); 1783 EXPECT_EQ(result, true); 1784 1785 result = CallWriteVector(parcel2, vectorTest); 1786 EXPECT_EQ(result, false); 1787} 1788 1789/** 1790 * @tc.name: test_parcel_WriteAndReadVector_005 1791 * @tc.desc: test vector parcel write failed. 1792 * @tc.type: FUNC 1793 */ 1794HWTEST_F(UtilsParcelTest, test_parcel_WriteAndReadVector_005, TestSize.Level0) 1795{ 1796 vector<bool> boolVectorTest { true, false }; 1797 vector<int8_t> int8VectorTest { 1, 0 }; 1798 vector<int16_t> int16VectorTest { 1, 0 }; 1799 vector<int32_t> int32VectorTest { 1, 0 }; 1800 vector<int64_t> int64VectorTest { 1, 0 }; 1801 vector<uint8_t> uint8VectorTest { 1, 0 }; 1802 vector<uint16_t> uint16VectorTest { 1, 0 }; 1803 vector<uint32_t> uint32VectorTest { 1, 0 }; 1804 vector<uint64_t> uint64VectorTest { 1, 0 }; 1805 vector<float> floatVectorTest { 1.1, 0 }; 1806 vector<double> doubleVectorTest { 1.1, 0 }; 1807 vector<std::string> stringVectorTest { "true", "false" }; 1808 vector<std::u16string> string16VectorTest { u"true", u"false" }; 1809 1810 ParcelWriteVector(boolVectorTest); 1811 ParcelWriteVector(int8VectorTest); 1812 ParcelWriteVector(int16VectorTest); 1813 ParcelWriteVector(int32VectorTest); 1814 ParcelWriteVector(int64VectorTest); 1815 ParcelWriteVector(uint8VectorTest); 1816 ParcelWriteVector(uint16VectorTest); 1817 ParcelWriteVector(uint32VectorTest); 1818 ParcelWriteVector(uint64VectorTest); 1819 ParcelWriteVector(floatVectorTest); 1820 ParcelWriteVector(doubleVectorTest); 1821 ParcelWriteVector(stringVectorTest); 1822 ParcelWriteVector(string16VectorTest); 1823} 1824 1825class TestParcelable : public virtual Parcelable { 1826public: 1827 TestParcelable() = default; 1828 ~TestParcelable() = default; 1829 1830 bool Marshalling(Parcel &parcel) const override; 1831 static TestParcelable *Unmarshalling(Parcel &parcel); 1832 1833public: 1834 int32_t int32Write_ = -0x12345678; 1835 int32_t int32Read_; 1836}; 1837 1838bool TestParcelable::Marshalling(Parcel &parcel) const 1839{ 1840 bool result = parcel.WriteInt32(this->int32Write_); 1841 return result; 1842} 1843 1844TestParcelable *TestParcelable::Unmarshalling(Parcel &parcel) 1845{ 1846 auto *read = new TestParcelable(); 1847 read->int32Read_ = parcel.ReadInt32(); 1848 return read; 1849} 1850 1851/** 1852 * @tc.name: test_parcel_parcelable_001 1853 * @tc.desc: test parcel read and write parcelable obj. 1854 * @tc.type: FUNC 1855 */ 1856HWTEST_F(UtilsParcelTest, test_parcel_parcelable_001, TestSize.Level0) 1857{ 1858 Parcel parcel(nullptr); 1859 sptr<TestParcelable> parcelableWrite = new TestParcelable(); 1860 bool result = false; 1861 1862 result = parcel.WriteParcelable(parcelableWrite); 1863 EXPECT_EQ(true, result); 1864 EXPECT_EQ(parcel.GetWritePosition(), parcel.GetDataSize()); 1865 1866 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>(); 1867 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_); 1868 EXPECT_EQ(parcel.GetReadPosition(), parcel.GetDataSize()); 1869} 1870 1871/** 1872 * @tc.name: test_parcel_parcelable_002 1873 * @tc.desc: test parcel read and write parcelable obj. 1874 * @tc.type: FUNC 1875 */ 1876HWTEST_F(UtilsParcelTest, test_parcel_parcelable_002, TestSize.Level0) 1877{ 1878 Parcel parcel(nullptr); 1879 1880 bool result = parcel.WriteParcelable(nullptr); 1881 EXPECT_EQ(true, result); 1882 1883 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>(); 1884 EXPECT_EQ(nullptr, parcelableRead); 1885} 1886 1887/** 1888 * @tc.name: test_parcel_parcelable_003 1889 * @tc.desc: test parcel read and write parcelable obj. 1890 * @tc.type: FUNC 1891 */ 1892HWTEST_F(UtilsParcelTest, test_parcel_parcelable_003, TestSize.Level0) 1893{ 1894 Parcel parcel(nullptr); 1895 sptr<TestParcelable> parcelableWriteNull; 1896 bool result = parcel.WriteStrongParcelable(parcelableWriteNull); 1897 EXPECT_EQ(true, result); 1898 1899 sptr<TestParcelable> parcelableWrite = new TestParcelable(); 1900 1901 bool test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); 1902 EXPECT_EQ(false, test); 1903 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC); 1904 EXPECT_EQ(false, test); 1905 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC); 1906 EXPECT_EQ(false, test); 1907 1908 result = parcel.WriteStrongParcelable(parcelableWrite); 1909 EXPECT_EQ(true, result); 1910 1911 sptr<TestParcelable> parcelableReadNull = parcel.ReadParcelable<TestParcelable>(); 1912 EXPECT_EQ(nullptr, parcelableReadNull); 1913 1914 sptr<TestParcelable> parcelableRead = parcel.ReadParcelable<TestParcelable>(); 1915 EXPECT_EQ(parcelableWrite->int32Write_, parcelableRead->int32Read_); 1916 1917 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); 1918 EXPECT_EQ(true, test); 1919 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::IPC); 1920 EXPECT_EQ(false, test); 1921 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::RPC); 1922 EXPECT_EQ(false, test); 1923 1924 parcelableWrite->ClearBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); 1925 test = parcelableWrite->TestBehavior(Parcelable::BehaviorFlag::HOLD_OBJECT); 1926 EXPECT_EQ(false, test); 1927} 1928 1929/** 1930 * @tc.name: test_SetMaxCapacity_001 1931 * @tc.desc: test parcel capacity function. 1932 * @tc.type: FUNC 1933 */ 1934HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_001, TestSize.Level0) 1935{ 1936 Parcel parcel(nullptr); 1937 char test[48] = {0}; 1938 bool ret = parcel.WriteBuffer(test, 48); 1939 EXPECT_EQ(true, ret); 1940 // because default maxCap is 200 * 1024, so reset it more 1941 parcel.SetMaxCapacity(201 * 1024); 1942 // test write data over max capacity: 205780 + 48 > 201 * 1024 1943 char test2[205780] = {0}; 1944 ret = parcel.WriteBuffer(test2, 205780); 1945 EXPECT_EQ(false, ret); 1946} 1947 1948/** 1949 * @tc.name: test_SetMaxCapacity_002 1950 * @tc.desc: test parcel capacity function. 1951 * @tc.type: FUNC 1952 */ 1953HWTEST_F(UtilsParcelTest, test_SetMaxCapacity_002, TestSize.Level0) 1954{ 1955 Parcel parcel(nullptr); 1956 char test[48] = {0}; 1957 bool ret = parcel.WriteInt32(5767168); 1958 EXPECT_EQ(true, ret); 1959 ret = parcel.WriteBuffer(test, 48); 1960 EXPECT_EQ(true, ret); 1961 vector<std::u16string> val; 1962 ret = parcel.ReadString16Vector(&val); 1963 EXPECT_EQ(false, ret); 1964} 1965 1966HWTEST_F(UtilsParcelTest, test_ValidateReadData_001, TestSize.Level0) 1967{ 1968 Parcel parcel(nullptr); 1969 parcel.WriteBool(true); 1970 string strWrite = "test"; 1971 bool result = parcel.WriteString(strWrite); 1972 EXPECT_EQ(result, true); 1973 1974 RemoteObject obj1; 1975 result = parcel.WriteRemoteObject(&obj1); 1976 EXPECT_EQ(result, true); 1977 parcel.WriteInt32(5); 1978 RemoteObject obj2; 1979 result = parcel.WriteRemoteObject(&obj2); 1980 EXPECT_EQ(result, true); 1981 u16string str16Write = u"12345"; 1982 result = parcel.WriteString16(str16Write); 1983 EXPECT_EQ(result, true); 1984 1985 bool readBool = parcel.ReadBool(); 1986 EXPECT_EQ(readBool, true); 1987 1988 string strRead = parcel.ReadString(); 1989 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 1990 1991 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>(); 1992 EXPECT_EQ(true, readObj1.GetRefPtr() != nullptr); 1993 1994 int32_t readInt32 = parcel.ReadInt32(); 1995 EXPECT_EQ(readInt32, 5); 1996 1997 sptr<RemoteObject> readObj2 = parcel.ReadObject<RemoteObject>(); 1998 EXPECT_EQ(true, readObj2.GetRefPtr() != nullptr); 1999 2000 u16string str16Read = parcel.ReadString16(); 2001 EXPECT_EQ(0, str16Read.compare(str16Write)); 2002} 2003 2004HWTEST_F(UtilsParcelTest, test_ValidateReadData_002, TestSize.Level0) 2005{ 2006 Parcel parcel(nullptr); 2007 parcel.WriteBool(true); 2008 string strWrite = "test"; 2009 bool result = parcel.WriteString(strWrite); 2010 EXPECT_EQ(result, true); 2011 2012 RemoteObject obj1; 2013 result = parcel.WriteRemoteObject(&obj1); 2014 EXPECT_EQ(result, true); 2015 parcel.WriteInt32(5); 2016 RemoteObject obj2; 2017 result = parcel.WriteRemoteObject(&obj2); 2018 EXPECT_EQ(result, true); 2019 u16string str16Write = u"12345"; 2020 result = parcel.WriteString16(str16Write); 2021 EXPECT_EQ(result, true); 2022 2023 bool readBool = parcel.ReadBool(); 2024 EXPECT_EQ(readBool, true); 2025 2026 string strRead = parcel.ReadString(); 2027 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 2028 2029 int32_t readInt32 = parcel.ReadInt32(); 2030 EXPECT_EQ(readInt32, 0); 2031 2032 u16string str16Read = parcel.ReadString16(); 2033 EXPECT_EQ(0, str16Read.compare(std::u16string())); 2034 2035 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>(); 2036 EXPECT_EQ(true, readObj1.GetRefPtr() == nullptr); 2037} 2038 2039HWTEST_F(UtilsParcelTest, test_multiRemoteObjectReadBuffer_001, TestSize.Level0) 2040{ 2041 Parcel parcel(nullptr); 2042 2043 RemoteFdObject obj1; 2044 bool result = parcel.WriteRemoteObject(&obj1); 2045 EXPECT_EQ(result, true); 2046 2047 RemoteHandleObject obj2; 2048 result = parcel.WriteRemoteObject(&obj2); 2049 EXPECT_EQ(result, true); 2050 2051 RemoteObject obj3; 2052 result = parcel.WriteRemoteObject(&obj3); 2053 EXPECT_EQ(result, true); 2054 2055 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object) * 3); 2056 EXPECT_EQ(true, buffer == nullptr); 2057} 2058 2059HWTEST_F(UtilsParcelTest, test_multiRemoteObjectReadBuffer_002, TestSize.Level0) 2060{ 2061 Parcel parcel(nullptr); 2062 2063 RemoteFdObject obj1; 2064 bool result = parcel.WriteRemoteObject(&obj1); 2065 EXPECT_EQ(result, true); 2066 2067 RemoteObject obj2; 2068 result = parcel.WriteRemoteObject(&obj2); 2069 EXPECT_EQ(result, true); 2070 2071 RemoteHandleObject obj3; 2072 result = parcel.WriteRemoteObject(&obj3); 2073 EXPECT_EQ(result, true); 2074 2075 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object) * 3); 2076 EXPECT_EQ(true, buffer == nullptr); 2077} 2078 2079HWTEST_F(UtilsParcelTest, test_multiRemoteObjectReadBuffer_003, TestSize.Level0) 2080{ 2081 Parcel parcel(nullptr); 2082 2083 RemoteObject obj1; 2084 bool result = parcel.WriteRemoteObject(&obj1); 2085 EXPECT_EQ(result, true); 2086 2087 RemoteHandleObject obj2; 2088 result = parcel.WriteRemoteObject(&obj2); 2089 EXPECT_EQ(result, true); 2090 2091 RemoteFdObject obj3; 2092 result = parcel.WriteRemoteObject(&obj3); 2093 EXPECT_EQ(result, true); 2094 2095 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object) * 3); 2096 EXPECT_EQ(true, buffer == nullptr); 2097} 2098 2099HWTEST_F(UtilsParcelTest, test_multiRemoteObjectReadBuffer_004, TestSize.Level0) 2100{ 2101 Parcel parcel(nullptr); 2102 2103 RemoteFdObject obj1; 2104 bool result = parcel.WriteRemoteObject(&obj1); 2105 EXPECT_EQ(result, true); 2106 2107 RemoteHandleObject obj2; 2108 result = parcel.WriteRemoteObject(&obj2); 2109 EXPECT_EQ(result, true); 2110 2111 RemoteFdObject obj3; 2112 result = parcel.WriteRemoteObject(&obj3); 2113 EXPECT_EQ(result, true); 2114 2115 const uint8_t *buffer = parcel.ReadBuffer(sizeof(parcel_flat_binder_object) * 3); 2116 EXPECT_EQ(true, buffer != nullptr); 2117} 2118 2119HWTEST_F(UtilsParcelTest, test_multiRemoteObjectReadBuffer_005, TestSize.Level0) 2120{ 2121 Parcel parcel(nullptr); 2122 2123 RemoteFdObject obj1; 2124 bool result = parcel.WriteRemoteObject(&obj1); 2125 EXPECT_EQ(result, true); 2126 2127 RemoteObject obj2; 2128 result = parcel.WriteRemoteObject(&obj2); 2129 EXPECT_EQ(result, true); 2130 2131 RemoteHandleObject obj3; 2132 result = parcel.WriteRemoteObject(&obj3); 2133 EXPECT_EQ(result, true); 2134 2135 size_t readLength = 36; 2136 const uint8_t *buffer = parcel.ReadBuffer(readLength); 2137 EXPECT_EQ(true, buffer == nullptr); 2138} 2139 2140HWTEST_F(UtilsParcelTest, test_RewindWrite_001, TestSize.Level0) 2141{ 2142 Parcel parcel(nullptr); 2143 parcel.WriteInt32(5); 2144 string strWrite = "test"; 2145 parcel.WriteString(strWrite); 2146 RemoteObject obj1; 2147 parcel.WriteRemoteObject(&obj1); 2148 size_t pos = parcel.GetWritePosition(); 2149 parcel.WriteInt32(5); 2150 RemoteObject obj2; 2151 parcel.WriteRemoteObject(&obj2); 2152 u16string str16Write = u"12345"; 2153 parcel.WriteString16(str16Write); 2154 2155 bool result = parcel.RewindWrite(pos); 2156 EXPECT_EQ(result, true); 2157 parcel.WriteInt32(5); 2158 parcel.WriteInt32(5); 2159 2160 int32_t readint32 = parcel.ReadInt32(); 2161 EXPECT_EQ(readint32, 5); 2162 string strRead = parcel.ReadString(); 2163 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 2164 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>(); 2165 EXPECT_EQ(true, readObj1.GetRefPtr() != nullptr); 2166 readint32 = parcel.ReadInt32(); 2167 EXPECT_EQ(readint32, 5); 2168 sptr<RemoteObject> readObj2 = parcel.ReadObject<RemoteObject>(); 2169 EXPECT_EQ(true, readObj2.GetRefPtr() == nullptr); 2170 readint32 = parcel.ReadInt32(); 2171 EXPECT_EQ(readint32, 5); 2172} 2173 2174HWTEST_F(UtilsParcelTest, test_RewindWrite_002, TestSize.Level0) 2175{ 2176 Parcel parcel(nullptr); 2177 parcel.WriteInt32(5); 2178 string strWrite = "test"; 2179 parcel.WriteString(strWrite); 2180 RemoteObject obj1; 2181 parcel.WriteRemoteObject(&obj1); 2182 parcel.WriteInt32(5); 2183 RemoteObject obj2; 2184 parcel.WriteRemoteObject(&obj2); 2185 size_t pos = parcel.GetWritePosition(); 2186 u16string str16Write = u"12345"; 2187 parcel.WriteString16(str16Write); 2188 2189 bool result = parcel.RewindWrite(pos); 2190 EXPECT_EQ(result, true); 2191 2192 int32_t readint32 = parcel.ReadInt32(); 2193 EXPECT_EQ(readint32, 5); 2194 string strRead = parcel.ReadString(); 2195 EXPECT_EQ(0, strcmp(strRead.c_str(), strWrite.c_str())); 2196 uint32_t readUint32 = parcel.ReadUint32(); 2197 EXPECT_EQ(readUint32, 0); 2198 string strRead2 = parcel.ReadString(); 2199 EXPECT_EQ(0, strRead2.compare(std::string())); 2200 sptr<RemoteObject> readObj1 = parcel.ReadObject<RemoteObject>(); 2201 EXPECT_EQ(true, readObj1.GetRefPtr() == nullptr); 2202 double readDouble = parcel.ReadDouble(); 2203 EXPECT_EQ(readDouble, 0); 2204} 2205 2206HWTEST_F(UtilsParcelTest, test_RewindWrite_003, TestSize.Level0) 2207{ 2208 Parcel parcel(nullptr); 2209 std::vector<int32_t> val{1, 2, 3, 4, 5}; 2210 EXPECT_EQ(val.size(), 5); 2211 bool result = parcel.WriteInt32Vector(val); 2212 EXPECT_EQ(result, true); 2213 size_t pos = parcel.GetWritePosition() - sizeof(int32_t); 2214 result = parcel.RewindWrite(pos); 2215 EXPECT_EQ(result, true); 2216 RemoteObject obj; 2217 parcel.WriteRemoteObject(&obj); 2218 2219 std::vector<int32_t> int32Read; 2220 result = parcel.ReadInt32Vector(&int32Read); 2221 EXPECT_EQ(result, false); 2222 EXPECT_EQ(int32Read.size(), 5); 2223 EXPECT_EQ(int32Read[0], 1); 2224 EXPECT_EQ(int32Read[1], 2); 2225 EXPECT_EQ(int32Read[2], 3); 2226 EXPECT_EQ(int32Read[3], 4); 2227 EXPECT_EQ(int32Read[4], 0); 2228} 2229 2230HWTEST_F(UtilsParcelTest, test_VectorDataPadding_001, TestSize.Level0) 2231{ 2232 Parcel parcel1(nullptr); 2233 std::vector<bool> val1(121, true); 2234 bool result = parcel1.WriteBoolVector(val1); 2235 EXPECT_EQ(result, true); 2236 2237 int32_t targetVal = 123; 2238 parcel1.WriteInt32(targetVal); 2239 2240 std::vector<bool> val2; 2241 result = parcel1.ReadBoolVector(&val2); 2242 int32_t target = parcel1.ReadInt32(); 2243 EXPECT_EQ(target, targetVal); 2244} 2245 2246HWTEST_F(UtilsParcelTest, test_VectorDataPadding_002, TestSize.Level0) 2247{ 2248 Parcel parcel1(nullptr); 2249 std::vector<bool> val1(15, true); 2250 bool result = parcel1.WriteBoolVector(val1); 2251 EXPECT_EQ(result, true); 2252 2253 std::vector<bool> val2(16, true); 2254 result = parcel1.WriteBoolVector(val2); 2255 EXPECT_EQ(result, true); 2256 2257 std::vector<bool> val3; 2258 result = parcel1.ReadBoolVector(&val3); 2259 for (int i = 0; i < val1.size(); i++) { 2260 EXPECT_EQ(val1[i], val3[i]); 2261 } 2262 2263 std::vector<bool> val4; 2264 result = parcel1.ReadBoolVector(&val4); 2265 for (int i = 0; i < val2.size(); i++) { 2266 EXPECT_EQ(val2[i], val4[i]); 2267 } 2268 parcel1.FlushBuffer(); 2269 2270 result = parcel1.WriteBoolVector(val2); 2271 EXPECT_EQ(result, true); 2272 result = parcel1.WriteBoolVector(val1); 2273 EXPECT_EQ(result, true); 2274 2275 std::vector<bool> val5; 2276 result = parcel1.ReadBoolVector(&val5); 2277 for (int i = 0; i < val2.size(); i++) { 2278 EXPECT_EQ(val2[i], val5[i]); 2279 } 2280 2281 std::vector<bool> val6; 2282 result = parcel1.ReadBoolVector(&val6); 2283 for (int i = 0; i < val1.size(); i++) { 2284 EXPECT_EQ(val1[i], val6[i]); 2285 } 2286} 2287 2288HWTEST_F(UtilsParcelTest, test_VectorDataPadding_003, TestSize.Level0) 2289{ 2290 Parcel parcel1(nullptr); 2291 std::vector<bool> val1(17, true); 2292 bool result = parcel1.WriteBoolVector(val1); 2293 EXPECT_EQ(result, true); 2294 2295 std::vector<int16_t> val2(18, 1); 2296 result = parcel1.WriteInt16Vector(val2); 2297 EXPECT_EQ(result, true); 2298 2299 std::vector<bool> val3; 2300 result = parcel1.ReadBoolVector(&val3); 2301 for (int i = 0; i < val1.size(); i++) { 2302 EXPECT_EQ(val1[i], val3[i]); 2303 } 2304 2305 std::vector<int16_t> val4; 2306 result = parcel1.ReadInt16Vector(&val4); 2307 for (int i = 0; i < val2.size(); i++) { 2308 EXPECT_EQ(val2[i], val4[i]); 2309 } 2310 parcel1.FlushBuffer(); 2311 2312 result = parcel1.WriteInt16Vector(val2); 2313 EXPECT_EQ(result, true); 2314 result = parcel1.WriteBoolVector(val1); 2315 EXPECT_EQ(result, true); 2316 2317 std::vector<int16_t> val5; 2318 result = parcel1.ReadInt16Vector(&val5); 2319 for (int i = 0; i < val2.size(); i++) { 2320 EXPECT_EQ(val2[i], val5[i]); 2321 } 2322 2323 std::vector<bool> val6; 2324 result = parcel1.ReadBoolVector(&val6); 2325 for (int i = 0; i < val1.size(); i++) { 2326 EXPECT_EQ(val1[i], val6[i]); 2327 } 2328} 2329 2330HWTEST_F(UtilsParcelTest, test_VectorDataPadding_004, TestSize.Level0) 2331{ 2332 Parcel parcel1(nullptr); 2333 std::vector<int16_t> val1(19, 1); 2334 bool result = parcel1.WriteInt16Vector(val1); 2335 EXPECT_EQ(result, true); 2336 2337 std::vector<int16_t> val2(20, 1); 2338 result = parcel1.WriteInt16Vector(val2); 2339 EXPECT_EQ(result, true); 2340 2341 std::vector<int16_t> val3; 2342 result = parcel1.ReadInt16Vector(&val3); 2343 for (int i = 0; i < val1.size(); i++) { 2344 EXPECT_EQ(val1[i], val3[i]); 2345 } 2346 2347 std::vector<int16_t> val4; 2348 result = parcel1.ReadInt16Vector(&val4); 2349 for (int i = 0; i < val2.size(); i++) { 2350 EXPECT_EQ(val2[i], val4[i]); 2351 } 2352 parcel1.FlushBuffer(); 2353 2354 result = parcel1.WriteInt16Vector(val2); 2355 EXPECT_EQ(result, true); 2356 result = parcel1.WriteInt16Vector(val1); 2357 EXPECT_EQ(result, true); 2358 2359 std::vector<int16_t> val5; 2360 result = parcel1.ReadInt16Vector(&val5); 2361 for (int i = 0; i < val2.size(); i++) { 2362 EXPECT_EQ(val2[i], val5[i]); 2363 } 2364 2365 std::vector<int16_t> val6; 2366 result = parcel1.ReadInt16Vector(&val6); 2367 for (int i = 0; i < val1.size(); i++) { 2368 EXPECT_EQ(val1[i], val6[i]); 2369 } 2370} 2371 2372#ifdef __aarch64__ 2373HWTEST_F(UtilsParcelTest, test_WriteStringDataLength_001, TestSize.Level0) 2374{ 2375 Parcel parcel1(nullptr); 2376 2377 std::string veryLongString(static_cast<size_t>(INT32_MAX) + 1, '#'); 2378 bool result = parcel1.WriteCString(veryLongString.c_str()); 2379 EXPECT_EQ(result, false); 2380 parcel1.FlushBuffer(); 2381 2382 result = parcel1.WriteString(veryLongString); 2383 EXPECT_EQ(result, false); 2384 parcel1.FlushBuffer(); 2385 2386 std::u16string veryLongStringU16(static_cast<size_t>(INT32_MAX) / 2, '#'); 2387 result = parcel1.WriteString16(veryLongStringU16); 2388 EXPECT_EQ(result, false); 2389 parcel1.FlushBuffer(); 2390 2391 result = parcel1.WriteString16WithLength(veryLongStringU16.c_str(), static_cast<size_t>(INT32_MAX) / 2); 2392 EXPECT_EQ(result, false); 2393 parcel1.FlushBuffer(); 2394 2395 result = parcel1.WriteString8WithLength(veryLongString.c_str(), static_cast<size_t>(INT32_MAX) + 1); 2396 EXPECT_EQ(result, false); 2397 parcel1.FlushBuffer(); 2398 2399 result = parcel1.WriteCString(veryLongString.substr(0, DEFAULT_CPACITY - 1).c_str()); 2400 EXPECT_EQ(result, true); 2401 parcel1.FlushBuffer(); 2402 2403 result = parcel1.WriteString(veryLongString.substr(0, DEFAULT_CPACITY - 5)); 2404 EXPECT_EQ(result, true); 2405 parcel1.FlushBuffer(); 2406 2407 result = parcel1.WriteString16(veryLongStringU16.substr(0, (DEFAULT_CPACITY - 4) / 2 - 1)); 2408 EXPECT_EQ(result, true); 2409 parcel1.FlushBuffer(); 2410 2411 result = parcel1.WriteString16WithLength(veryLongStringU16.c_str(), (DEFAULT_CPACITY - 4) / 2 - 1); 2412 EXPECT_EQ(result, true); 2413 parcel1.FlushBuffer(); 2414 2415 result = parcel1.WriteString8WithLength(veryLongString.c_str(), DEFAULT_CPACITY - 5); 2416 EXPECT_EQ(result, true); 2417 parcel1.FlushBuffer(); 2418} 2419#endif 2420} // namespace 2421} // namespace OHOS 2422