1// Copyright 2013 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 "net/quic/iovector.h"
6
7#include <string.h>
8
9#include "base/logging.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12using std::string;
13
14namespace net {
15namespace test {
16namespace {
17
18const char* const test_data[] = {
19  "test string 1, a medium size one.",
20  "test string2",
21  "test string      3, a looooooooooooong loooooooooooooooong string"
22};
23
24TEST(IOVectorTest, CopyConstructor) {
25  IOVector iov1;
26  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
27    iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
28  }
29  IOVector iov2 = iov1;
30  EXPECT_EQ(iov2.Size(), iov1.Size());
31  for (size_t i = 0; i < iov2.Size(); ++i) {
32    EXPECT_TRUE(iov2.iovec()[i].iov_base == iov1.iovec()[i].iov_base);
33    EXPECT_EQ(iov2.iovec()[i].iov_len, iov1.iovec()[i].iov_len);
34  }
35  EXPECT_EQ(iov2.TotalBufferSize(), iov1.TotalBufferSize());
36}
37
38TEST(IOVectorTest, AssignmentOperator) {
39  IOVector iov1;
40  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
41    iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
42  }
43  IOVector iov2;
44  iov2.Append(const_cast<char*>("ephemeral string"), 16);
45  // The following assignment results in a shallow copy;
46  // both IOVectors point to the same underlying data.
47  iov2 = iov1;
48  EXPECT_EQ(iov2.Size(), iov1.Size());
49  for (size_t i = 0; i < iov2.Size(); ++i) {
50    EXPECT_TRUE(iov2.iovec()[i].iov_base == iov1.iovec()[i].iov_base);
51    EXPECT_EQ(iov2.iovec()[i].iov_len, iov1.iovec()[i].iov_len);
52  }
53  EXPECT_EQ(iov2.TotalBufferSize(), iov1.TotalBufferSize());
54}
55
56TEST(IOVectorTest, Append) {
57  IOVector iov;
58  int length = 0;
59  const struct iovec* iov2 = iov.iovec();
60
61  ASSERT_EQ(0u, iov.Size());
62  ASSERT_TRUE(iov2 == NULL);
63  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
64    const int str_len = strlen(test_data[i]);
65    const int append_len = str_len / 2;
66    // This should append a new block
67    iov.Append(const_cast<char*>(test_data[i]), append_len);
68    length += append_len;
69    ASSERT_EQ(i + 1, static_cast<size_t>(iov.Size()));
70    ASSERT_TRUE(iov.LastBlockEnd() == test_data[i] + append_len);
71    // This should just lengthen the existing block.
72    iov.Append(const_cast<char*>(test_data[i] + append_len),
73               str_len - append_len);
74    length += (str_len - append_len);
75    ASSERT_EQ(i + 1, static_cast<size_t>(iov.Size()));
76    ASSERT_TRUE(iov.LastBlockEnd() == test_data[i] + str_len);
77  }
78
79  iov2 = iov.iovec();
80  ASSERT_TRUE(iov2 != NULL);
81  for (size_t i = 0; i < iov.Size(); ++i) {
82    ASSERT_TRUE(test_data[i] == iov2[i].iov_base);
83    ASSERT_EQ(strlen(test_data[i]), iov2[i].iov_len);
84  }
85}
86
87TEST(IOVectorTest, AppendIovec) {
88  IOVector iov;
89  const struct iovec test_iov[] = {
90    {const_cast<char*>("foo"), 3},
91    {const_cast<char*>("bar"), 3},
92    {const_cast<char*>("buzzzz"), 6}
93  };
94  iov.AppendIovec(test_iov, ARRAYSIZE_UNSAFE(test_iov));
95  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
96    EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
97    EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
98  }
99
100  // Test AppendIovecAtMostBytes.
101  iov.Clear();
102  // Stop in the middle of a block.
103  EXPECT_EQ(5u, iov.AppendIovecAtMostBytes(test_iov, ARRAYSIZE_UNSAFE(test_iov),
104                                           5));
105  EXPECT_EQ(5u, iov.TotalBufferSize());
106  iov.Append(static_cast<char*>(test_iov[1].iov_base) + 2, 1);
107  // Make sure the boundary case, where max_bytes == size of block also works.
108  EXPECT_EQ(6u, iov.AppendIovecAtMostBytes(&test_iov[2], 1, 6));
109  ASSERT_LE(ARRAYSIZE_UNSAFE(test_iov), static_cast<size_t>(iov.Size()));
110  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
111    EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
112    EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
113  }
114}
115
116TEST(IOVectorTest, ConsumeHalfBlocks) {
117  IOVector iov;
118  int length = 0;
119
120  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
121    const int str_len = strlen(test_data[i]);
122    iov.Append(const_cast<char*>(test_data[i]), str_len);
123    length += str_len;
124  }
125  const char* endp = iov.LastBlockEnd();
126  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
127    const struct iovec* iov2 = iov.iovec();
128    const size_t str_len = strlen(test_data[i]);
129    size_t tmp = str_len / 2;
130
131    ASSERT_TRUE(iov2 != NULL);
132    ASSERT_TRUE(iov2[0].iov_base == test_data[i]);
133    ASSERT_EQ(str_len, iov2[0].iov_len);
134
135    // Consume half of the first block.
136    size_t consumed = iov.Consume(tmp);
137    ASSERT_EQ(tmp, consumed);
138    ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i, static_cast<size_t>(iov.Size()));
139    iov2 = iov.iovec();
140    ASSERT_TRUE(iov2 != NULL);
141    ASSERT_TRUE(iov2[0].iov_base == test_data[i] + tmp);
142    ASSERT_EQ(iov2[0].iov_len, str_len - tmp);
143
144    // Consume the rest of the first block
145    consumed = iov.Consume(str_len - tmp);
146    ASSERT_EQ(str_len - tmp, consumed);
147    ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i - 1,
148              static_cast<size_t>(iov.Size()));
149    iov2 = iov.iovec();
150    if (iov.Size() > 0) {
151      ASSERT_TRUE(iov2 != NULL);
152      ASSERT_TRUE(iov.LastBlockEnd() == endp);
153    } else {
154      ASSERT_TRUE(iov2 == NULL);
155      ASSERT_TRUE(iov.LastBlockEnd() == NULL);
156    }
157  }
158}
159
160TEST(IOVectorTest, ConsumeTwoAndHalfBlocks) {
161  IOVector iov;
162  int length = 0;
163
164  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
165    const int str_len = strlen(test_data[i]);
166    iov.Append(const_cast<char*>(test_data[i]), str_len);
167    length += str_len;
168  }
169  const size_t last_len = strlen(test_data[ARRAYSIZE_UNSAFE(test_data) - 1]);
170  const size_t half_len = last_len / 2;
171
172  const char* endp = iov.LastBlockEnd();
173  size_t consumed = iov.Consume(length - half_len);
174  ASSERT_EQ(length - half_len, consumed);
175  const struct iovec* iov2 = iov.iovec();
176  ASSERT_TRUE(iov2 != NULL);
177  ASSERT_EQ(1u, iov.Size());
178  ASSERT_TRUE(iov2[0].iov_base ==
179              test_data[ARRAYSIZE_UNSAFE(test_data) - 1] + last_len - half_len);
180  ASSERT_EQ(half_len, iov2[0].iov_len);
181  ASSERT_TRUE(iov.LastBlockEnd() == endp);
182
183  consumed = iov.Consume(half_len);
184  ASSERT_EQ(half_len, consumed);
185  iov2 = iov.iovec();
186  ASSERT_EQ(0u, iov.Size());
187  ASSERT_TRUE(iov2 == NULL);
188  ASSERT_TRUE(iov.LastBlockEnd() == NULL);
189}
190
191TEST(IOVectorTest, ConsumeTooMuch) {
192  IOVector iov;
193  int length = 0;
194
195  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
196    const int str_len = strlen(test_data[i]);
197    iov.Append(const_cast<char*>(test_data[i]), str_len);
198    length += str_len;
199  }
200
201  int consumed = 0;
202  consumed = iov.Consume(length);
203  // TODO(rtenneti): enable when chromium supports EXPECT_DFATAL.
204  /*
205  EXPECT_DFATAL(
206      {consumed = iov.Consume(length + 1);},
207      "Attempting to consume 1 non-existent bytes.");
208  */
209  ASSERT_EQ(length, consumed);
210  const struct iovec* iov2 = iov.iovec();
211  ASSERT_EQ(0u, iov.Size());
212  ASSERT_TRUE(iov2 == NULL);
213  ASSERT_TRUE(iov.LastBlockEnd() == NULL);
214}
215
216TEST(IOVectorTest, Clear) {
217  IOVector iov;
218  int length = 0;
219
220  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
221    const int str_len = strlen(test_data[i]);
222    iov.Append(const_cast<char*>(test_data[i]), str_len);
223    length += str_len;
224  }
225  const struct iovec* iov2 = iov.iovec();
226  ASSERT_TRUE(iov2 != NULL);
227  ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data), static_cast<size_t>(iov.Size()));
228
229  iov.Clear();
230  iov2 = iov.iovec();
231  ASSERT_EQ(0u, iov.Size());
232  ASSERT_TRUE(iov2 == NULL);
233}
234
235TEST(IOVectorTest, Capacity) {
236  IOVector iov;
237  // Note: IOVector merges adjacent Appends() into a single iov.
238  // Therefore, if we expect final size of iov to be 3, we must insure
239  // that the items we are appending are not adjacent. To achieve that
240  // we use use an array (a[1] provides a buffer between a[0] and b[0],
241  // and makes them non-adjacent).
242  char a[2], b[2], c[2];
243  iov.Append(&a[0], 1);
244  iov.Append(&b[0], 1);
245  iov.Append(&c[0], 1);
246  ASSERT_EQ(3u, iov.Size());
247  size_t capacity = iov.Capacity();
248  EXPECT_LE(iov.Size(), capacity);
249  iov.Consume(2);
250  // The capacity should not have changed.
251  EXPECT_EQ(capacity, iov.Capacity());
252}
253
254TEST(IOVectorTest, Swap) {
255  IOVector iov1, iov2;
256  // See IOVector merge comment above.
257  char a[2], b[2], c[2], d[2], e[2];
258  iov1.Append(&a[0], 1);
259  iov1.Append(&b[0], 1);
260
261  iov2.Append(&c[0], 1);
262  iov2.Append(&d[0], 1);
263  iov2.Append(&e[0], 1);
264  iov1.Swap(&iov2);
265
266  ASSERT_EQ(3u, iov1.Size());
267  EXPECT_EQ(&c[0], iov1.iovec()[0].iov_base);
268  EXPECT_EQ(1u, iov1.iovec()[0].iov_len);
269  EXPECT_EQ(&d[0], iov1.iovec()[1].iov_base);
270  EXPECT_EQ(1u, iov1.iovec()[1].iov_len);
271  EXPECT_EQ(&e[0], iov1.iovec()[2].iov_base);
272  EXPECT_EQ(1u, iov1.iovec()[2].iov_len);
273
274  ASSERT_EQ(2u, iov2.Size());
275  EXPECT_EQ(&a[0], iov2.iovec()[0].iov_base);
276  EXPECT_EQ(1u, iov2.iovec()[0].iov_len);
277  EXPECT_EQ(&b[0], iov2.iovec()[1].iov_base);
278  EXPECT_EQ(1u, iov2.iovec()[1].iov_len);
279}
280
281}  // namespace
282}  // namespace test
283}  // namespace net
284