OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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/upload_file_element_reader.h" | 5 #include "net/base/upload_file_element_reader.h" |
6 | 6 |
7 #include "base/file_util.h" | 7 #include "base/file_util.h" |
8 #include "base/files/scoped_temp_dir.h" | 8 #include "base/files/scoped_temp_dir.h" |
9 #include "base/message_loop_proxy.h" | 9 #include "base/message_loop_proxy.h" |
10 #include "net/base/io_buffer.h" | 10 #include "net/base/io_buffer.h" |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
46 base::ScopedTempDir temp_dir_; | 46 base::ScopedTempDir temp_dir_; |
47 base::FilePath temp_file_path_; | 47 base::FilePath temp_file_path_; |
48 }; | 48 }; |
49 | 49 |
50 TEST_F(UploadFileElementReaderTest, ReadPartially) { | 50 TEST_F(UploadFileElementReaderTest, ReadPartially) { |
51 const size_t kHalfSize = bytes_.size() / 2; | 51 const size_t kHalfSize = bytes_.size() / 2; |
52 ASSERT_EQ(bytes_.size(), kHalfSize * 2); | 52 ASSERT_EQ(bytes_.size(), kHalfSize * 2); |
53 std::vector<char> buf(kHalfSize); | 53 std::vector<char> buf(kHalfSize); |
54 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 54 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
55 TestCompletionCallback read_callback1; | 55 TestCompletionCallback read_callback1; |
56 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 56 ASSERT_EQ(ERR_IO_PENDING, |
57 read_callback1.callback())); | 57 reader_->Read( |
| 58 wrapped_buffer.get(), buf.size(), read_callback1.callback())); |
58 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); | 59 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); |
59 EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); | 60 EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); |
60 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf); | 61 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf); |
61 | 62 |
62 TestCompletionCallback read_callback2; | 63 TestCompletionCallback read_callback2; |
63 EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 64 EXPECT_EQ(ERR_IO_PENDING, |
64 read_callback2.callback())); | 65 reader_->Read( |
| 66 wrapped_buffer.get(), buf.size(), read_callback2.callback())); |
65 EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult()); | 67 EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult()); |
66 EXPECT_EQ(0U, reader_->BytesRemaining()); | 68 EXPECT_EQ(0U, reader_->BytesRemaining()); |
67 EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf); | 69 EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf); |
68 } | 70 } |
69 | 71 |
70 TEST_F(UploadFileElementReaderTest, ReadAll) { | 72 TEST_F(UploadFileElementReaderTest, ReadAll) { |
71 std::vector<char> buf(bytes_.size()); | 73 std::vector<char> buf(bytes_.size()); |
72 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 74 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
73 TestCompletionCallback read_callback; | 75 TestCompletionCallback read_callback; |
74 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 76 ASSERT_EQ(ERR_IO_PENDING, |
75 read_callback.callback())); | 77 reader_->Read( |
| 78 wrapped_buffer.get(), buf.size(), read_callback.callback())); |
76 EXPECT_EQ(static_cast<int>(buf.size()), read_callback.WaitForResult()); | 79 EXPECT_EQ(static_cast<int>(buf.size()), read_callback.WaitForResult()); |
77 EXPECT_EQ(0U, reader_->BytesRemaining()); | 80 EXPECT_EQ(0U, reader_->BytesRemaining()); |
78 EXPECT_EQ(bytes_, buf); | 81 EXPECT_EQ(bytes_, buf); |
79 // Try to read again. | 82 // Try to read again. |
80 EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), | 83 EXPECT_EQ(0, |
81 read_callback.callback())); | 84 reader_->Read( |
| 85 wrapped_buffer.get(), buf.size(), read_callback.callback())); |
82 } | 86 } |
83 | 87 |
84 TEST_F(UploadFileElementReaderTest, ReadTooMuch) { | 88 TEST_F(UploadFileElementReaderTest, ReadTooMuch) { |
85 const size_t kTooLargeSize = bytes_.size() * 2; | 89 const size_t kTooLargeSize = bytes_.size() * 2; |
86 std::vector<char> buf(kTooLargeSize); | 90 std::vector<char> buf(kTooLargeSize); |
87 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 91 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
88 TestCompletionCallback read_callback; | 92 TestCompletionCallback read_callback; |
89 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 93 ASSERT_EQ(ERR_IO_PENDING, |
90 read_callback.callback())); | 94 reader_->Read( |
| 95 wrapped_buffer.get(), buf.size(), read_callback.callback())); |
91 EXPECT_EQ(static_cast<int>(bytes_.size()), read_callback.WaitForResult()); | 96 EXPECT_EQ(static_cast<int>(bytes_.size()), read_callback.WaitForResult()); |
92 EXPECT_EQ(0U, reader_->BytesRemaining()); | 97 EXPECT_EQ(0U, reader_->BytesRemaining()); |
93 buf.resize(bytes_.size()); // Resize to compare. | 98 buf.resize(bytes_.size()); // Resize to compare. |
94 EXPECT_EQ(bytes_, buf); | 99 EXPECT_EQ(bytes_, buf); |
95 } | 100 } |
96 | 101 |
97 TEST_F(UploadFileElementReaderTest, MultipleInit) { | 102 TEST_F(UploadFileElementReaderTest, MultipleInit) { |
98 std::vector<char> buf(bytes_.size()); | 103 std::vector<char> buf(bytes_.size()); |
99 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 104 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
100 | 105 |
101 // Read all. | 106 // Read all. |
102 TestCompletionCallback read_callback1; | 107 TestCompletionCallback read_callback1; |
103 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 108 ASSERT_EQ(ERR_IO_PENDING, |
104 read_callback1.callback())); | 109 reader_->Read( |
| 110 wrapped_buffer.get(), buf.size(), read_callback1.callback())); |
105 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); | 111 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); |
106 EXPECT_EQ(0U, reader_->BytesRemaining()); | 112 EXPECT_EQ(0U, reader_->BytesRemaining()); |
107 EXPECT_EQ(bytes_, buf); | 113 EXPECT_EQ(bytes_, buf); |
108 | 114 |
109 // Call Init() again to reset the state. | 115 // Call Init() again to reset the state. |
110 TestCompletionCallback init_callback; | 116 TestCompletionCallback init_callback; |
111 ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 117 ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
112 EXPECT_EQ(OK, init_callback.WaitForResult()); | 118 EXPECT_EQ(OK, init_callback.WaitForResult()); |
113 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); | 119 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); |
114 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); | 120 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); |
115 | 121 |
116 // Read again. | 122 // Read again. |
117 TestCompletionCallback read_callback2; | 123 TestCompletionCallback read_callback2; |
118 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 124 ASSERT_EQ(ERR_IO_PENDING, |
119 read_callback2.callback())); | 125 reader_->Read( |
| 126 wrapped_buffer.get(), buf.size(), read_callback2.callback())); |
120 EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult()); | 127 EXPECT_EQ(static_cast<int>(buf.size()), read_callback2.WaitForResult()); |
121 EXPECT_EQ(0U, reader_->BytesRemaining()); | 128 EXPECT_EQ(0U, reader_->BytesRemaining()); |
122 EXPECT_EQ(bytes_, buf); | 129 EXPECT_EQ(bytes_, buf); |
123 } | 130 } |
124 | 131 |
125 TEST_F(UploadFileElementReaderTest, InitDuringAsyncOperation) { | 132 TEST_F(UploadFileElementReaderTest, InitDuringAsyncOperation) { |
126 std::vector<char> buf(bytes_.size()); | 133 std::vector<char> buf(bytes_.size()); |
127 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 134 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
128 | 135 |
129 // Start reading all. | 136 // Start reading all. |
130 TestCompletionCallback read_callback1; | 137 TestCompletionCallback read_callback1; |
131 EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), | 138 EXPECT_EQ(ERR_IO_PENDING, |
132 read_callback1.callback())); | 139 reader_->Read( |
| 140 wrapped_buffer.get(), buf.size(), read_callback1.callback())); |
133 | 141 |
134 // Call Init to cancel the previous read. | 142 // Call Init to cancel the previous read. |
135 TestCompletionCallback init_callback1; | 143 TestCompletionCallback init_callback1; |
136 EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback1.callback())); | 144 EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback1.callback())); |
137 | 145 |
138 // Call Init again to cancel the previous init. | 146 // Call Init again to cancel the previous init. |
139 TestCompletionCallback init_callback2; | 147 TestCompletionCallback init_callback2; |
140 EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback2.callback())); | 148 EXPECT_EQ(ERR_IO_PENDING, reader_->Init(init_callback2.callback())); |
141 EXPECT_EQ(OK, init_callback2.WaitForResult()); | 149 EXPECT_EQ(OK, init_callback2.WaitForResult()); |
142 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); | 150 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); |
143 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); | 151 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); |
144 | 152 |
145 // Read half. | 153 // Read half. |
146 std::vector<char> buf2(bytes_.size() / 2); | 154 std::vector<char> buf2(bytes_.size() / 2); |
147 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); | 155 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); |
148 TestCompletionCallback read_callback2; | 156 TestCompletionCallback read_callback2; |
149 EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer2, buf2.size(), | 157 EXPECT_EQ(ERR_IO_PENDING, |
150 read_callback2.callback())); | 158 reader_->Read( |
| 159 wrapped_buffer2.get(), buf2.size(), read_callback2.callback())); |
151 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); | 160 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); |
152 EXPECT_EQ(bytes_.size() - buf2.size(), reader_->BytesRemaining()); | 161 EXPECT_EQ(bytes_.size() - buf2.size(), reader_->BytesRemaining()); |
153 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + buf2.size()), | 162 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + buf2.size()), |
154 buf2); | 163 buf2); |
155 | 164 |
156 // Make sure callbacks are not called for cancelled operations. | 165 // Make sure callbacks are not called for cancelled operations. |
157 EXPECT_FALSE(read_callback1.have_result()); | 166 EXPECT_FALSE(read_callback1.have_result()); |
158 EXPECT_FALSE(init_callback1.have_result()); | 167 EXPECT_FALSE(init_callback1.have_result()); |
159 } | 168 } |
160 | 169 |
161 TEST_F(UploadFileElementReaderTest, Range) { | 170 TEST_F(UploadFileElementReaderTest, Range) { |
162 const uint64 kOffset = 2; | 171 const uint64 kOffset = 2; |
163 const uint64 kLength = bytes_.size() - kOffset * 3; | 172 const uint64 kLength = bytes_.size() - kOffset * 3; |
164 reader_.reset(new UploadFileElementReader( | 173 reader_.reset(new UploadFileElementReader( |
165 base::MessageLoopProxy::current(), | 174 base::MessageLoopProxy::current(), |
166 temp_file_path_, kOffset, kLength, base::Time())); | 175 temp_file_path_, kOffset, kLength, base::Time())); |
167 TestCompletionCallback init_callback; | 176 TestCompletionCallback init_callback; |
168 ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 177 ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
169 EXPECT_EQ(OK, init_callback.WaitForResult()); | 178 EXPECT_EQ(OK, init_callback.WaitForResult()); |
170 EXPECT_EQ(kLength, reader_->GetContentLength()); | 179 EXPECT_EQ(kLength, reader_->GetContentLength()); |
171 EXPECT_EQ(kLength, reader_->BytesRemaining()); | 180 EXPECT_EQ(kLength, reader_->BytesRemaining()); |
172 std::vector<char> buf(kLength); | 181 std::vector<char> buf(kLength); |
173 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 182 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
174 TestCompletionCallback read_callback; | 183 TestCompletionCallback read_callback; |
175 ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, kLength, | 184 ASSERT_EQ( |
176 read_callback.callback())); | 185 ERR_IO_PENDING, |
| 186 reader_->Read(wrapped_buffer.get(), kLength, read_callback.callback())); |
177 EXPECT_EQ(static_cast<int>(kLength), read_callback.WaitForResult()); | 187 EXPECT_EQ(static_cast<int>(kLength), read_callback.WaitForResult()); |
178 const std::vector<char> expected(bytes_.begin() + kOffset, | 188 const std::vector<char> expected(bytes_.begin() + kOffset, |
179 bytes_.begin() + kOffset + kLength); | 189 bytes_.begin() + kOffset + kLength); |
180 EXPECT_EQ(expected, buf); | 190 EXPECT_EQ(expected, buf); |
181 } | 191 } |
182 | 192 |
183 TEST_F(UploadFileElementReaderTest, FileChanged) { | 193 TEST_F(UploadFileElementReaderTest, FileChanged) { |
184 base::PlatformFileInfo info; | 194 base::PlatformFileInfo info; |
185 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_, &info)); | 195 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_, &info)); |
186 | 196 |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
235 scoped_ptr<UploadElementReader> reader_; | 245 scoped_ptr<UploadElementReader> reader_; |
236 base::ScopedTempDir temp_dir_; | 246 base::ScopedTempDir temp_dir_; |
237 base::FilePath temp_file_path_; | 247 base::FilePath temp_file_path_; |
238 }; | 248 }; |
239 | 249 |
240 TEST_F(UploadFileElementReaderSyncTest, ReadPartially) { | 250 TEST_F(UploadFileElementReaderSyncTest, ReadPartially) { |
241 const size_t kHalfSize = bytes_.size() / 2; | 251 const size_t kHalfSize = bytes_.size() / 2; |
242 ASSERT_EQ(bytes_.size(), kHalfSize * 2); | 252 ASSERT_EQ(bytes_.size(), kHalfSize * 2); |
243 std::vector<char> buf(kHalfSize); | 253 std::vector<char> buf(kHalfSize); |
244 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 254 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
245 EXPECT_EQ(static_cast<int>(buf.size()), | 255 EXPECT_EQ( |
246 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 256 static_cast<int>(buf.size()), |
| 257 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
247 EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); | 258 EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); |
248 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf); | 259 EXPECT_EQ(std::vector<char>(bytes_.begin(), bytes_.begin() + kHalfSize), buf); |
249 | 260 |
250 EXPECT_EQ(static_cast<int>(buf.size()), | 261 EXPECT_EQ( |
251 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 262 static_cast<int>(buf.size()), |
| 263 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
252 EXPECT_EQ(0U, reader_->BytesRemaining()); | 264 EXPECT_EQ(0U, reader_->BytesRemaining()); |
253 EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf); | 265 EXPECT_EQ(std::vector<char>(bytes_.begin() + kHalfSize, bytes_.end()), buf); |
254 } | 266 } |
255 | 267 |
256 TEST_F(UploadFileElementReaderSyncTest, ReadAll) { | 268 TEST_F(UploadFileElementReaderSyncTest, ReadAll) { |
257 std::vector<char> buf(bytes_.size()); | 269 std::vector<char> buf(bytes_.size()); |
258 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 270 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
259 EXPECT_EQ(static_cast<int>(buf.size()), | 271 EXPECT_EQ( |
260 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 272 static_cast<int>(buf.size()), |
| 273 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
261 EXPECT_EQ(0U, reader_->BytesRemaining()); | 274 EXPECT_EQ(0U, reader_->BytesRemaining()); |
262 EXPECT_EQ(bytes_, buf); | 275 EXPECT_EQ(bytes_, buf); |
263 // Try to read again. | 276 // Try to read again. |
264 EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 277 EXPECT_EQ( |
| 278 0, reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
265 } | 279 } |
266 | 280 |
267 TEST_F(UploadFileElementReaderSyncTest, ReadTooMuch) { | 281 TEST_F(UploadFileElementReaderSyncTest, ReadTooMuch) { |
268 const size_t kTooLargeSize = bytes_.size() * 2; | 282 const size_t kTooLargeSize = bytes_.size() * 2; |
269 std::vector<char> buf(kTooLargeSize); | 283 std::vector<char> buf(kTooLargeSize); |
270 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 284 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
271 EXPECT_EQ(static_cast<int>(bytes_.size()), | 285 EXPECT_EQ( |
272 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 286 static_cast<int>(bytes_.size()), |
| 287 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
273 EXPECT_EQ(0U, reader_->BytesRemaining()); | 288 EXPECT_EQ(0U, reader_->BytesRemaining()); |
274 buf.resize(bytes_.size()); // Resize to compare. | 289 buf.resize(bytes_.size()); // Resize to compare. |
275 EXPECT_EQ(bytes_, buf); | 290 EXPECT_EQ(bytes_, buf); |
276 } | 291 } |
277 | 292 |
278 TEST_F(UploadFileElementReaderSyncTest, MultipleInit) { | 293 TEST_F(UploadFileElementReaderSyncTest, MultipleInit) { |
279 std::vector<char> buf(bytes_.size()); | 294 std::vector<char> buf(bytes_.size()); |
280 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 295 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
281 | 296 |
282 // Read all. | 297 // Read all. |
283 EXPECT_EQ(static_cast<int>(buf.size()), | 298 EXPECT_EQ( |
284 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 299 static_cast<int>(buf.size()), |
| 300 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
285 EXPECT_EQ(0U, reader_->BytesRemaining()); | 301 EXPECT_EQ(0U, reader_->BytesRemaining()); |
286 EXPECT_EQ(bytes_, buf); | 302 EXPECT_EQ(bytes_, buf); |
287 | 303 |
288 // Call Init() again to reset the state. | 304 // Call Init() again to reset the state. |
289 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); | 305 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); |
290 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); | 306 EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); |
291 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); | 307 EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); |
292 | 308 |
293 // Read again. | 309 // Read again. |
294 EXPECT_EQ(static_cast<int>(buf.size()), | 310 EXPECT_EQ( |
295 reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); | 311 static_cast<int>(buf.size()), |
| 312 reader_->Read(wrapped_buffer.get(), buf.size(), CompletionCallback())); |
296 EXPECT_EQ(0U, reader_->BytesRemaining()); | 313 EXPECT_EQ(0U, reader_->BytesRemaining()); |
297 EXPECT_EQ(bytes_, buf); | 314 EXPECT_EQ(bytes_, buf); |
298 } | 315 } |
299 | 316 |
300 TEST_F(UploadFileElementReaderSyncTest, Range) { | 317 TEST_F(UploadFileElementReaderSyncTest, Range) { |
301 const uint64 kOffset = 2; | 318 const uint64 kOffset = 2; |
302 const uint64 kLength = bytes_.size() - kOffset * 3; | 319 const uint64 kLength = bytes_.size() - kOffset * 3; |
303 reader_.reset(new UploadFileElementReaderSync( | 320 reader_.reset(new UploadFileElementReaderSync( |
304 temp_file_path_, kOffset, kLength, base::Time())); | 321 temp_file_path_, kOffset, kLength, base::Time())); |
305 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); | 322 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); |
306 EXPECT_EQ(kLength, reader_->GetContentLength()); | 323 EXPECT_EQ(kLength, reader_->GetContentLength()); |
307 EXPECT_EQ(kLength, reader_->BytesRemaining()); | 324 EXPECT_EQ(kLength, reader_->BytesRemaining()); |
308 std::vector<char> buf(kLength); | 325 std::vector<char> buf(kLength); |
309 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 326 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
310 EXPECT_EQ(static_cast<int>(kLength), | 327 EXPECT_EQ(static_cast<int>(kLength), |
311 reader_->Read(wrapped_buffer, kLength, CompletionCallback())); | 328 reader_->Read(wrapped_buffer.get(), kLength, CompletionCallback())); |
312 const std::vector<char> expected(bytes_.begin() + kOffset, | 329 const std::vector<char> expected(bytes_.begin() + kOffset, |
313 bytes_.begin() + kOffset + kLength); | 330 bytes_.begin() + kOffset + kLength); |
314 EXPECT_EQ(expected, buf); | 331 EXPECT_EQ(expected, buf); |
315 } | 332 } |
316 | 333 |
317 TEST_F(UploadFileElementReaderSyncTest, FileChanged) { | 334 TEST_F(UploadFileElementReaderSyncTest, FileChanged) { |
318 base::PlatformFileInfo info; | 335 base::PlatformFileInfo info; |
319 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_, &info)); | 336 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_, &info)); |
320 | 337 |
321 // Expect one second before the actual modification time to simulate change. | 338 // Expect one second before the actual modification time to simulate change. |
322 const base::Time expected_modification_time = | 339 const base::Time expected_modification_time = |
323 info.last_modified - base::TimeDelta::FromSeconds(1); | 340 info.last_modified - base::TimeDelta::FromSeconds(1); |
324 reader_.reset(new UploadFileElementReaderSync( | 341 reader_.reset(new UploadFileElementReaderSync( |
325 temp_file_path_, 0, kuint64max, expected_modification_time)); | 342 temp_file_path_, 0, kuint64max, expected_modification_time)); |
326 EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, reader_->Init(CompletionCallback())); | 343 EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, reader_->Init(CompletionCallback())); |
327 } | 344 } |
328 | 345 |
329 TEST_F(UploadFileElementReaderSyncTest, WrongPath) { | 346 TEST_F(UploadFileElementReaderSyncTest, WrongPath) { |
330 const base::FilePath wrong_path(FILE_PATH_LITERAL("wrong_path")); | 347 const base::FilePath wrong_path(FILE_PATH_LITERAL("wrong_path")); |
331 reader_.reset(new UploadFileElementReaderSync( | 348 reader_.reset(new UploadFileElementReaderSync( |
332 wrong_path, 0, kuint64max, base::Time())); | 349 wrong_path, 0, kuint64max, base::Time())); |
333 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); | 350 ASSERT_EQ(OK, reader_->Init(CompletionCallback())); |
334 EXPECT_EQ(0U, reader_->GetContentLength()); | 351 EXPECT_EQ(0U, reader_->GetContentLength()); |
335 EXPECT_EQ(0U, reader_->BytesRemaining()); | 352 EXPECT_EQ(0U, reader_->BytesRemaining()); |
336 } | 353 } |
337 | 354 |
338 } // namespace net | 355 } // namespace net |
OLD | NEW |