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