base/pickle_unittest.cc

   1 // Copyright (c) 2006-2008 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/pickle.h"
   9 #include "base/scoped_ptr.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
  23 // checks that the result
  24 void VerifyResult(const Pickle& pickle) {
  25   void* iter = NULL;
  26
  27   int outint;
  28   EXPECT_TRUE(pickle.ReadInt(&iter, &outint));
  29   EXPECT_EQ(testint, outint);
  30
  31   std::string outstr;
  32   EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
  33   EXPECT_EQ(teststr, outstr);
  34
  35   std::wstring outwstr;
  36   EXPECT_TRUE(pickle.ReadWString(&iter, &outwstr));
  37   EXPECT_EQ(testwstr, outwstr);
  38
  39   bool outbool;
  40   EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
  41   EXPECT_EQ(testbool1, outbool);
  42   EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
  43   EXPECT_EQ(testbool2, outbool);
  44
  45   const char* outdata;
  46   int outdatalen;
  47   EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
  48   EXPECT_EQ(testdatalen, outdatalen);
  49   EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
  50
  51   EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
  52   EXPECT_EQ(testdatalen, outdatalen);
  53   EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
  54
  55   // reads past the end should fail
  56   EXPECT_FALSE(pickle.ReadInt(&iter, &outint));
  57 }
  58
  59 }  // namespace
  60
  61 TEST(PickleTest, EncodeDecode) {
  62   Pickle pickle;
  63
  64   EXPECT_TRUE(pickle.WriteInt(testint));
  65   EXPECT_TRUE(pickle.WriteString(teststr));
  66   EXPECT_TRUE(pickle.WriteWString(testwstr));
  67   EXPECT_TRUE(pickle.WriteBool(testbool1));
  68   EXPECT_TRUE(pickle.WriteBool(testbool2));
  69   EXPECT_TRUE(pickle.WriteData(testdata, testdatalen));
  70
  71   // Over allocate BeginWriteData so we can test TrimWriteData.
  72   char* dest = pickle.BeginWriteData(testdatalen + 100);
  73   EXPECT_TRUE(dest);
  74   memcpy(dest, testdata, testdatalen);
  75
  76   pickle.TrimWriteData(testdatalen);
  77
  78   VerifyResult(pickle);
  79
  80   // test copy constructor
  81   Pickle pickle2(pickle);
  82   VerifyResult(pickle2);
  83
  84   // test operator=
  85   Pickle pickle3;
  86   pickle3 = pickle;
  87   VerifyResult(pickle3);
  88 }
  89
  90 TEST(PickleTest, ZeroLenStr) {
  91   Pickle pickle;
  92   EXPECT_TRUE(pickle.WriteString(""));
  93
  94   void* iter = NULL;
  95   std::string outstr;
  96   EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
  97   EXPECT_EQ("", outstr);
  98 }
  99
 100 TEST(PickleTest, ZeroLenWStr) {
 101   Pickle pickle;
 102   EXPECT_TRUE(pickle.WriteWString(L""));
 103
 104   void* iter = NULL;
 105   std::string outstr;
 106   EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
 107   EXPECT_EQ("", outstr);
 108 }
 109
 110 TEST(PickleTest, BadLenStr) {
 111   Pickle pickle;
 112   EXPECT_TRUE(pickle.WriteInt(-2));
 113
 114   void* iter = NULL;
 115   std::string outstr;
 116   EXPECT_FALSE(pickle.ReadString(&iter, &outstr));
 117 }
 118
 119 TEST(PickleTest, BadLenWStr) {
 120   Pickle pickle;
 121   EXPECT_TRUE(pickle.WriteInt(-1));
 122
 123   void* iter = NULL;
 124   std::wstring woutstr;
 125   EXPECT_FALSE(pickle.ReadWString(&iter, &woutstr));
 126 }
 127
 128 TEST(PickleTest, FindNext) {
 129   Pickle pickle;
 130   EXPECT_TRUE(pickle.WriteInt(1));
 131   EXPECT_TRUE(pickle.WriteString("Domo"));
 132
 133   const char* start = reinterpret_cast<const char*>(pickle.data());
 134   const char* end = start + pickle.size();
 135
 136   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end));
 137   EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1));
 138   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1));
 139 }
 140
 141 TEST(PickleTest, IteratorHasRoom) {
 142   Pickle pickle;
 143   EXPECT_TRUE(pickle.WriteInt(1));
 144   EXPECT_TRUE(pickle.WriteInt(2));
 145
 146   const void* iter = 0;
 147   EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, 1));
 148   iter = pickle.payload();
 149   EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, 0));
 150   EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, 1));
 151   EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, -1));
 152   EXPECT_TRUE(pickle.IteratorHasRoomFor(iter, sizeof(int) * 2));
 153   EXPECT_FALSE(pickle.IteratorHasRoomFor(iter, (sizeof(int) * 2) + 1));
 154 }
 155
 156 TEST(PickleTest, Resize) {
 157   size_t unit = Pickle::kPayloadUnit;
 158   scoped_array<char> data(new char[unit]);
 159   char* data_ptr = data.get();
 160   for (size_t i = 0; i < unit; i++)
 161     data_ptr[i] = 'G';
 162
 163   // construct a message that will be exactly the size of one payload unit,
 164   // note that any data will have a 4-byte header indicating the size
 165   const size_t payload_size_after_header = unit - sizeof(uint32);
 166   Pickle pickle;
 167   pickle.WriteData(data_ptr,
 168       static_cast<int>(payload_size_after_header - sizeof(uint32)));
 169   size_t cur_payload = payload_size_after_header;
 170
 171   // note: we assume 'unit' is a power of 2
 172   EXPECT_EQ(unit, pickle.capacity());
 173   EXPECT_EQ(pickle.payload_size(), payload_size_after_header);
 174
 175   // fill out a full page (noting data header)
 176   pickle.WriteData(data_ptr, static_cast<int>(unit - sizeof(uint32)));
 177   cur_payload += unit;
 178   EXPECT_EQ(unit * 2, pickle.capacity());
 179   EXPECT_EQ(cur_payload, pickle.payload_size());
 180
 181   // one more byte should double the capacity
 182   pickle.WriteData(data_ptr, 1);
 183   cur_payload += 5;
 184   EXPECT_EQ(unit * 4, pickle.capacity());
 185   EXPECT_EQ(cur_payload, pickle.payload_size());
 186 }
 187
 188 namespace {
 189
 190 struct CustomHeader : Pickle::Header {
 191   int blah;
 192 };
 193
 194 }  // namespace
 195
 196 TEST(PickleTest, HeaderPadding) {
 197   const uint32 kMagic = 0x12345678;
 198
 199   Pickle pickle(sizeof(CustomHeader));
 200   pickle.WriteInt(kMagic);
 201
 202   // this should not overwrite the 'int' payload
 203   pickle.headerT<CustomHeader>()->blah = 10;
 204
 205   void* iter = NULL;
 206   int result;
 207   ASSERT_TRUE(pickle.ReadInt(&iter, &result));
 208
 209   EXPECT_EQ(static_cast<uint32>(result), kMagic);
 210 }
 211
 212 TEST(PickleTest, EqualsOperator) {
 213   Pickle source;
 214   source.WriteInt(1);
 215
 216   Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()),
 217                                  source.size());
 218   Pickle copy;
 219   copy = copy_refs_source_buffer;
 220   ASSERT_EQ(source.size(), copy.size());
 221 }
 222
 223 TEST(PickleTest, EvilLengths) {
 224   Pickle source;
 225   std::string str(100000, 'A');
 226   source.WriteData(str.c_str(), 100000);
 227   // ReadString16 used to have its read buffer length calculation wrong leading
 228   // to out-of-bounds reading.
 229   void* iter = NULL;
 230   string16 str16;
 231   EXPECT_FALSE(source.ReadString16(&iter, &str16));
 232
 233   // And check we didn't break ReadString16.
 234   str16 = (wchar_t) 'A';
 235   Pickle str16_pickle;
 236   str16_pickle.WriteString16(str16);
 237   iter = NULL;
 238   EXPECT_TRUE(str16_pickle.ReadString16(&iter, &str16));
 239   EXPECT_EQ(1U, str16.length());
 240
 241   // Check we don't fail in a length check with large WStrings.
 242   Pickle big_len;
 243   big_len.WriteInt(1 << 30);
 244   iter = NULL;
 245   std::wstring wstr;
 246   EXPECT_FALSE(big_len.ReadWString(&iter, &wstr));
 247 }
 248
 249 // Check we can write zero bytes of data and 'data' can be NULL.
 250 TEST(PickleTest, ZeroLength) {
 251   Pickle pickle;
 252   EXPECT_TRUE(pickle.WriteData(NULL, 0));
 253
 254   void* iter = NULL;
 255   const char* outdata;
 256   int outdatalen;
 257   EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
 258   EXPECT_EQ(0, outdatalen);
 259   // We can't assert that outdata is NULL.
 260 }
 261