Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(481)

Side by Side Diff: net/base/chunked_upload_data_stream_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/base/chunked_upload_data_stream.h" 5 #include "net/base/chunked_upload_data_stream.h"
6 6
7 #include <memory> 7 #include <memory>
8 #include <string> 8 #include <string>
9 9
10 #include "net/base/io_buffer.h" 10 #include "net/base/io_buffer.h"
(...skipping 25 matching lines...) Expand all
36 buffer_size, 36 buffer_size,
37 TestCompletionCallback().callback()); 37 TestCompletionCallback().callback());
38 EXPECT_GE(result, 0); 38 EXPECT_GE(result, 0);
39 return std::string(buf->data(), result); 39 return std::string(buf->data(), result);
40 } 40 }
41 41
42 // Check the case data is added after the first read attempt. 42 // Check the case data is added after the first read attempt.
43 TEST(ChunkedUploadDataStreamTest, AppendOnce) { 43 TEST(ChunkedUploadDataStreamTest, AppendOnce) {
44 ChunkedUploadDataStream stream(0); 44 ChunkedUploadDataStream stream(0);
45 45
46 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 46 ASSERT_THAT(
47 IsOk()); 47 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
48 IsOk());
48 EXPECT_FALSE(stream.IsInMemory()); 49 EXPECT_FALSE(stream.IsInMemory());
49 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 50 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
50 EXPECT_EQ(0u, stream.position()); 51 EXPECT_EQ(0u, stream.position());
51 EXPECT_FALSE(stream.IsEOF()); 52 EXPECT_FALSE(stream.IsEOF());
52 53
53 TestCompletionCallback callback; 54 TestCompletionCallback callback;
54 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 55 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
55 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback()); 56 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
56 ASSERT_THAT(result, IsError(ERR_IO_PENDING)); 57 ASSERT_THAT(result, IsError(ERR_IO_PENDING));
57 58
58 stream.AppendData(kTestData, kTestDataSize, true); 59 stream.AppendData(kTestData, kTestDataSize, true);
59 int read = callback.WaitForResult(); 60 int read = callback.WaitForResult();
60 ASSERT_GE(read, 0); 61 ASSERT_GE(read, 0);
61 EXPECT_EQ(kTestData, std::string(buf->data(), read)); 62 EXPECT_EQ(kTestData, std::string(buf->data(), read));
62 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 63 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
63 EXPECT_EQ(kTestDataSize, stream.position()); 64 EXPECT_EQ(kTestDataSize, stream.position());
64 EXPECT_TRUE(stream.IsEOF()); 65 EXPECT_TRUE(stream.IsEOF());
65 } 66 }
66 67
67 TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeRead) { 68 TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeRead) {
68 ChunkedUploadDataStream stream(0); 69 ChunkedUploadDataStream stream(0);
69 70
70 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 71 ASSERT_THAT(
71 IsOk()); 72 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
73 IsOk());
72 EXPECT_FALSE(stream.IsInMemory()); 74 EXPECT_FALSE(stream.IsInMemory());
73 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 75 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
74 EXPECT_EQ(0u, stream.position()); 76 EXPECT_EQ(0u, stream.position());
75 EXPECT_FALSE(stream.IsEOF()); 77 EXPECT_FALSE(stream.IsEOF());
76 78
77 stream.AppendData(kTestData, kTestDataSize, true); 79 stream.AppendData(kTestData, kTestDataSize, true);
78 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 80 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
79 EXPECT_EQ(0u, stream.position()); 81 EXPECT_EQ(0u, stream.position());
80 EXPECT_FALSE(stream.IsEOF()); 82 EXPECT_FALSE(stream.IsEOF());
81 83
82 std::string data = ReadSync(&stream, kTestBufferSize); 84 std::string data = ReadSync(&stream, kTestBufferSize);
83 EXPECT_EQ(kTestData, data); 85 EXPECT_EQ(kTestData, data);
84 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 86 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
85 EXPECT_EQ(kTestDataSize, stream.position()); 87 EXPECT_EQ(kTestDataSize, stream.position());
86 EXPECT_TRUE(stream.IsEOF()); 88 EXPECT_TRUE(stream.IsEOF());
87 } 89 }
88 90
89 TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeInit) { 91 TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeInit) {
90 ChunkedUploadDataStream stream(0); 92 ChunkedUploadDataStream stream(0);
91 93
92 stream.AppendData(kTestData, kTestDataSize, true); 94 stream.AppendData(kTestData, kTestDataSize, true);
93 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 95 ASSERT_THAT(
94 IsOk()); 96 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
97 IsOk());
95 EXPECT_FALSE(stream.IsInMemory()); 98 EXPECT_FALSE(stream.IsInMemory());
96 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 99 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
97 EXPECT_EQ(0u, stream.position()); 100 EXPECT_EQ(0u, stream.position());
98 EXPECT_FALSE(stream.IsEOF()); 101 EXPECT_FALSE(stream.IsEOF());
99 102
100 std::string data = ReadSync(&stream, kTestBufferSize); 103 std::string data = ReadSync(&stream, kTestBufferSize);
101 EXPECT_EQ(kTestData, data); 104 EXPECT_EQ(kTestData, data);
102 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 105 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
103 EXPECT_EQ(kTestDataSize, stream.position()); 106 EXPECT_EQ(kTestDataSize, stream.position());
104 EXPECT_TRUE(stream.IsEOF()); 107 EXPECT_TRUE(stream.IsEOF());
105 } 108 }
106 109
107 TEST(ChunkedUploadDataStreamTest, MultipleAppends) { 110 TEST(ChunkedUploadDataStreamTest, MultipleAppends) {
108 ChunkedUploadDataStream stream(0); 111 ChunkedUploadDataStream stream(0);
109 112
110 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 113 ASSERT_THAT(
111 IsOk()); 114 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
115 IsOk());
112 EXPECT_FALSE(stream.IsInMemory()); 116 EXPECT_FALSE(stream.IsInMemory());
113 EXPECT_EQ(0u, stream.size()); 117 EXPECT_EQ(0u, stream.size());
114 EXPECT_EQ(0u, stream.position()); 118 EXPECT_EQ(0u, stream.position());
115 EXPECT_FALSE(stream.IsEOF()); 119 EXPECT_FALSE(stream.IsEOF());
116 120
117 TestCompletionCallback callback; 121 TestCompletionCallback callback;
118 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 122 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
119 for (size_t i = 0; i < kTestDataSize; ++i) { 123 for (size_t i = 0; i < kTestDataSize; ++i) {
120 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 124 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
121 EXPECT_EQ(i, stream.position()); 125 EXPECT_EQ(i, stream.position());
122 ASSERT_FALSE(stream.IsEOF()); 126 ASSERT_FALSE(stream.IsEOF());
123 int bytes_read = stream.Read(buf.get(), 127 int bytes_read = stream.Read(buf.get(),
124 kTestBufferSize, 128 kTestBufferSize,
125 callback.callback()); 129 callback.callback());
126 ASSERT_THAT(bytes_read, IsError(ERR_IO_PENDING)); 130 ASSERT_THAT(bytes_read, IsError(ERR_IO_PENDING));
127 stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1); 131 stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
128 ASSERT_EQ(1, callback.WaitForResult()); 132 ASSERT_EQ(1, callback.WaitForResult());
129 EXPECT_EQ(kTestData[i], buf->data()[0]); 133 EXPECT_EQ(kTestData[i], buf->data()[0]);
130 } 134 }
131 135
132 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 136 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
133 EXPECT_EQ(kTestDataSize, stream.position()); 137 EXPECT_EQ(kTestDataSize, stream.position());
134 ASSERT_TRUE(stream.IsEOF()); 138 ASSERT_TRUE(stream.IsEOF());
135 } 139 }
136 140
137 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBetweenReads) { 141 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBetweenReads) {
138 ChunkedUploadDataStream stream(0); 142 ChunkedUploadDataStream stream(0);
139 143
140 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 144 ASSERT_THAT(
141 IsOk()); 145 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
146 IsOk());
142 EXPECT_FALSE(stream.IsInMemory()); 147 EXPECT_FALSE(stream.IsInMemory());
143 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 148 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
144 EXPECT_EQ(0u, stream.position()); 149 EXPECT_EQ(0u, stream.position());
145 EXPECT_FALSE(stream.IsEOF()); 150 EXPECT_FALSE(stream.IsEOF());
146 151
147 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 152 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
148 for (size_t i = 0; i < kTestDataSize; ++i) { 153 for (size_t i = 0; i < kTestDataSize; ++i) {
149 EXPECT_EQ(i, stream.position()); 154 EXPECT_EQ(i, stream.position());
150 ASSERT_FALSE(stream.IsEOF()); 155 ASSERT_FALSE(stream.IsEOF());
151 stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1); 156 stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
152 int bytes_read = stream.Read(buf.get(), 157 int bytes_read = stream.Read(buf.get(),
153 kTestBufferSize, 158 kTestBufferSize,
154 TestCompletionCallback().callback()); 159 TestCompletionCallback().callback());
155 ASSERT_EQ(1, bytes_read); 160 ASSERT_EQ(1, bytes_read);
156 EXPECT_EQ(kTestData[i], buf->data()[0]); 161 EXPECT_EQ(kTestData[i], buf->data()[0]);
157 } 162 }
158 163
159 EXPECT_EQ(kTestDataSize, stream.position()); 164 EXPECT_EQ(kTestDataSize, stream.position());
160 ASSERT_TRUE(stream.IsEOF()); 165 ASSERT_TRUE(stream.IsEOF());
161 } 166 }
162 167
163 // Checks that multiple reads can be merged. 168 // Checks that multiple reads can be merged.
164 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBeforeInit) { 169 TEST(ChunkedUploadDataStreamTest, MultipleAppendsBeforeInit) {
165 ChunkedUploadDataStream stream(0); 170 ChunkedUploadDataStream stream(0);
166 stream.AppendData(kTestData, 1, false); 171 stream.AppendData(kTestData, 1, false);
167 stream.AppendData(kTestData + 1, 1, false); 172 stream.AppendData(kTestData + 1, 1, false);
168 stream.AppendData(kTestData + 2, kTestDataSize - 2, true); 173 stream.AppendData(kTestData + 2, kTestDataSize - 2, true);
169 174
170 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 175 ASSERT_THAT(
171 IsOk()); 176 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
177 IsOk());
172 EXPECT_FALSE(stream.IsInMemory()); 178 EXPECT_FALSE(stream.IsInMemory());
173 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 179 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
174 EXPECT_EQ(0u, stream.position()); 180 EXPECT_EQ(0u, stream.position());
175 EXPECT_FALSE(stream.IsEOF()); 181 EXPECT_FALSE(stream.IsEOF());
176 182
177 std::string data = ReadSync(&stream, kTestBufferSize); 183 std::string data = ReadSync(&stream, kTestBufferSize);
178 EXPECT_EQ(kTestData, data); 184 EXPECT_EQ(kTestData, data);
179 EXPECT_EQ(kTestDataSize, stream.position()); 185 EXPECT_EQ(kTestDataSize, stream.position());
180 ASSERT_TRUE(stream.IsEOF()); 186 ASSERT_TRUE(stream.IsEOF());
181 } 187 }
182 188
183 TEST(ChunkedUploadDataStreamTest, MultipleReads) { 189 TEST(ChunkedUploadDataStreamTest, MultipleReads) {
184 // Use a read size different from the write size to test bounds checking. 190 // Use a read size different from the write size to test bounds checking.
185 const size_t kReadSize = kTestDataSize + 3; 191 const size_t kReadSize = kTestDataSize + 3;
186 192
187 ChunkedUploadDataStream stream(0); 193 ChunkedUploadDataStream stream(0);
188 stream.AppendData(kTestData, kTestDataSize, false); 194 stream.AppendData(kTestData, kTestDataSize, false);
189 stream.AppendData(kTestData, kTestDataSize, false); 195 stream.AppendData(kTestData, kTestDataSize, false);
190 stream.AppendData(kTestData, kTestDataSize, false); 196 stream.AppendData(kTestData, kTestDataSize, false);
191 stream.AppendData(kTestData, kTestDataSize, true); 197 stream.AppendData(kTestData, kTestDataSize, true);
192 198
193 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 199 ASSERT_THAT(
194 IsOk()); 200 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
201 IsOk());
195 EXPECT_FALSE(stream.IsInMemory()); 202 EXPECT_FALSE(stream.IsInMemory());
196 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 203 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
197 EXPECT_EQ(0u, stream.position()); 204 EXPECT_EQ(0u, stream.position());
198 EXPECT_FALSE(stream.IsEOF()); 205 EXPECT_FALSE(stream.IsEOF());
199 206
200 std::string data = ReadSync(&stream, kReadSize); 207 std::string data = ReadSync(&stream, kReadSize);
201 EXPECT_EQ("0123456789012", data); 208 EXPECT_EQ("0123456789012", data);
202 EXPECT_EQ(kReadSize, stream.position()); 209 EXPECT_EQ(kReadSize, stream.position());
203 EXPECT_FALSE(stream.IsEOF()); 210 EXPECT_FALSE(stream.IsEOF());
204 211
205 data = ReadSync(&stream, kReadSize); 212 data = ReadSync(&stream, kReadSize);
206 EXPECT_EQ("3456789012345", data); 213 EXPECT_EQ("3456789012345", data);
207 EXPECT_EQ(2 * kReadSize, stream.position()); 214 EXPECT_EQ(2 * kReadSize, stream.position());
208 EXPECT_FALSE(stream.IsEOF()); 215 EXPECT_FALSE(stream.IsEOF());
209 216
210 data = ReadSync(&stream, kReadSize); 217 data = ReadSync(&stream, kReadSize);
211 EXPECT_EQ("6789012345678", data); 218 EXPECT_EQ("6789012345678", data);
212 EXPECT_EQ(3 * kReadSize, stream.position()); 219 EXPECT_EQ(3 * kReadSize, stream.position());
213 EXPECT_FALSE(stream.IsEOF()); 220 EXPECT_FALSE(stream.IsEOF());
214 221
215 data = ReadSync(&stream, kReadSize); 222 data = ReadSync(&stream, kReadSize);
216 EXPECT_EQ("9", data); 223 EXPECT_EQ("9", data);
217 EXPECT_EQ(4 * kTestDataSize, stream.position()); 224 EXPECT_EQ(4 * kTestDataSize, stream.position());
218 EXPECT_TRUE(stream.IsEOF()); 225 EXPECT_TRUE(stream.IsEOF());
219 } 226 }
220 227
221 TEST(ChunkedUploadDataStreamTest, EmptyUpload) { 228 TEST(ChunkedUploadDataStreamTest, EmptyUpload) {
222 ChunkedUploadDataStream stream(0); 229 ChunkedUploadDataStream stream(0);
223 230
224 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 231 ASSERT_THAT(
225 IsOk()); 232 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
233 IsOk());
226 EXPECT_FALSE(stream.IsInMemory()); 234 EXPECT_FALSE(stream.IsInMemory());
227 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 235 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
228 EXPECT_EQ(0u, stream.position()); 236 EXPECT_EQ(0u, stream.position());
229 EXPECT_FALSE(stream.IsEOF()); 237 EXPECT_FALSE(stream.IsEOF());
230 238
231 TestCompletionCallback callback; 239 TestCompletionCallback callback;
232 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 240 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
233 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback()); 241 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
234 ASSERT_THAT(result, IsError(ERR_IO_PENDING)); 242 ASSERT_THAT(result, IsError(ERR_IO_PENDING));
235 243
236 stream.AppendData(NULL, 0, true); 244 stream.AppendData(NULL, 0, true);
237 int read = callback.WaitForResult(); 245 int read = callback.WaitForResult();
238 EXPECT_EQ(0, read); 246 EXPECT_EQ(0, read);
239 EXPECT_EQ(0u, stream.position()); 247 EXPECT_EQ(0u, stream.position());
240 EXPECT_TRUE(stream.IsEOF()); 248 EXPECT_TRUE(stream.IsEOF());
241 } 249 }
242 250
243 TEST(ChunkedUploadDataStreamTest, EmptyUploadEndedBeforeInit) { 251 TEST(ChunkedUploadDataStreamTest, EmptyUploadEndedBeforeInit) {
244 ChunkedUploadDataStream stream(0); 252 ChunkedUploadDataStream stream(0);
245 stream.AppendData(NULL, 0, true); 253 stream.AppendData(NULL, 0, true);
246 254
247 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 255 ASSERT_THAT(
248 IsOk()); 256 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
257 IsOk());
249 EXPECT_FALSE(stream.IsInMemory()); 258 EXPECT_FALSE(stream.IsInMemory());
250 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 259 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
251 EXPECT_EQ(0u, stream.position()); 260 EXPECT_EQ(0u, stream.position());
252 EXPECT_FALSE(stream.IsEOF()); 261 EXPECT_FALSE(stream.IsEOF());
253 262
254 std::string data = ReadSync(&stream, kTestBufferSize); 263 std::string data = ReadSync(&stream, kTestBufferSize);
255 ASSERT_EQ("", data); 264 ASSERT_EQ("", data);
256 EXPECT_EQ(0u, stream.position()); 265 EXPECT_EQ(0u, stream.position());
257 EXPECT_TRUE(stream.IsEOF()); 266 EXPECT_TRUE(stream.IsEOF());
258 } 267 }
259 268
260 TEST(ChunkedUploadDataStreamTest, RewindAfterComplete) { 269 TEST(ChunkedUploadDataStreamTest, RewindAfterComplete) {
261 ChunkedUploadDataStream stream(0); 270 ChunkedUploadDataStream stream(0);
262 stream.AppendData(kTestData, 1, false); 271 stream.AppendData(kTestData, 1, false);
263 stream.AppendData(kTestData + 1, kTestDataSize - 1, true); 272 stream.AppendData(kTestData + 1, kTestDataSize - 1, true);
264 273
265 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 274 ASSERT_THAT(
266 IsOk()); 275 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
276 IsOk());
267 EXPECT_FALSE(stream.IsInMemory()); 277 EXPECT_FALSE(stream.IsInMemory());
268 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 278 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
269 EXPECT_EQ(0u, stream.position()); 279 EXPECT_EQ(0u, stream.position());
270 EXPECT_FALSE(stream.IsEOF()); 280 EXPECT_FALSE(stream.IsEOF());
271 281
272 std::string data = ReadSync(&stream, kTestBufferSize); 282 std::string data = ReadSync(&stream, kTestBufferSize);
273 EXPECT_EQ(kTestData, data); 283 EXPECT_EQ(kTestData, data);
274 EXPECT_EQ(kTestDataSize, stream.position()); 284 EXPECT_EQ(kTestDataSize, stream.position());
275 ASSERT_TRUE(stream.IsEOF()); 285 ASSERT_TRUE(stream.IsEOF());
276 286
277 // Rewind stream and repeat. 287 // Rewind stream and repeat.
278 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 288 ASSERT_THAT(
279 IsOk()); 289 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
290 IsOk());
280 EXPECT_FALSE(stream.IsInMemory()); 291 EXPECT_FALSE(stream.IsInMemory());
281 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 292 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
282 EXPECT_EQ(0u, stream.position()); 293 EXPECT_EQ(0u, stream.position());
283 EXPECT_FALSE(stream.IsEOF()); 294 EXPECT_FALSE(stream.IsEOF());
284 295
285 data = ReadSync(&stream, kTestBufferSize); 296 data = ReadSync(&stream, kTestBufferSize);
286 EXPECT_EQ(kTestData, data); 297 EXPECT_EQ(kTestData, data);
287 EXPECT_EQ(kTestDataSize, stream.position()); 298 EXPECT_EQ(kTestDataSize, stream.position());
288 ASSERT_TRUE(stream.IsEOF()); 299 ASSERT_TRUE(stream.IsEOF());
289 } 300 }
290 301
291 TEST(ChunkedUploadDataStreamTest, RewindWhileReading) { 302 TEST(ChunkedUploadDataStreamTest, RewindWhileReading) {
292 ChunkedUploadDataStream stream(0); 303 ChunkedUploadDataStream stream(0);
293 304
294 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 305 ASSERT_THAT(
295 IsOk()); 306 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
307 IsOk());
296 EXPECT_FALSE(stream.IsInMemory()); 308 EXPECT_FALSE(stream.IsInMemory());
297 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 309 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
298 EXPECT_EQ(0u, stream.position()); 310 EXPECT_EQ(0u, stream.position());
299 EXPECT_FALSE(stream.IsEOF()); 311 EXPECT_FALSE(stream.IsEOF());
300 312
301 TestCompletionCallback callback; 313 TestCompletionCallback callback;
302 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 314 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
303 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback()); 315 int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
304 ASSERT_THAT(result, IsError(ERR_IO_PENDING)); 316 ASSERT_THAT(result, IsError(ERR_IO_PENDING));
305 317
306 ASSERT_THAT(stream.Init(TestCompletionCallback().callback(), BoundNetLog()), 318 ASSERT_THAT(
307 IsOk()); 319 stream.Init(TestCompletionCallback().callback(), NetLogWithSource()),
320 IsOk());
308 EXPECT_FALSE(stream.IsInMemory()); 321 EXPECT_FALSE(stream.IsInMemory());
309 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data. 322 EXPECT_EQ(0u, stream.size()); // Content-Length is 0 for chunked data.
310 EXPECT_EQ(0u, stream.position()); 323 EXPECT_EQ(0u, stream.position());
311 EXPECT_FALSE(stream.IsEOF()); 324 EXPECT_FALSE(stream.IsEOF());
312 325
313 // Adding data now should not result in calling the original read callback, 326 // Adding data now should not result in calling the original read callback,
314 // since the stream was re-initialized for reuse, which cancels all pending 327 // since the stream was re-initialized for reuse, which cancels all pending
315 // reads. 328 // reads.
316 stream.AppendData(kTestData, kTestDataSize, true); 329 stream.AppendData(kTestData, kTestDataSize, true);
317 EXPECT_FALSE(callback.have_result()); 330 EXPECT_FALSE(callback.have_result());
318 331
319 std::string data = ReadSync(&stream, kTestBufferSize); 332 std::string data = ReadSync(&stream, kTestBufferSize);
320 EXPECT_EQ(kTestData, data); 333 EXPECT_EQ(kTestData, data);
321 EXPECT_EQ(kTestDataSize, stream.position()); 334 EXPECT_EQ(kTestDataSize, stream.position());
322 ASSERT_TRUE(stream.IsEOF()); 335 ASSERT_TRUE(stream.IsEOF());
323 EXPECT_FALSE(callback.have_result()); 336 EXPECT_FALSE(callback.have_result());
324 } 337 }
325 338
326 // Check the behavior of ChunkedUploadDataStream::Writer. 339 // Check the behavior of ChunkedUploadDataStream::Writer.
327 TEST(ChunkedUploadDataStreamTest, ChunkedUploadDataStreamWriter) { 340 TEST(ChunkedUploadDataStreamTest, ChunkedUploadDataStreamWriter) {
328 std::unique_ptr<ChunkedUploadDataStream> stream( 341 std::unique_ptr<ChunkedUploadDataStream> stream(
329 new ChunkedUploadDataStream(0)); 342 new ChunkedUploadDataStream(0));
330 std::unique_ptr<ChunkedUploadDataStream::Writer> writer( 343 std::unique_ptr<ChunkedUploadDataStream::Writer> writer(
331 stream->CreateWriter()); 344 stream->CreateWriter());
332 345
333 // Write before Init. 346 // Write before Init.
334 ASSERT_TRUE(writer->AppendData(kTestData, 1, false)); 347 ASSERT_TRUE(writer->AppendData(kTestData, 1, false));
335 ASSERT_THAT(stream->Init(TestCompletionCallback().callback(), BoundNetLog()), 348 ASSERT_THAT(
336 IsOk()); 349 stream->Init(TestCompletionCallback().callback(), NetLogWithSource()),
350 IsOk());
337 351
338 // Write after Init. 352 // Write after Init.
339 ASSERT_TRUE(writer->AppendData(kTestData + 1, kTestDataSize - 1, false)); 353 ASSERT_TRUE(writer->AppendData(kTestData + 1, kTestDataSize - 1, false));
340 354
341 TestCompletionCallback callback; 355 TestCompletionCallback callback;
342 std::string data = ReadSync(stream.get(), kTestBufferSize); 356 std::string data = ReadSync(stream.get(), kTestBufferSize);
343 EXPECT_EQ(kTestData, data); 357 EXPECT_EQ(kTestData, data);
344 358
345 // Writing data should gracefully fail if the stream is deleted while still 359 // Writing data should gracefully fail if the stream is deleted while still
346 // appending data to it. 360 // appending data to it.
347 stream.reset(); 361 stream.reset();
348 EXPECT_FALSE(writer->AppendData(kTestData, kTestDataSize, true)); 362 EXPECT_FALSE(writer->AppendData(kTestData, kTestDataSize, true));
349 } 363 }
350 364
351 } // namespace net 365 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698