1b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Use of this source code is governed by a BSD-style license that can be 3b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// found in the LICENSE file. 4b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 594ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez#include "base/pickle.h" 694ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez 70d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko#include <limits.h> 80d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko#include <stddef.h> 90d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko#include <stdint.h> 100d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 1194ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez#include <memory> 12b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#include <string> 13b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 140d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko#include "base/macros.h" 15b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#include "base/strings/string16.h" 16b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#include "base/strings/utf_string_conversions.h" 17b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#include "testing/gtest/include/gtest/gtest.h" 18b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 19b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratnamespace base { 20b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 21b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratnamespace { 22b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 23b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst bool testbool1 = false; 24b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst bool testbool2 = true; 25b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst int testint = 2093847192; 26b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst long testlong = 1093847192; 270d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkoconst uint16_t testuint16 = 32123; 280d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkoconst uint32_t testuint32 = 1593847192; 290d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkoconst int64_t testint64 = -0x7E8CA9253104BDFCLL; 300d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkoconst uint64_t testuint64 = 0xCE8CA9253104BDF7ULL; 31b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst float testfloat = 3.1415926935f; 32b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst double testdouble = 2.71828182845904523; 33b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst std::string teststring("Hello world"); // note non-aligned string length 34b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst std::wstring testwstring(L"Hello, world"); 35b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst string16 teststring16(ASCIIToUTF16("Hello, world")); 36b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst char testrawstring[] = "Hello new world"; // Test raw string writing 37b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Test raw char16 writing, assumes UTF16 encoding is ANSI for alpha chars. 38b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst char16 testrawstring16[] = {'A', 'l', 'o', 'h', 'a', 0}; 39b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst char testdata[] = "AAA\0BBB\0"; 40b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratconst int testdatalen = arraysize(testdata) - 1; 41b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 42b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// checks that the results can be read correctly from the Pickle 43b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratvoid VerifyResult(const Pickle& pickle) { 44b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 45b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 46b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat bool outbool; 47b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadBool(&outbool)); 48b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(outbool); 49b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadBool(&outbool)); 50b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(outbool); 51b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 52b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int outint; 53b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadInt(&outint)); 54b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testint, outint); 55b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 56b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat long outlong; 57b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadLong(&outlong)); 58b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testlong, outlong); 59b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 600d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko uint16_t outuint16; 61b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadUInt16(&outuint16)); 62b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testuint16, outuint16); 63b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 640d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko uint32_t outuint32; 65b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadUInt32(&outuint32)); 66b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testuint32, outuint32); 67b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 680d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko int64_t outint64; 69b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadInt64(&outint64)); 70b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testint64, outint64); 71b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 720d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko uint64_t outuint64; 73b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadUInt64(&outuint64)); 74b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testuint64, outuint64); 75b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 76b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat float outfloat; 77b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadFloat(&outfloat)); 78b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testfloat, outfloat); 79b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 80b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat double outdouble; 81b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadDouble(&outdouble)); 82b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testdouble, outdouble); 83b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 84b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat std::string outstring; 85b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadString(&outstring)); 86b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(teststring, outstring); 87b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 88b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat string16 outstring16; 89b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadString16(&outstring16)); 90b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(teststring16, outstring16); 91b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 92b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat StringPiece outstringpiece; 93b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadStringPiece(&outstringpiece)); 94b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testrawstring, outstringpiece); 95b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 96b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat StringPiece16 outstringpiece16; 97b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadStringPiece16(&outstringpiece16)); 98b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testrawstring16, outstringpiece16); 99b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 100b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* outdata; 101b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int outdatalen; 102b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen)); 103b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(testdatalen, outdatalen); 104b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0); 105b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 106b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // reads past the end should fail 107b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadInt(&outint)); 108b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 109b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 110b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} // namespace 111b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 112b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, EncodeDecode) { 113b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 114b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 115b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteBool(testbool1)); 116b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteBool(testbool2)); 117b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(testint)); 11845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_TRUE(pickle.WriteLong(testlong)); 119b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteUInt16(testuint16)); 120b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteUInt32(testuint32)); 121b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt64(testint64)); 122b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteUInt64(testuint64)); 123b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteFloat(testfloat)); 124b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteDouble(testdouble)); 125b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString(teststring)); 126b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString16(teststring16)); 127b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString(testrawstring)); 128b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString16(testrawstring16)); 129b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteData(testdata, testdatalen)); 130b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat VerifyResult(pickle); 131b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 132b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // test copy constructor 133b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle2(pickle); 134b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat VerifyResult(pickle2); 135b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 136b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // test operator= 137b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle3; 138b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat pickle3 = pickle; 139b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat VerifyResult(pickle3); 140b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 141b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 14245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko// Tests that reading/writing a long works correctly when the source process 143b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// is 64-bit. We rely on having both 32- and 64-bit trybots to validate both 144b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// arms of the conditional in this test. 14545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex VakulenkoTEST(PickleTest, LongFrom64Bit) { 146b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 14745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko // Under the hood long is always written as a 64-bit value, so simulate a 14845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko // 64-bit long even on 32-bit architectures by explicitly writing an int64_t. 14945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_TRUE(pickle.WriteInt64(testint64)); 150b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 151b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 15245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko long outlong; 15345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko if (sizeof(long) < sizeof(int64_t)) { 15445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko // ReadLong() should return false when the original written value can't be 15545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko // represented as a long. 15645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko#if GTEST_HAS_DEATH_TEST 15745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_DEATH(ignore_result(iter.ReadLong(&outlong)), ""); 15845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko#endif 159b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat } else { 16045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_TRUE(iter.ReadLong(&outlong)); 16145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(testint64, outlong); 162b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat } 163b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 164b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 165b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Tests that we can handle really small buffers. 166b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, SmallBuffer) { 16794ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez std::unique_ptr<char[]> buffer(new char[1]); 168b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 169b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // We should not touch the buffer. 170b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle(buffer.get(), 1); 171b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 172b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 173b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int data; 174b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadInt(&data)); 175b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 176b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 177b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Tests that we can handle improper headers. 178b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, BigSize) { 179b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int buffer[] = { 0x56035200, 25, 40, 50 }; 180b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 181b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 182b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 183b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 184b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int data; 185b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadInt(&data)); 186b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 187b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 188b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, UnalignedSize) { 189b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int buffer[] = { 10, 25, 40, 50 }; 190b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 191b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 192b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 193b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 194b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int data; 195b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadInt(&data)); 196b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 197b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 198b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, ZeroLenStr) { 199b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 200b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString(std::string())); 201b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 202b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 203b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat std::string outstr; 204b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadString(&outstr)); 205b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ("", outstr); 206b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 207b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 208b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, ZeroLenStr16) { 209b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 210b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString16(string16())); 211b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 212b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 213b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat std::string outstr; 214b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadString(&outstr)); 215b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ("", outstr); 216b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 217b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 218b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, BadLenStr) { 219b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 220b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(-2)); 221b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 222b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 223b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat std::string outstr; 224b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadString(&outstr)); 225b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 226b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 227b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, BadLenStr16) { 228b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 229b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(-1)); 230b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 231b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 232b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat string16 outstr; 233b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadString16(&outstr)); 234b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 235b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 2360d205d712abd16eeed2f5d5b1052a367d23a223fAlex VakulenkoTEST(PickleTest, PeekNext) { 2370d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko struct CustomHeader : base::Pickle::Header { 2380d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko int cookies[10]; 2390d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko }; 2400d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2410d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko Pickle pickle(sizeof(CustomHeader)); 2420d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2430d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(pickle.WriteString("Goooooooooooogle")); 2440d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2450d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const char* pickle_data = static_cast<const char*>(pickle.data()); 2460d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2470d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko size_t pickle_size; 2480d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2490d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Data range doesn't contain header 2500d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_FALSE(Pickle::PeekNext( 2510d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 2520d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 2530d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + sizeof(CustomHeader) - 1, 2540d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 2550d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2560d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Data range contains header 2570d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(Pickle::PeekNext( 2580d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 2590d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 2600d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + sizeof(CustomHeader), 2610d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 2620d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle_size, pickle.size()); 2630d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2640d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Data range contains header and some other data 2650d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(Pickle::PeekNext( 2660d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 2670d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 2680d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + sizeof(CustomHeader) + 1, 2690d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 2700d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle_size, pickle.size()); 2710d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2720d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Data range contains full pickle 2730d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(Pickle::PeekNext( 2740d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 2750d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 2760d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + pickle.size(), 2770d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 2780d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle_size, pickle.size()); 2790d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} 2800d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2810d205d712abd16eeed2f5d5b1052a367d23a223fAlex VakulenkoTEST(PickleTest, PeekNextOverflow) { 2820d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko struct CustomHeader : base::Pickle::Header { 2830d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko int cookies[10]; 2840d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko }; 2850d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2860d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko CustomHeader header; 2870d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2880d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Check if we can wrap around at all 2890d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko if (sizeof(size_t) > sizeof(header.payload_size)) 2900d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko return; 2910d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2920d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const char* pickle_data = reinterpret_cast<const char*>(&header); 2930d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2940d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko size_t pickle_size; 2950d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 2960d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Wrapping around is detected and reported as maximum size_t value 2970d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko header.payload_size = static_cast<uint32_t>( 2980d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 1 - static_cast<int32_t>(sizeof(CustomHeader))); 2990d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(Pickle::PeekNext( 3000d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 3010d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 3020d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + sizeof(CustomHeader), 3030d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 3040d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle_size, std::numeric_limits<size_t>::max()); 3050d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 3060d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Ridiculous pickle sizes are fine (callers are supposed to 3070d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // verify them) 3080d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko header.payload_size = 3090d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko std::numeric_limits<uint32_t>::max() / 2 - sizeof(CustomHeader); 3100d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(Pickle::PeekNext( 3110d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko sizeof(CustomHeader), 3120d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data, 3130d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle_data + sizeof(CustomHeader), 3140d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko &pickle_size)); 3150d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle_size, std::numeric_limits<uint32_t>::max() / 2); 3160d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} 3170d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 318b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, FindNext) { 319b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 320b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(1)); 321b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteString("Domo")); 322b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 323b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* start = reinterpret_cast<const char*>(pickle.data()); 324b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* end = start + pickle.size(); 325b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 326b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end)); 327b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1)); 328b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1)); 329b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 330b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 331b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, FindNextWithIncompleteHeader) { 332b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t header_size = sizeof(Pickle::Header); 33394ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez std::unique_ptr<char[]> buffer(new char[header_size - 1]); 334b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat memset(buffer.get(), 0x1, header_size - 1); 335b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 336b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* start = buffer.get(); 337b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* end = start + header_size - 1; 338b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 339b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(NULL == Pickle::FindNext(header_size, start, end)); 340b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 341b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 342b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#if defined(COMPILER_MSVC) 343b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#pragma warning(push) 344b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#pragma warning(disable: 4146) 345b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#endif 346b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, FindNextOverflow) { 347b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t header_size = sizeof(Pickle::Header); 348b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t header_size2 = 2 * header_size; 349b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t payload_received = 100; 35094ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez std::unique_ptr<char[]> buffer(new char[header_size2 + payload_received]); 351b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* start = buffer.get(); 352b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle::Header* header = reinterpret_cast<Pickle::Header*>(buffer.get()); 353b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* end = start + header_size2 + payload_received; 354b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // It is impossible to construct an overflow test otherwise. 355b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat if (sizeof(size_t) > sizeof(header->payload_size) || 356b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat sizeof(uintptr_t) > sizeof(header->payload_size)) 357b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat return; 358b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 359b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat header->payload_size = -(reinterpret_cast<uintptr_t>(start) + header_size2); 360b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 361b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 362b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat header->payload_size = -header_size2; 363b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 364b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 365b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat header->payload_size = 0; 366b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat end = start + header_size; 367b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end)); 368b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 369b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#if defined(COMPILER_MSVC) 370b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#pragma warning(pop) 371b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat#endif 372b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 373b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, GetReadPointerAndAdvance) { 374b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 375b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 376b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 377b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.GetReadPointerAndAdvance(1)); 378b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 379b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(1)); 380b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteInt(2)); 381b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int bytes = sizeof(int) * 2; 382b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 383b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(0)); 384b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(1)); 385b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(-1)); 386b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes)); 387b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes + 1)); 388b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MAX)); 389b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MIN)); 390b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 391b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 392b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, Resize) { 393b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t unit = Pickle::kPayloadUnit; 39494ffa55491333f3dcc701befd0d2652922916d99Luis Hector Chavez std::unique_ptr<char[]> data(new char[unit]); 395b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat char* data_ptr = data.get(); 396b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat for (size_t i = 0; i < unit; i++) 397b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat data_ptr[i] = 'G'; 398b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 399b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // construct a message that will be exactly the size of one payload unit, 400b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // note that any data will have a 4-byte header indicating the size 4010d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const size_t payload_size_after_header = unit - sizeof(uint32_t); 402b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 4030d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle.WriteData( 4040d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko data_ptr, static_cast<int>(payload_size_after_header - sizeof(uint32_t))); 405b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat size_t cur_payload = payload_size_after_header; 406b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 407b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // note: we assume 'unit' is a power of 2 408b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(unit, pickle.capacity_after_header()); 409b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(pickle.payload_size(), payload_size_after_header); 410b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 411b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // fill out a full page (noting data header) 4120d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32_t))); 413b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat cur_payload += unit; 414b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(unit * 2, pickle.capacity_after_header()); 415b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(cur_payload, pickle.payload_size()); 416b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 417b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // one more byte should double the capacity 418b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat pickle.WriteData(data_ptr, 1); 419b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat cur_payload += 8; 420b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(unit * 4, pickle.capacity_after_header()); 421b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(cur_payload, pickle.payload_size()); 422b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 423b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 424b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratnamespace { 425b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 426b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Eratstruct CustomHeader : Pickle::Header { 427b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int blah; 428b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat}; 429b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 430b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} // namespace 431b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 432b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, HeaderPadding) { 4330d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const uint32_t kMagic = 0x12345678; 434b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 435b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle(sizeof(CustomHeader)); 436b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat pickle.WriteInt(kMagic); 437b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 438b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // this should not overwrite the 'int' payload 439b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat pickle.headerT<CustomHeader>()->blah = 10; 440b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 441b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 442b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int result; 443b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat ASSERT_TRUE(iter.ReadInt(&result)); 444b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 4450d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(static_cast<uint32_t>(result), kMagic); 446b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 447b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 448b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, EqualsOperator) { 449b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle source; 450b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat source.WriteInt(1); 451b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 452b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()), 453b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat source.size()); 454b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle copy; 455b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat copy = copy_refs_source_buffer; 456b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat ASSERT_EQ(source.size(), copy.size()); 457b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 458b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 459b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, EvilLengths) { 460b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle source; 461b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat std::string str(100000, 'A'); 462b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(source.WriteData(str.c_str(), 100000)); 463b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // ReadString16 used to have its read buffer length calculation wrong leading 464b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // to out-of-bounds reading. 465b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(source); 466b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat string16 str16; 467b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadString16(&str16)); 468b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 469b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // And check we didn't break ReadString16. 470b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat str16 = (wchar_t) 'A'; 471b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle str16_pickle; 472b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(str16_pickle.WriteString16(str16)); 473b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat iter = PickleIterator(str16_pickle); 474b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadString16(&str16)); 475b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(1U, str16.length()); 476b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 477b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // Check we don't fail in a length check with invalid String16 size. 478b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // (1<<31) * sizeof(char16) == 0, so this is particularly evil. 479b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle bad_len; 480b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(bad_len.WriteInt(1 << 31)); 481b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat iter = PickleIterator(bad_len); 482b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_FALSE(iter.ReadString16(&str16)); 483b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 484b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 485b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Check we can write zero bytes of data and 'data' can be NULL. 486b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, ZeroLength) { 487b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 488b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteData(NULL, 0)); 489b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 490b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 491b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* outdata; 492b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int outdatalen; 493b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen)); 494b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(0, outdatalen); 495b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat // We can't assert that outdata is NULL. 496b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 497b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 498b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat// Check that ReadBytes works properly with an iterator initialized to NULL. 499b8cf94937c52feb53b55c39e3f82094d27de464cDaniel EratTEST(PickleTest, ReadBytes) { 500b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat Pickle pickle; 501b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int data = 0x7abcd; 502b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data))); 503b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 504b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat PickleIterator iter(pickle); 505b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat const char* outdata_char = NULL; 506b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_TRUE(iter.ReadBytes(&outdata_char, sizeof(data))); 507b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 508b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat int outdata; 509b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat memcpy(&outdata, outdata_char, sizeof(outdata)); 510b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat EXPECT_EQ(data, outdata); 511b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} 512b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat 5130d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko// Checks that when a pickle is deep-copied, the result is not larger than 5140d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko// needed. 5150d205d712abd16eeed2f5d5b1052a367d23a223fAlex VakulenkoTEST(PickleTest, DeepCopyResize) { 5160d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko Pickle pickle; 5170d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko while (pickle.capacity_after_header() != pickle.payload_size()) 5180d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle.WriteBool(true); 5190d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5200d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Make a deep copy. 5210d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko Pickle pickle2(pickle); 5220d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5230d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko // Check that there isn't any extraneous capacity. 5240d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(pickle.capacity_after_header(), pickle2.capacity_after_header()); 5250d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} 5260d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5270d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkonamespace { 5280d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5290d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko// Publicly exposes the ClaimBytes interface for testing. 5300d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenkoclass TestingPickle : public Pickle { 5310d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko public: 5320d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko TestingPickle() {} 5330d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5340d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko void* ClaimBytes(size_t num_bytes) { return Pickle::ClaimBytes(num_bytes); } 5350d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko}; 5360d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5370d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} // namespace 5380d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5390d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko// Checks that claimed bytes are zero-initialized. 5400d205d712abd16eeed2f5d5b1052a367d23a223fAlex VakulenkoTEST(PickleTest, ClaimBytesInitialization) { 5410d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko static const int kChunkSize = 64; 5420d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko TestingPickle pickle; 5430d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const char* bytes = static_cast<const char*>(pickle.ClaimBytes(kChunkSize)); 5440d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko for (size_t i = 0; i < kChunkSize; ++i) { 5450d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(0, bytes[i]); 5460d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko } 5470d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} 5480d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5490d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko// Checks that ClaimBytes properly advances the write offset. 5500d205d712abd16eeed2f5d5b1052a367d23a223fAlex VakulenkoTEST(PickleTest, ClaimBytes) { 5510d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko std::string data("Hello, world!"); 5520d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5530d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko TestingPickle pickle; 55445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteUInt32(data.size()); 5550d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko void* bytes = pickle.ClaimBytes(data.size()); 5560d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko pickle.WriteInt(42); 5570d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko memcpy(bytes, data.data(), data.size()); 5580d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5590d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko PickleIterator iter(pickle); 56045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko uint32_t out_data_length; 56145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_TRUE(iter.ReadUInt32(&out_data_length)); 5620d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(data.size(), out_data_length); 5630d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5640d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko const char* out_data = nullptr; 5650d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(iter.ReadBytes(&out_data, out_data_length)); 5660d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(data, std::string(out_data, out_data_length)); 5670d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 5680d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko int out_value; 5690d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_TRUE(iter.ReadInt(&out_value)); 5700d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko EXPECT_EQ(42, out_value); 5710d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko} 5720d205d712abd16eeed2f5d5b1052a367d23a223fAlex Vakulenko 57345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko// Checks that PickleSizer and Pickle agree on the size of things. 57445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex VakulenkoTEST(PickleTest, PickleSizer) { 57545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 57645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 57745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 57845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteBool(true); 57945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddBool(); 58045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 58145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 58245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 58345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 58445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 58545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteInt(42); 58645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddInt(); 58745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 58845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 58945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 59045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 59145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 59245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteLong(42); 59345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddLong(); 59445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 59545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 59645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 59745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 59845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 59945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteUInt16(42); 60045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddUInt16(); 60145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 60245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 60345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 60445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 60545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 60645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteUInt32(42); 60745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddUInt32(); 60845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 60945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 61045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 61145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 61245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 61345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteInt64(42); 61445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddInt64(); 61545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 61645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 61745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 61845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 61945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 62045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteUInt64(42); 62145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddUInt64(); 62245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 62345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 62445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 62545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 62645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 62745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteFloat(42.0f); 62845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddFloat(); 62945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 63045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 63145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 63245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 63345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 63445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteDouble(42.0); 63545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddDouble(); 63645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 63745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 63845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 63945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 64045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 64145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteString(teststring); 64245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddString(teststring); 64345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 64445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 64545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 64645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 64745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 64845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteString16(teststring16); 64945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddString16(teststring16); 65045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 65145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 65245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 65345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 65445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 65545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteData(testdata, testdatalen); 65645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddData(testdatalen); 65745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 65845779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 65945779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko { 66045779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko TestingPickle pickle; 66145779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko base::PickleSizer sizer; 66245779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko pickle.WriteBytes(testdata, testdatalen); 66345779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko sizer.AddBytes(testdatalen); 66445779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko EXPECT_EQ(sizer.payload_size(), pickle.payload_size()); 66545779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko } 66645779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko} 66745779228f8c9e40851cfd23f727e2bd8ffdd4714Alex Vakulenko 668b8cf94937c52feb53b55c39e3f82094d27de464cDaniel Erat} // namespace base 669