pickle_unittest.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
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.
14using base::string16;
15
16namespace {
17
18const int testint = 2093847192;
19const std::string teststr("Hello world");  // note non-aligned string length
20const std::wstring testwstr(L"Hello, world");
21const char testdata[] = "AAA\0BBB\0";
22const int testdatalen = arraysize(testdata) - 1;
23const bool testbool1 = false;
24const bool testbool2 = true;
25const uint16 testuint16 = 32123;
26const float testfloat = 3.1415926935f;
27
28// checks that the result
29void 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
70TEST(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.
94TEST(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.
106TEST(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
116TEST(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
126TEST(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
136TEST(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
146TEST(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
155TEST(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
164TEST(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
177TEST(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
192TEST(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
219TEST(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
238TEST(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 += 5;
266  EXPECT_EQ(unit * 4, pickle.capacity_after_header());
267  EXPECT_EQ(cur_payload, pickle.payload_size());
268}
269
270namespace {
271
272struct CustomHeader : Pickle::Header {
273  int blah;
274};
275
276}  // namespace
277
278TEST(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
294TEST(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
305TEST(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.
339TEST(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.
352TEST(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}
365