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
12 using std::string;
13
14 namespace net {
15 namespace test {
16 namespace {
17
18 const 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
TEST(IOVectorTest,CopyConstructor)24 TEST(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
TEST(IOVectorTest,AssignmentOperator)38 TEST(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
TEST(IOVectorTest,Append)56 TEST(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
TEST(IOVectorTest,AppendIovec)87 TEST(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
TEST(IOVectorTest,ConsumeHalfBlocks)116 TEST(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
TEST(IOVectorTest,ConsumeTwoAndHalfBlocks)160 TEST(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
TEST(IOVectorTest,ConsumeTooMuch)191 TEST(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
TEST(IOVectorTest,Clear)216 TEST(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
TEST(IOVectorTest,Capacity)235 TEST(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
TEST(IOVectorTest,Swap)254 TEST(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