1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/pickle.h" 6 7 #include <limits.h> 8 #include <stddef.h> 9 #include <stdint.h> 10 11 #include <memory> 12 #include <string> 13 14 #include "base/macros.h" 15 #include "base/strings/string16.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 19 namespace base { 20 21 namespace { 22 23 const bool testbool1 = false; 24 const bool testbool2 = true; 25 const int testint = 2093847192; 26 const long testlong = 1093847192; 27 const uint16_t testuint16 = 32123; 28 const uint32_t testuint32 = 1593847192; 29 const int64_t testint64 = -0x7E8CA9253104BDFCLL; 30 const uint64_t testuint64 = 0xCE8CA9253104BDF7ULL; 31 const float testfloat = 3.1415926935f; 32 const double testdouble = 2.71828182845904523; 33 const std::string teststring("Hello world"); // note non-aligned string length 34 const std::wstring testwstring(L"Hello, world"); 35 const string16 teststring16(ASCIIToUTF16("Hello, world")); 36 const char testrawstring[] = "Hello new world"; // Test raw string writing 37 // Test raw char16 writing, assumes UTF16 encoding is ANSI for alpha chars. 38 const char16 testrawstring16[] = {'A', 'l', 'o', 'h', 'a', 0}; 39 const char testdata[] = "AAA\0BBB\0"; 40 const int testdatalen = arraysize(testdata) - 1; 41 42 // checks that the results can be read correctly from the Pickle 43 void VerifyResult(const Pickle& pickle) { 44 PickleIterator iter(pickle); 45 46 bool outbool; 47 EXPECT_TRUE(iter.ReadBool(&outbool)); 48 EXPECT_FALSE(outbool); 49 EXPECT_TRUE(iter.ReadBool(&outbool)); 50 EXPECT_TRUE(outbool); 51 52 int outint; 53 EXPECT_TRUE(iter.ReadInt(&outint)); 54 EXPECT_EQ(testint, outint); 55 56 long outlong; 57 EXPECT_TRUE(iter.ReadLong(&outlong)); 58 EXPECT_EQ(testlong, outlong); 59 60 uint16_t outuint16; 61 EXPECT_TRUE(iter.ReadUInt16(&outuint16)); 62 EXPECT_EQ(testuint16, outuint16); 63 64 uint32_t outuint32; 65 EXPECT_TRUE(iter.ReadUInt32(&outuint32)); 66 EXPECT_EQ(testuint32, outuint32); 67 68 int64_t outint64; 69 EXPECT_TRUE(iter.ReadInt64(&outint64)); 70 EXPECT_EQ(testint64, outint64); 71 72 uint64_t outuint64; 73 EXPECT_TRUE(iter.ReadUInt64(&outuint64)); 74 EXPECT_EQ(testuint64, outuint64); 75 76 float outfloat; 77 EXPECT_TRUE(iter.ReadFloat(&outfloat)); 78 EXPECT_EQ(testfloat, outfloat); 79 80 double outdouble; 81 EXPECT_TRUE(iter.ReadDouble(&outdouble)); 82 EXPECT_EQ(testdouble, outdouble); 83 84 std::string outstring; 85 EXPECT_TRUE(iter.ReadString(&outstring)); 86 EXPECT_EQ(teststring, outstring); 87 88 string16 outstring16; 89 EXPECT_TRUE(iter.ReadString16(&outstring16)); 90 EXPECT_EQ(teststring16, outstring16); 91 92 StringPiece outstringpiece; 93 EXPECT_TRUE(iter.ReadStringPiece(&outstringpiece)); 94 EXPECT_EQ(testrawstring, outstringpiece); 95 96 StringPiece16 outstringpiece16; 97 EXPECT_TRUE(iter.ReadStringPiece16(&outstringpiece16)); 98 EXPECT_EQ(testrawstring16, outstringpiece16); 99 100 const char* outdata; 101 int outdatalen; 102 EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen)); 103 EXPECT_EQ(testdatalen, outdatalen); 104 EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0); 105 106 // reads past the end should fail 107 EXPECT_FALSE(iter.ReadInt(&outint)); 108 } 109 110 } // namespace 111 112 TEST(PickleTest, EncodeDecode) { 113 Pickle pickle; 114 115 EXPECT_TRUE(pickle.WriteBool(testbool1)); 116 EXPECT_TRUE(pickle.WriteBool(testbool2)); 117 EXPECT_TRUE(pickle.WriteInt(testint)); 118 EXPECT_TRUE(pickle.WriteLong(testlong)); 119 EXPECT_TRUE(pickle.WriteUInt16(testuint16)); 120 EXPECT_TRUE(pickle.WriteUInt32(testuint32)); 121 EXPECT_TRUE(pickle.WriteInt64(testint64)); 122 EXPECT_TRUE(pickle.WriteUInt64(testuint64)); 123 EXPECT_TRUE(pickle.WriteFloat(testfloat)); 124 EXPECT_TRUE(pickle.WriteDouble(testdouble)); 125 EXPECT_TRUE(pickle.WriteString(teststring)); 126 EXPECT_TRUE(pickle.WriteString16(teststring16)); 127 EXPECT_TRUE(pickle.WriteString(testrawstring)); 128 EXPECT_TRUE(pickle.WriteString16(testrawstring16)); 129 EXPECT_TRUE(pickle.WriteData(testdata, testdatalen)); 130 VerifyResult(pickle); 131 132 // test copy constructor 133 Pickle pickle2(pickle); 134 VerifyResult(pickle2); 135 136 // test operator= 137 Pickle pickle3; 138 pickle3 = pickle; 139 VerifyResult(pickle3); 140 } 141 142 // Tests that reading/writing a long works correctly when the source process 143 // is 64-bit. We rely on having both 32- and 64-bit trybots to validate both 144 // arms of the conditional in this test. 145 TEST(PickleTest, LongFrom64Bit) { 146 Pickle pickle; 147 // Under the hood long is always written as a 64-bit value, so simulate a 148 // 64-bit long even on 32-bit architectures by explicitly writing an int64_t. 149 EXPECT_TRUE(pickle.WriteInt64(testint64)); 150 151 PickleIterator iter(pickle); 152 long outlong; 153 if (sizeof(long) < sizeof(int64_t)) { 154 // ReadLong() should return false when the original written value can't be 155 // represented as a long. 156 #if GTEST_HAS_DEATH_TEST 157 EXPECT_DEATH(ignore_result(iter.ReadLong(&outlong)), ""); 158 #endif 159 } else { 160 EXPECT_TRUE(iter.ReadLong(&outlong)); 161 EXPECT_EQ(testint64, outlong); 162 } 163 } 164 165 // Tests that we can handle really small buffers. 166 TEST(PickleTest, SmallBuffer) { 167 std::unique_ptr<char[]> buffer(new char[1]); 168 169 // We should not touch the buffer. 170 Pickle pickle(buffer.get(), 1); 171 172 PickleIterator iter(pickle); 173 int data; 174 EXPECT_FALSE(iter.ReadInt(&data)); 175 } 176 177 // Tests that we can handle improper headers. 178 TEST(PickleTest, BigSize) { 179 int buffer[] = { 0x56035200, 25, 40, 50 }; 180 181 Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 182 183 PickleIterator iter(pickle); 184 int data; 185 EXPECT_FALSE(iter.ReadInt(&data)); 186 } 187 188 TEST(PickleTest, UnalignedSize) { 189 int buffer[] = { 10, 25, 40, 50 }; 190 191 Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 192 193 PickleIterator iter(pickle); 194 int data; 195 EXPECT_FALSE(iter.ReadInt(&data)); 196 } 197 198 TEST(PickleTest, ZeroLenStr) { 199 Pickle pickle; 200 EXPECT_TRUE(pickle.WriteString(std::string())); 201 202 PickleIterator iter(pickle); 203 std::string outstr; 204 EXPECT_TRUE(iter.ReadString(&outstr)); 205 EXPECT_EQ("", outstr); 206 } 207 208 TEST(PickleTest, ZeroLenStr16) { 209 Pickle pickle; 210 EXPECT_TRUE(pickle.WriteString16(string16())); 211 212 PickleIterator iter(pickle); 213 std::string outstr; 214 EXPECT_TRUE(iter.ReadString(&outstr)); 215 EXPECT_EQ("", outstr); 216 } 217 218 TEST(PickleTest, BadLenStr) { 219 Pickle pickle; 220 EXPECT_TRUE(pickle.WriteInt(-2)); 221 222 PickleIterator iter(pickle); 223 std::string outstr; 224 EXPECT_FALSE(iter.ReadString(&outstr)); 225 } 226 227 TEST(PickleTest, BadLenStr16) { 228 Pickle pickle; 229 EXPECT_TRUE(pickle.WriteInt(-1)); 230 231 PickleIterator iter(pickle); 232 string16 outstr; 233 EXPECT_FALSE(iter.ReadString16(&outstr)); 234 } 235 236 TEST(PickleTest, PeekNext) { 237 struct CustomHeader : base::Pickle::Header { 238 int cookies[10]; 239 }; 240 241 Pickle pickle(sizeof(CustomHeader)); 242 243 EXPECT_TRUE(pickle.WriteString("Goooooooooooogle")); 244 245 const char* pickle_data = static_cast<const char*>(pickle.data()); 246 247 size_t pickle_size; 248 249 // Data range doesn't contain header 250 EXPECT_FALSE(Pickle::PeekNext( 251 sizeof(CustomHeader), 252 pickle_data, 253 pickle_data + sizeof(CustomHeader) - 1, 254 &pickle_size)); 255 256 // Data range contains header 257 EXPECT_TRUE(Pickle::PeekNext( 258 sizeof(CustomHeader), 259 pickle_data, 260 pickle_data + sizeof(CustomHeader), 261 &pickle_size)); 262 EXPECT_EQ(pickle_size, pickle.size()); 263 264 // Data range contains header and some other data 265 EXPECT_TRUE(Pickle::PeekNext( 266 sizeof(CustomHeader), 267 pickle_data, 268 pickle_data + sizeof(CustomHeader) + 1, 269 &pickle_size)); 270 EXPECT_EQ(pickle_size, pickle.size()); 271 272 // Data range contains full pickle 273 EXPECT_TRUE(Pickle::PeekNext( 274 sizeof(CustomHeader), 275 pickle_data, 276 pickle_data + pickle.size(), 277 &pickle_size)); 278 EXPECT_EQ(pickle_size, pickle.size()); 279 } 280 281 TEST(PickleTest, PeekNextOverflow) { 282 struct CustomHeader : base::Pickle::Header { 283 int cookies[10]; 284 }; 285 286 CustomHeader header; 287 288 // Check if we can wrap around at all 289 if (sizeof(size_t) > sizeof(header.payload_size)) 290 return; 291 292 const char* pickle_data = reinterpret_cast<const char*>(&header); 293 294 size_t pickle_size; 295 296 // Wrapping around is detected and reported as maximum size_t value 297 header.payload_size = static_cast<uint32_t>( 298 1 - static_cast<int32_t>(sizeof(CustomHeader))); 299 EXPECT_TRUE(Pickle::PeekNext( 300 sizeof(CustomHeader), 301 pickle_data, 302 pickle_data + sizeof(CustomHeader), 303 &pickle_size)); 304 EXPECT_EQ(pickle_size, std::numeric_limits<size_t>::max()); 305 306 // Ridiculous pickle sizes are fine (callers are supposed to 307 // verify them) 308 header.payload_size = 309 std::numeric_limits<uint32_t>::max() / 2 - sizeof(CustomHeader); 310 EXPECT_TRUE(Pickle::PeekNext( 311 sizeof(CustomHeader), 312 pickle_data, 313 pickle_data + sizeof(CustomHeader), 314 &pickle_size)); 315 EXPECT_EQ(pickle_size, std::numeric_limits<uint32_t>::max() / 2); 316 } 317 318 TEST(PickleTest, FindNext) { 319 Pickle pickle; 320 EXPECT_TRUE(pickle.WriteInt(1)); 321 EXPECT_TRUE(pickle.WriteString("Domo")); 322 323 const char* start = reinterpret_cast<const char*>(pickle.data()); 324 const char* end = start + pickle.size(); 325 326 EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end)); 327 EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1)); 328 EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1)); 329 } 330 331 TEST(PickleTest, FindNextWithIncompleteHeader) { 332 size_t header_size = sizeof(Pickle::Header); 333 std::unique_ptr<char[]> buffer(new char[header_size - 1]); 334 memset(buffer.get(), 0x1, header_size - 1); 335 336 const char* start = buffer.get(); 337 const char* end = start + header_size - 1; 338 339 EXPECT_TRUE(NULL == Pickle::FindNext(header_size, start, end)); 340 } 341 342 #if defined(COMPILER_MSVC) 343 #pragma warning(push) 344 #pragma warning(disable: 4146) 345 #endif 346 TEST(PickleTest, FindNextOverflow) { 347 size_t header_size = sizeof(Pickle::Header); 348 size_t header_size2 = 2 * header_size; 349 size_t payload_received = 100; 350 std::unique_ptr<char[]> buffer(new char[header_size2 + payload_received]); 351 const char* start = buffer.get(); 352 Pickle::Header* header = reinterpret_cast<Pickle::Header*>(buffer.get()); 353 const char* end = start + header_size2 + payload_received; 354 // It is impossible to construct an overflow test otherwise. 355 if (sizeof(size_t) > sizeof(header->payload_size) || 356 sizeof(uintptr_t) > sizeof(header->payload_size)) 357 return; 358 359 header->payload_size = -(reinterpret_cast<uintptr_t>(start) + header_size2); 360 EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 361 362 header->payload_size = -header_size2; 363 EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 364 365 header->payload_size = 0; 366 end = start + header_size; 367 EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 368 } 369 #if defined(COMPILER_MSVC) 370 #pragma warning(pop) 371 #endif 372 373 TEST(PickleTest, GetReadPointerAndAdvance) { 374 Pickle pickle; 375 376 PickleIterator iter(pickle); 377 EXPECT_FALSE(iter.GetReadPointerAndAdvance(1)); 378 379 EXPECT_TRUE(pickle.WriteInt(1)); 380 EXPECT_TRUE(pickle.WriteInt(2)); 381 int bytes = sizeof(int) * 2; 382 383 EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(0)); 384 EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(1)); 385 EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(-1)); 386 EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes)); 387 EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes + 1)); 388 EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MAX)); 389 EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MIN)); 390 } 391 392 TEST(PickleTest, Resize) { 393 size_t unit = Pickle::kPayloadUnit; 394 std::unique_ptr<char[]> data(new char[unit]); 395 char* data_ptr = data.get(); 396 for (size_t i = 0; i < unit; i++) 397 data_ptr[i] = 'G'; 398 399 // construct a message that will be exactly the size of one payload unit, 400 // note that any data will have a 4-byte header indicating the size 401 const size_t payload_size_after_header = unit - sizeof(uint32_t); 402 Pickle pickle; 403 pickle.WriteData( 404 data_ptr, static_cast<int>(payload_size_after_header - sizeof(uint32_t))); 405 size_t cur_payload = payload_size_after_header; 406 407 // note: we assume 'unit' is a power of 2 408 EXPECT_EQ(unit, pickle.capacity_after_header()); 409 EXPECT_EQ(pickle.payload_size(), payload_size_after_header); 410 411 // fill out a full page (noting data header) 412 pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32_t))); 413 cur_payload += unit; 414 EXPECT_EQ(unit * 2, pickle.capacity_after_header()); 415 EXPECT_EQ(cur_payload, pickle.payload_size()); 416 417 // one more byte should double the capacity 418 pickle.WriteData(data_ptr, 1); 419 cur_payload += 8; 420 EXPECT_EQ(unit * 4, pickle.capacity_after_header()); 421 EXPECT_EQ(cur_payload, pickle.payload_size()); 422 } 423 424 namespace { 425 426 struct CustomHeader : Pickle::Header { 427 int blah; 428 }; 429 430 } // namespace 431 432 TEST(PickleTest, HeaderPadding) { 433 const uint32_t kMagic = 0x12345678; 434 435 Pickle pickle(sizeof(CustomHeader)); 436 pickle.WriteInt(kMagic); 437 438 // this should not overwrite the 'int' payload 439 pickle.headerT<CustomHeader>()->blah = 10; 440 441 PickleIterator iter(pickle); 442 int result; 443 ASSERT_TRUE(iter.ReadInt(&result)); 444 445 EXPECT_EQ(static_cast<uint32_t>(result), kMagic); 446 } 447 448 TEST(PickleTest, EqualsOperator) { 449 Pickle source; 450 source.WriteInt(1); 451 452 Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()), 453 source.size()); 454 Pickle copy; 455 copy = copy_refs_source_buffer; 456 ASSERT_EQ(source.size(), copy.size()); 457 } 458 459 TEST(PickleTest, EvilLengths) { 460 Pickle source; 461 std::string str(100000, 'A'); 462 EXPECT_TRUE(source.WriteData(str.c_str(), 100000)); 463 // ReadString16 used to have its read buffer length calculation wrong leading 464 // to out-of-bounds reading. 465 PickleIterator iter(source); 466 string16 str16; 467 EXPECT_FALSE(iter.ReadString16(&str16)); 468 469 // And check we didn't break ReadString16. 470 str16 = (wchar_t) 'A'; 471 Pickle str16_pickle; 472 EXPECT_TRUE(str16_pickle.WriteString16(str16)); 473 iter = PickleIterator(str16_pickle); 474 EXPECT_TRUE(iter.ReadString16(&str16)); 475 EXPECT_EQ(1U, str16.length()); 476 477 // Check we don't fail in a length check with invalid String16 size. 478 // (1<<31) * sizeof(char16) == 0, so this is particularly evil. 479 Pickle bad_len; 480 EXPECT_TRUE(bad_len.WriteInt(1 << 31)); 481 iter = PickleIterator(bad_len); 482 EXPECT_FALSE(iter.ReadString16(&str16)); 483 } 484 485 // Check we can write zero bytes of data and 'data' can be NULL. 486 TEST(PickleTest, ZeroLength) { 487 Pickle pickle; 488 EXPECT_TRUE(pickle.WriteData(NULL, 0)); 489 490 PickleIterator iter(pickle); 491 const char* outdata; 492 int outdatalen; 493 EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen)); 494 EXPECT_EQ(0, outdatalen); 495 // We can't assert that outdata is NULL. 496 } 497 498 // Check that ReadBytes works properly with an iterator initialized to NULL. 499 TEST(PickleTest, ReadBytes) { 500 Pickle pickle; 501 int data = 0x7abcd; 502 EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data))); 503 504 PickleIterator iter(pickle); 505 const char* outdata_char = NULL; 506 EXPECT_TRUE(iter.ReadBytes(&outdata_char, sizeof(data))); 507 508 int outdata; 509 memcpy(&outdata, outdata_char, sizeof(outdata)); 510 EXPECT_EQ(data, outdata); 511 } 512 513 // Checks that when a pickle is deep-copied, the result is not larger than 514 // needed. 515 TEST(PickleTest, DeepCopyResize) { 516 Pickle pickle; 517 while (pickle.capacity_after_header() != pickle.payload_size()) 518 pickle.WriteBool(true); 519 520 // Make a deep copy. 521 Pickle pickle2(pickle); 522 523 // Check that there isn't any extraneous capacity. 524 EXPECT_EQ(pickle.capacity_after_header(), pickle2.capacity_after_header()); 525 } 526 527 namespace { 528 529 // Publicly exposes the ClaimBytes interface for testing. 530 class TestingPickle : public Pickle { 531 public: 532 TestingPickle() {} 533 534 void* ClaimBytes(size_t num_bytes) { return Pickle::ClaimBytes(num_bytes); } 535 }; 536 537 } // namespace 538 539 // Checks that claimed bytes are zero-initialized. 540 TEST(PickleTest, ClaimBytesInitialization) { 541 static const int kChunkSize = 64; 542 TestingPickle pickle; 543 const char* bytes = static_cast<const char*>(pickle.ClaimBytes(kChunkSize)); 544 for (size_t i = 0; i < kChunkSize; ++i) { 545 EXPECT_EQ(0, bytes[i]); 546 } 547 } 548 549 // Checks that ClaimBytes properly advances the write offset. 550 TEST(PickleTest, ClaimBytes) { 551 std::string data("Hello, world!"); 552 553 TestingPickle pickle; 554 pickle.WriteUInt32(data.size()); 555 void* bytes = pickle.ClaimBytes(data.size()); 556 pickle.WriteInt(42); 557 memcpy(bytes, data.data(), data.size()); 558 559 PickleIterator iter(pickle); 560 uint32_t out_data_length; 561 EXPECT_TRUE(iter.ReadUInt32(&out_data_length)); 562 EXPECT_EQ(data.size(), out_data_length); 563 564 const char* out_data = nullptr; 565 EXPECT_TRUE(iter.ReadBytes(&out_data, out_data_length)); 566 EXPECT_EQ(data, std::string(out_data, out_data_length)); 567 568 int out_value; 569 EXPECT_TRUE(iter.ReadInt(&out_value)); 570 EXPECT_EQ(42, out_value); 571 } 572 573 // Checks that PickleSizer and Pickle agree on the size of things. 574 TEST(PickleTest, PickleSizer) { 575 { 576 TestingPickle pickle; 577 base::PickleSizer sizer; 578 pickle.WriteBool(true); 579 sizer.AddBool(); 580 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 581 } 582 { 583 TestingPickle pickle; 584 base::PickleSizer sizer; 585 pickle.WriteInt(42); 586 sizer.AddInt(); 587 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 588 } 589 { 590 TestingPickle pickle; 591 base::PickleSizer sizer; 592 pickle.WriteLong(42); 593 sizer.AddLong(); 594 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 595 } 596 { 597 TestingPickle pickle; 598 base::PickleSizer sizer; 599 pickle.WriteUInt16(42); 600 sizer.AddUInt16(); 601 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 602 } 603 { 604 TestingPickle pickle; 605 base::PickleSizer sizer; 606 pickle.WriteUInt32(42); 607 sizer.AddUInt32(); 608 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 609 } 610 { 611 TestingPickle pickle; 612 base::PickleSizer sizer; 613 pickle.WriteInt64(42); 614 sizer.AddInt64(); 615 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 616 } 617 { 618 TestingPickle pickle; 619 base::PickleSizer sizer; 620 pickle.WriteUInt64(42); 621 sizer.AddUInt64(); 622 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 623 } 624 { 625 TestingPickle pickle; 626 base::PickleSizer sizer; 627 pickle.WriteFloat(42.0f); 628 sizer.AddFloat(); 629 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 630 } 631 { 632 TestingPickle pickle; 633 base::PickleSizer sizer; 634 pickle.WriteDouble(42.0); 635 sizer.AddDouble(); 636 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 637 } 638 { 639 TestingPickle pickle; 640 base::PickleSizer sizer; 641 pickle.WriteString(teststring); 642 sizer.AddString(teststring); 643 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 644 } 645 { 646 TestingPickle pickle; 647 base::PickleSizer sizer; 648 pickle.WriteString16(teststring16); 649 sizer.AddString16(teststring16); 650 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 651 } 652 { 653 TestingPickle pickle; 654 base::PickleSizer sizer; 655 pickle.WriteData(testdata, testdatalen); 656 sizer.AddData(testdatalen); 657 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 658 } 659 { 660 TestingPickle pickle; 661 base::PickleSizer sizer; 662 pickle.WriteBytes(testdata, testdatalen); 663 sizer.AddBytes(testdatalen); 664 EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 665 } 666 } 667 668 } // namespace base 669
