OLD | NEW |
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 Loading... |
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 |
OLD | NEW |