1 // Copyright (c) 2011 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 <string> 6 7 #include "base/basictypes.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/pickle.h" 10 #include "base/string16.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 namespace { 14 15 const int testint = 2093847192; 16 const std::string teststr("Hello world"); // note non-aligned string length 17 const std::wstring testwstr(L"Hello, world"); 18 const char testdata[] = "AAA\0BBB\0"; 19 const int testdatalen = arraysize(testdata) - 1; 20 const bool testbool1 = false; 21 const bool testbool2 = true; 22 const uint16 testuint16 = 32123; 23 24 // checks that the result 25 void VerifyResult(const Pickle& pickle) { 26 void* iter = NULL; 27 28 int outint; 29 EXPECT_TRUE(pickle.ReadInt(&iter, &outint)); 30 EXPECT_EQ(testint, outint); 31 32 std::string outstr; 33 EXPECT_TRUE(pickle.ReadString(&iter, &outstr)); 34 EXPECT_EQ(teststr, outstr); 35 36 std::wstring outwstr; 37 EXPECT_TRUE(pickle.ReadWString(&iter, &outwstr)); 38 EXPECT_EQ(testwstr, outwstr); 39 40 bool outbool; 41 EXPECT_TRUE(pickle.ReadBool(&iter, &outbool)); 42 EXPECT_EQ(testbool1, outbool); 43 EXPECT_TRUE(pickle.ReadBool(&iter, &outbool)); 44 EXPECT_EQ(testbool2, outbool); 45 46 uint16 outuint16; 47 EXPECT_TRUE(pickle.ReadUInt16(&iter, &outuint16)); 48 EXPECT_EQ(testuint16, outuint16); 49 50 const char* outdata; 51 int outdatalen; 52 EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen)); 53 EXPECT_EQ(testdatalen, outdatalen); 54 EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0); 55 56 EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen)); 57 EXPECT_EQ(testdatalen, outdatalen); 58 EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0); 59 60 // reads past the end should fail 61 EXPECT_FALSE(pickle.ReadInt(&iter, &outint)); 62 } 63 64 } // namespace 65 66 TEST(PickleTest, EncodeDecode) { 67 Pickle pickle; 68 69 EXPECT_TRUE(pickle.WriteInt(testint)); 70 EXPECT_TRUE(pickle.WriteString(teststr)); 71 EXPECT_TRUE(pickle.WriteWString(testwstr)); 72 EXPECT_TRUE(pickle.WriteBool(testbool1)); 73 EXPECT_TRUE(pickle.WriteBool(testbool2)); 74 EXPECT_TRUE(pickle.WriteUInt16(testuint16)); 75 EXPECT_TRUE(pickle.WriteData(testdata, testdatalen)); 76 77 // Over allocate BeginWriteData so we can test TrimWriteData. 78 char* dest = pickle.BeginWriteData(testdatalen + 100); 79 EXPECT_TRUE(dest); 80 memcpy(dest, testdata, testdatalen); 81 82 pickle.TrimWriteData(testdatalen); 83 84 VerifyResult(pickle); 85 86 // test copy constructor 87 Pickle pickle2(pickle); 88 VerifyResult(pickle2); 89 90 // test operator= 91 Pickle pickle3; 92 pickle3 = pickle; 93 VerifyResult(pickle3); 94 } 95 96 // Tests that we can handle really small buffers. 97 TEST(PickleTest, SmallBuffer) { 98 scoped_array<char> buffer(new char[1]); 99 100 // We should not touch the buffer. 101 Pickle pickle(buffer.get(), 1); 102 103 void* iter = NULL; 104 int data; 105 EXPECT_FALSE(pickle.ReadInt(&iter, &data)); 106 } 107 108 // Tests that we can handle improper headers. 109 TEST(PickleTest, BigSize) { 110 int buffer[] = { 0x56035200, 25, 40, 50 }; 111 112 Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 113 114 void* iter = NULL; 115 int data; 116 EXPECT_FALSE(pickle.ReadInt(&iter, &data)); 117 } 118 119 TEST(PickleTest, UnalignedSize) { 120 int buffer[] = { 10, 25, 40, 50 }; 121 122 Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer)); 123 124 void* iter = NULL; 125 int data; 126 EXPECT_FALSE(pickle.ReadInt(&iter, &data)); 127 } 128 129 TEST(PickleTest, ZeroLenStr) { 130 Pickle pickle; 131 EXPECT_TRUE(pickle.WriteString("")); 132 133 void* iter = NULL; 134 std::string outstr; 135 EXPECT_TRUE(pickle.ReadString(&iter, &outstr)); 136 EXPECT_EQ("", outstr); 137 } 138 139 TEST(PickleTest, ZeroLenWStr) { 140 Pickle pickle; 141 EXPECT_TRUE(pickle.WriteWString(L"")); 142 143 void* iter = NULL; 144 std::string outstr; 145 EXPECT_TRUE(pickle.ReadString(&iter, &outstr)); 146 EXPECT_EQ("", outstr); 147 } 148 149 TEST(PickleTest, BadLenStr) { 150 Pickle pickle; 151 EXPECT_TRUE(pickle.WriteInt(-2)); 152 153 void* iter = NULL; 154 std::string outstr; 155 EXPECT_FALSE(pickle.ReadString(&iter, &outstr)); 156 } 157 158 TEST(PickleTest, BadLenWStr) { 159 Pickle pickle; 160 EXPECT_TRUE(pickle.WriteInt(-1)); 161 162 void* iter = NULL; 163 std::wstring woutstr; 164 EXPECT_FALSE(pickle.ReadWString(&iter, &woutstr)); 165 } 166 167 TEST(PickleTest, FindNext) { 168 Pickle pickle; 169 EXPECT_TRUE(pickle.WriteInt(1)); 170 EXPECT_TRUE(pickle.WriteString("Domo")); 171 172 const char* start = reinterpret_cast<const char*>(pickle.data()); 173 const char* end = start + pickle.size(); 174 175 EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end)); 176 EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1)); 177 EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1)); 178 } 179 180 TEST(PickleTest, FindNextWithIncompleteHeader) { 181 size_t header_size = sizeof(Pickle::Header); 182 scoped_array<char> buffer(new char[header_size - 1]); 183 memset(buffer.get(), 0x1, header_size - 1); 184 185 const char* start = buffer.get(); 186 const char* end = start + header_size - 1; 187 188 EXPECT_TRUE(NULL == Pickle::FindNext(header_size, start, end)); 189 } 190 191 TEST(PickleTest, IteratorHasRoom) { 192 Pickle pickle; 193 EXPECT_TRUE(pickle.WriteInt(1)); 194 EXPECT_TRUE(pickle.WriteInt(2)); 195 196 const void* iter = 0; 197 EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, 1)); 198 iter = pickle.payload(); 199 EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, 0)); 200 EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, 1)); 201 EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, -1)); 202 EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, sizeof(int) * 2)); 203 EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, (sizeof(int) * 2) + 1)); 204 } 205 206 TEST(PickleTest, Resize) { 207 size_t unit = Pickle::kPayloadUnit; 208 scoped_array<char> data(new char[unit]); 209 char* data_ptr = data.get(); 210 for (size_t i = 0; i < unit; i++) 211 data_ptr[i] = 'G'; 212 213 // construct a message that will be exactly the size of one payload unit, 214 // note that any data will have a 4-byte header indicating the size 215 const size_t payload_size_after_header = unit - sizeof(uint32); 216 Pickle pickle; 217 pickle.WriteData(data_ptr, 218 static_cast<int>(payload_size_after_header - sizeof(uint32))); 219 size_t cur_payload = payload_size_after_header; 220 221 // note: we assume 'unit' is a power of 2 222 EXPECT_EQ(unit, pickle.capacity()); 223 EXPECT_EQ(pickle.payload_size(), payload_size_after_header); 224 225 // fill out a full page (noting data header) 226 pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32))); 227 cur_payload += unit; 228 EXPECT_EQ(unit * 2, pickle.capacity()); 229 EXPECT_EQ(cur_payload, pickle.payload_size()); 230 231 // one more byte should double the capacity 232 pickle.WriteData(data_ptr, 1); 233 cur_payload += 5; 234 EXPECT_EQ(unit * 4, pickle.capacity()); 235 EXPECT_EQ(cur_payload, pickle.payload_size()); 236 } 237 238 namespace { 239 240 struct CustomHeader : Pickle::Header { 241 int blah; 242 }; 243 244 } // namespace 245 246 TEST(PickleTest, HeaderPadding) { 247 const uint32 kMagic = 0x12345678; 248 249 Pickle pickle(sizeof(CustomHeader)); 250 pickle.WriteInt(kMagic); 251 252 // this should not overwrite the 'int' payload 253 pickle.headerT<CustomHeader>()->blah = 10; 254 255 void* iter = NULL; 256 int result; 257 ASSERT_TRUE(pickle.ReadInt(&iter, &result)); 258 259 EXPECT_EQ(static_cast<uint32>(result), kMagic); 260 } 261 262 TEST(PickleTest, EqualsOperator) { 263 Pickle source; 264 source.WriteInt(1); 265 266 Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()), 267 source.size()); 268 Pickle copy; 269 copy = copy_refs_source_buffer; 270 ASSERT_EQ(source.size(), copy.size()); 271 } 272 273 TEST(PickleTest, EvilLengths) { 274 Pickle source; 275 std::string str(100000, 'A'); 276 source.WriteData(str.c_str(), 100000); 277 // ReadString16 used to have its read buffer length calculation wrong leading 278 // to out-of-bounds reading. 279 void* iter = NULL; 280 string16 str16; 281 EXPECT_FALSE(source.ReadString16(&iter, &str16)); 282 283 // And check we didn't break ReadString16. 284 str16 = (wchar_t) 'A'; 285 Pickle str16_pickle; 286 str16_pickle.WriteString16(str16); 287 iter = NULL; 288 EXPECT_TRUE(str16_pickle.ReadString16(&iter, &str16)); 289 EXPECT_EQ(1U, str16.length()); 290 291 // Check we don't fail in a length check with large WStrings. 292 Pickle big_len; 293 big_len.WriteInt(1 << 30); 294 iter = NULL; 295 std::wstring wstr; 296 EXPECT_FALSE(big_len.ReadWString(&iter, &wstr)); 297 } 298 299 // Check we can write zero bytes of data and 'data' can be NULL. 300 TEST(PickleTest, ZeroLength) { 301 Pickle pickle; 302 EXPECT_TRUE(pickle.WriteData(NULL, 0)); 303 304 void* iter = NULL; 305 const char* outdata; 306 int outdatalen; 307 EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen)); 308 EXPECT_EQ(0, outdatalen); 309 // We can't assert that outdata is NULL. 310 } 311 312 // Check that ReadBytes works properly with an iterator initialized to NULL. 313 TEST(PickleTest, ReadBytes) { 314 Pickle pickle; 315 int data = 0x7abcd; 316 EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data))); 317 318 void* iter = NULL; 319 const char* outdata_char; 320 EXPECT_TRUE(pickle.ReadBytes(&iter, &outdata_char, sizeof(data))); 321 322 int outdata; 323 memcpy(&outdata, outdata_char, sizeof(outdata)); 324 EXPECT_EQ(data, outdata); 325 } 326
