base/pickle_unittest.cc

   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 <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/pickle.h"
  10 #include "base/strings/string16.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace base {
  15
  16 namespace {
  17
  18 const bool testbool1 = false;
  19 const bool testbool2 = true;
  20 const int testint = 2093847192;
  21 const long testlong = 1093847192;
  22 const uint16 testuint16 = 32123;
  23 const uint32 testuint32 = 1593847192;
  24 const int64 testint64 = -0x7E8CA9253104BDFCLL;
  25 const uint64 testuint64 = 0xCE8CA9253104BDF7ULL;
  26 const size_t testsizet = 0xFEDC7654;
  27 const float testfloat = 3.1415926935f;
  28 const double testdouble = 2.71828182845904523;
  29 const std::string teststring("Hello world");  // note non-aligned string length
  30 const std::wstring testwstring(L"Hello, world");
  31 const string16 teststring16(ASCIIToUTF16("Hello, world"));
  32 const char testrawstring[] = "Hello new world"; // Test raw string writing
  33 // Test raw char16 writing, assumes UTF16 encoding is ANSI for alpha chars.
  34 const char16 testrawstring16[] = {'A', 'l', 'o', 'h', 'a', 0};
  35 const char testdata[] = "AAA\0BBB\0";
  36 const int testdatalen = arraysize(testdata) - 1;
  37
  38 // checks that the results can be read correctly from the Pickle
  39 void VerifyResult(const Pickle& pickle) {
  40   PickleIterator iter(pickle);
  41
  42   bool outbool;
  43   EXPECT_TRUE(iter.ReadBool(&outbool));
  44   EXPECT_FALSE(outbool);
  45   EXPECT_TRUE(iter.ReadBool(&outbool));
  46   EXPECT_TRUE(outbool);
  47
  48   int outint;
  49   EXPECT_TRUE(iter.ReadInt(&outint));
  50   EXPECT_EQ(testint, outint);
  51
  52   long outlong;
  53   EXPECT_TRUE(iter.ReadLong(&outlong));
  54   EXPECT_EQ(testlong, outlong);
  55
  56   uint16 outuint16;
  57   EXPECT_TRUE(iter.ReadUInt16(&outuint16));
  58   EXPECT_EQ(testuint16, outuint16);
  59
  60   uint32 outuint32;
  61   EXPECT_TRUE(iter.ReadUInt32(&outuint32));
  62   EXPECT_EQ(testuint32, outuint32);
  63
  64   int64 outint64;
  65   EXPECT_TRUE(iter.ReadInt64(&outint64));
  66   EXPECT_EQ(testint64, outint64);
  67
  68   uint64 outuint64;
  69   EXPECT_TRUE(iter.ReadUInt64(&outuint64));
  70   EXPECT_EQ(testuint64, outuint64);
  71
  72   size_t outsizet;
  73   EXPECT_TRUE(iter.ReadSizeT(&outsizet));
  74   EXPECT_EQ(testsizet, outsizet);
  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(
 119       pickle.WriteLongUsingDangerousNonPortableLessPersistableForm(testlong));
 120   EXPECT_TRUE(pickle.WriteUInt16(testuint16));
 121   EXPECT_TRUE(pickle.WriteUInt32(testuint32));
 122   EXPECT_TRUE(pickle.WriteInt64(testint64));
 123   EXPECT_TRUE(pickle.WriteUInt64(testuint64));
 124   EXPECT_TRUE(pickle.WriteSizeT(testsizet));
 125   EXPECT_TRUE(pickle.WriteFloat(testfloat));
 126   EXPECT_TRUE(pickle.WriteDouble(testdouble));
 127   EXPECT_TRUE(pickle.WriteString(teststring));
 128   EXPECT_TRUE(pickle.WriteString16(teststring16));
 129   EXPECT_TRUE(pickle.WriteString(testrawstring));
 130   EXPECT_TRUE(pickle.WriteString16(testrawstring16));
 131   EXPECT_TRUE(pickle.WriteData(testdata, testdatalen));
 132   VerifyResult(pickle);
 133
 134   // test copy constructor
 135   Pickle pickle2(pickle);
 136   VerifyResult(pickle2);
 137
 138   // test operator=
 139   Pickle pickle3;
 140   pickle3 = pickle;
 141   VerifyResult(pickle3);
 142 }
 143
 144 // Tests that reading/writing a size_t works correctly when the source process
 145 // is 64-bit.  We rely on having both 32- and 64-bit trybots to validate both
 146 // arms of the conditional in this test.
 147 TEST(PickleTest, SizeTFrom64Bit) {
 148   Pickle pickle;
 149   // Under the hood size_t is always written as a 64-bit value, so simulate a
 150   // 64-bit size_t even on 32-bit architectures by explicitly writing a uint64.
 151   EXPECT_TRUE(pickle.WriteUInt64(testuint64));
 152
 153   PickleIterator iter(pickle);
 154   size_t outsizet;
 155   if (sizeof(size_t) < sizeof(uint64)) {
 156     // ReadSizeT() should return false when the original written value can't be
 157     // represented as a size_t.
 158     EXPECT_FALSE(iter.ReadSizeT(&outsizet));
 159   } else {
 160     EXPECT_TRUE(iter.ReadSizeT(&outsizet));
 161     EXPECT_EQ(testuint64, outsizet);
 162   }
 163 }
 164
 165 // Tests that we can handle really small buffers.
 166 TEST(PickleTest, SmallBuffer) {
 167   scoped_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, FindNext) {
 237   Pickle pickle;
 238   EXPECT_TRUE(pickle.WriteInt(1));
 239   EXPECT_TRUE(pickle.WriteString("Domo"));
 240
 241   const char* start = reinterpret_cast<const char*>(pickle.data());
 242   const char* end = start + pickle.size();
 243
 244   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end));
 245   EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1));
 246   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1));
 247 }
 248
 249 TEST(PickleTest, FindNextWithIncompleteHeader) {
 250   size_t header_size = sizeof(Pickle::Header);
 251   scoped_ptr<char[]> buffer(new char[header_size - 1]);
 252   memset(buffer.get(), 0x1, header_size - 1);
 253
 254   const char* start = buffer.get();
 255   const char* end = start + header_size - 1;
 256
 257   EXPECT_TRUE(NULL == Pickle::FindNext(header_size, start, end));
 258 }
 259
 260 #if defined(COMPILER_MSVC)
 261 #pragma warning(push)
 262 #pragma warning(disable: 4146)
 263 #endif
 264 TEST(PickleTest, FindNextOverflow) {
 265   size_t header_size = sizeof(Pickle::Header);
 266   size_t header_size2 = 2 * header_size;
 267   size_t payload_received = 100;
 268   scoped_ptr<char[]> buffer(new char[header_size2 + payload_received]);
 269   const char* start = buffer.get();
 270   Pickle::Header* header = reinterpret_cast<Pickle::Header*>(buffer.get());
 271   const char* end = start + header_size2 + payload_received;
 272   // It is impossible to construct an overflow test otherwise.
 273   if (sizeof(size_t) > sizeof(header->payload_size) ||
 274       sizeof(uintptr_t) > sizeof(header->payload_size))
 275     return;
 276
 277   header->payload_size = -(reinterpret_cast<uintptr_t>(start) + header_size2);
 278   EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end));
 279
 280   header->payload_size = -header_size2;
 281   EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end));
 282
 283   header->payload_size = 0;
 284   end = start + header_size;
 285   EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end));
 286 }
 287 #if defined(COMPILER_MSVC)
 288 #pragma warning(pop)
 289 #endif
 290
 291 TEST(PickleTest, GetReadPointerAndAdvance) {
 292   Pickle pickle;
 293
 294   PickleIterator iter(pickle);
 295   EXPECT_FALSE(iter.GetReadPointerAndAdvance(1));
 296
 297   EXPECT_TRUE(pickle.WriteInt(1));
 298   EXPECT_TRUE(pickle.WriteInt(2));
 299   int bytes = sizeof(int) * 2;
 300
 301   EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(0));
 302   EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(1));
 303   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(-1));
 304   EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes));
 305   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes + 1));
 306   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MAX));
 307   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MIN));
 308 }
 309
 310 TEST(PickleTest, Resize) {
 311   size_t unit = Pickle::kPayloadUnit;
 312   scoped_ptr<char[]> data(new char[unit]);
 313   char* data_ptr = data.get();
 314   for (size_t i = 0; i < unit; i++)
 315     data_ptr[i] = 'G';
 316
 317   // construct a message that will be exactly the size of one payload unit,
 318   // note that any data will have a 4-byte header indicating the size
 319   const size_t payload_size_after_header = unit - sizeof(uint32);
 320   Pickle pickle;
 321   pickle.WriteData(data_ptr,
 322       static_cast<int>(payload_size_after_header - sizeof(uint32)));
 323   size_t cur_payload = payload_size_after_header;
 324
 325   // note: we assume 'unit' is a power of 2
 326   EXPECT_EQ(unit, pickle.capacity_after_header());
 327   EXPECT_EQ(pickle.payload_size(), payload_size_after_header);
 328
 329   // fill out a full page (noting data header)
 330   pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32)));
 331   cur_payload += unit;
 332   EXPECT_EQ(unit * 2, pickle.capacity_after_header());
 333   EXPECT_EQ(cur_payload, pickle.payload_size());
 334
 335   // one more byte should double the capacity
 336   pickle.WriteData(data_ptr, 1);
 337   cur_payload += 8;
 338   EXPECT_EQ(unit * 4, pickle.capacity_after_header());
 339   EXPECT_EQ(cur_payload, pickle.payload_size());
 340 }
 341
 342 namespace {
 343
 344 struct CustomHeader : Pickle::Header {
 345   int blah;
 346 };
 347
 348 }  // namespace
 349
 350 TEST(PickleTest, HeaderPadding) {
 351   const uint32 kMagic = 0x12345678;
 352
 353   Pickle pickle(sizeof(CustomHeader));
 354   pickle.WriteInt(kMagic);
 355
 356   // this should not overwrite the 'int' payload
 357   pickle.headerT<CustomHeader>()->blah = 10;
 358
 359   PickleIterator iter(pickle);
 360   int result;
 361   ASSERT_TRUE(iter.ReadInt(&result));
 362
 363   EXPECT_EQ(static_cast<uint32>(result), kMagic);
 364 }
 365
 366 TEST(PickleTest, EqualsOperator) {
 367   Pickle source;
 368   source.WriteInt(1);
 369
 370   Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()),
 371                                  source.size());
 372   Pickle copy;
 373   copy = copy_refs_source_buffer;
 374   ASSERT_EQ(source.size(), copy.size());
 375 }
 376
 377 TEST(PickleTest, EvilLengths) {
 378   Pickle source;
 379   std::string str(100000, 'A');
 380   EXPECT_TRUE(source.WriteData(str.c_str(), 100000));
 381   // ReadString16 used to have its read buffer length calculation wrong leading
 382   // to out-of-bounds reading.
 383   PickleIterator iter(source);
 384   string16 str16;
 385   EXPECT_FALSE(iter.ReadString16(&str16));
 386
 387   // And check we didn't break ReadString16.
 388   str16 = (wchar_t) 'A';
 389   Pickle str16_pickle;
 390   EXPECT_TRUE(str16_pickle.WriteString16(str16));
 391   iter = PickleIterator(str16_pickle);
 392   EXPECT_TRUE(iter.ReadString16(&str16));
 393   EXPECT_EQ(1U, str16.length());
 394
 395   // Check we don't fail in a length check with invalid String16 size.
 396   // (1<<31) * sizeof(char16) == 0, so this is particularly evil.
 397   Pickle bad_len;
 398   EXPECT_TRUE(bad_len.WriteInt(1 << 31));
 399   iter = PickleIterator(bad_len);
 400   EXPECT_FALSE(iter.ReadString16(&str16));
 401 }
 402
 403 // Check we can write zero bytes of data and 'data' can be NULL.
 404 TEST(PickleTest, ZeroLength) {
 405   Pickle pickle;
 406   EXPECT_TRUE(pickle.WriteData(NULL, 0));
 407
 408   PickleIterator iter(pickle);
 409   const char* outdata;
 410   int outdatalen;
 411   EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen));
 412   EXPECT_EQ(0, outdatalen);
 413   // We can't assert that outdata is NULL.
 414 }
 415
 416 // Check that ReadBytes works properly with an iterator initialized to NULL.
 417 TEST(PickleTest, ReadBytes) {
 418   Pickle pickle;
 419   int data = 0x7abcd;
 420   EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data)));
 421
 422   PickleIterator iter(pickle);
 423   const char* outdata_char = NULL;
 424   EXPECT_TRUE(iter.ReadBytes(&outdata_char, sizeof(data)));
 425
 426   int outdata;
 427   memcpy(&outdata, outdata_char, sizeof(outdata));
 428   EXPECT_EQ(data, outdata);
 429 }
 430
 431 // Checks that when a pickle is deep-copied, the result is not larger than
 432 // needed.
 433 TEST(PickleTest, DeepCopyResize) {
 434   Pickle pickle;
 435   while (pickle.capacity_after_header() != pickle.payload_size())
 436     pickle.WriteBool(true);
 437
 438   // Make a deep copy.
 439   Pickle pickle2(pickle);
 440
 441   // Check that there isn't any extraneous capacity.
 442   EXPECT_EQ(pickle.capacity_after_header(), pickle2.capacity_after_header());
 443 }
 444
 445 }  // namespace base