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