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
3 // found in the LICENSE file.
5 #include "net/base/upload_file_element_reader.h"
7 #include "base/file_util.h"
8 #include "base/files/scoped_temp_dir.h"
9 #include "base/message_loop/message_loop_proxy.h"
10 #include "net/base/io_buffer.h"
11 #include "net/base/net_errors.h"
12 #include "net/base/test_completion_callback.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14 #include "testing/platform_test.h"
18 class UploadFileElementReaderTest
: public PlatformTest
{
20 virtual void SetUp() OVERRIDE
{
21 // Some tests (*.ReadPartially) rely on bytes_.size() being even.
22 const char kData
[] = "123456789abcdefghi";
23 bytes_
.assign(kData
, kData
+ arraysize(kData
) - 1);
25 ASSERT_TRUE(temp_dir_
.CreateUniqueTempDir());
27 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_
.path(),
30 static_cast<int>(bytes_
.size()),
31 file_util::WriteFile(temp_file_path_
, &bytes_
[0], bytes_
.size()));
34 new UploadFileElementReader(base::MessageLoopProxy::current().get(),
39 TestCompletionCallback callback
;
40 ASSERT_EQ(ERR_IO_PENDING
, reader_
->Init(callback
.callback()));
41 EXPECT_EQ(OK
, callback
.WaitForResult());
42 EXPECT_EQ(bytes_
.size(), reader_
->GetContentLength());
43 EXPECT_EQ(bytes_
.size(), reader_
->BytesRemaining());
44 EXPECT_FALSE(reader_
->IsInMemory());
47 std::vector
<char> bytes_
;
48 scoped_ptr
<UploadElementReader
> reader_
;
49 base::ScopedTempDir temp_dir_
;
50 base::FilePath temp_file_path_
;
53 TEST_F(UploadFileElementReaderTest
, ReadPartially
) {
54 const size_t kHalfSize
= bytes_
.size() / 2;
55 ASSERT_EQ(bytes_
.size(), kHalfSize
* 2);
56 std::vector
<char> buf(kHalfSize
);
57 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
58 TestCompletionCallback read_callback1
;
59 ASSERT_EQ(ERR_IO_PENDING
,
61 wrapped_buffer
.get(), buf
.size(), read_callback1
.callback()));
62 EXPECT_EQ(static_cast<int>(buf
.size()), read_callback1
.WaitForResult());
63 EXPECT_EQ(bytes_
.size() - buf
.size(), reader_
->BytesRemaining());
64 EXPECT_EQ(std::vector
<char>(bytes_
.begin(), bytes_
.begin() + kHalfSize
), buf
);
66 TestCompletionCallback read_callback2
;
67 EXPECT_EQ(ERR_IO_PENDING
,
69 wrapped_buffer
.get(), buf
.size(), read_callback2
.callback()));
70 EXPECT_EQ(static_cast<int>(buf
.size()), read_callback2
.WaitForResult());
71 EXPECT_EQ(0U, reader_
->BytesRemaining());
72 EXPECT_EQ(std::vector
<char>(bytes_
.begin() + kHalfSize
, bytes_
.end()), buf
);
75 TEST_F(UploadFileElementReaderTest
, ReadAll
) {
76 std::vector
<char> buf(bytes_
.size());
77 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
78 TestCompletionCallback read_callback
;
79 ASSERT_EQ(ERR_IO_PENDING
,
81 wrapped_buffer
.get(), buf
.size(), read_callback
.callback()));
82 EXPECT_EQ(static_cast<int>(buf
.size()), read_callback
.WaitForResult());
83 EXPECT_EQ(0U, reader_
->BytesRemaining());
84 EXPECT_EQ(bytes_
, buf
);
88 wrapped_buffer
.get(), buf
.size(), read_callback
.callback()));
91 TEST_F(UploadFileElementReaderTest
, ReadTooMuch
) {
92 const size_t kTooLargeSize
= bytes_
.size() * 2;
93 std::vector
<char> buf(kTooLargeSize
);
94 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
95 TestCompletionCallback read_callback
;
96 ASSERT_EQ(ERR_IO_PENDING
,
98 wrapped_buffer
.get(), buf
.size(), read_callback
.callback()));
99 EXPECT_EQ(static_cast<int>(bytes_
.size()), read_callback
.WaitForResult());
100 EXPECT_EQ(0U, reader_
->BytesRemaining());
101 buf
.resize(bytes_
.size()); // Resize to compare.
102 EXPECT_EQ(bytes_
, buf
);
105 TEST_F(UploadFileElementReaderTest
, MultipleInit
) {
106 std::vector
<char> buf(bytes_
.size());
107 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
110 TestCompletionCallback read_callback1
;
111 ASSERT_EQ(ERR_IO_PENDING
,
113 wrapped_buffer
.get(), buf
.size(), read_callback1
.callback()));
114 EXPECT_EQ(static_cast<int>(buf
.size()), read_callback1
.WaitForResult());
115 EXPECT_EQ(0U, reader_
->BytesRemaining());
116 EXPECT_EQ(bytes_
, buf
);
118 // Call Init() again to reset the state.
119 TestCompletionCallback init_callback
;
120 ASSERT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback
.callback()));
121 EXPECT_EQ(OK
, init_callback
.WaitForResult());
122 EXPECT_EQ(bytes_
.size(), reader_
->GetContentLength());
123 EXPECT_EQ(bytes_
.size(), reader_
->BytesRemaining());
126 TestCompletionCallback read_callback2
;
127 ASSERT_EQ(ERR_IO_PENDING
,
129 wrapped_buffer
.get(), buf
.size(), read_callback2
.callback()));
130 EXPECT_EQ(static_cast<int>(buf
.size()), read_callback2
.WaitForResult());
131 EXPECT_EQ(0U, reader_
->BytesRemaining());
132 EXPECT_EQ(bytes_
, buf
);
135 TEST_F(UploadFileElementReaderTest
, InitDuringAsyncOperation
) {
136 std::vector
<char> buf(bytes_
.size());
137 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
139 // Start reading all.
140 TestCompletionCallback read_callback1
;
141 EXPECT_EQ(ERR_IO_PENDING
,
143 wrapped_buffer
.get(), buf
.size(), read_callback1
.callback()));
145 // Call Init to cancel the previous read.
146 TestCompletionCallback init_callback1
;
147 EXPECT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback1
.callback()));
149 // Call Init again to cancel the previous init.
150 TestCompletionCallback init_callback2
;
151 EXPECT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback2
.callback()));
152 EXPECT_EQ(OK
, init_callback2
.WaitForResult());
153 EXPECT_EQ(bytes_
.size(), reader_
->GetContentLength());
154 EXPECT_EQ(bytes_
.size(), reader_
->BytesRemaining());
157 std::vector
<char> buf2(bytes_
.size() / 2);
158 scoped_refptr
<IOBuffer
> wrapped_buffer2
= new WrappedIOBuffer(&buf2
[0]);
159 TestCompletionCallback read_callback2
;
160 EXPECT_EQ(ERR_IO_PENDING
,
162 wrapped_buffer2
.get(), buf2
.size(), read_callback2
.callback()));
163 EXPECT_EQ(static_cast<int>(buf2
.size()), read_callback2
.WaitForResult());
164 EXPECT_EQ(bytes_
.size() - buf2
.size(), reader_
->BytesRemaining());
165 EXPECT_EQ(std::vector
<char>(bytes_
.begin(), bytes_
.begin() + buf2
.size()),
168 // Make sure callbacks are not called for cancelled operations.
169 EXPECT_FALSE(read_callback1
.have_result());
170 EXPECT_FALSE(init_callback1
.have_result());
173 TEST_F(UploadFileElementReaderTest
, Range
) {
174 const uint64 kOffset
= 2;
175 const uint64 kLength
= bytes_
.size() - kOffset
* 3;
177 new UploadFileElementReader(base::MessageLoopProxy::current().get(),
182 TestCompletionCallback init_callback
;
183 ASSERT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback
.callback()));
184 EXPECT_EQ(OK
, init_callback
.WaitForResult());
185 EXPECT_EQ(kLength
, reader_
->GetContentLength());
186 EXPECT_EQ(kLength
, reader_
->BytesRemaining());
187 std::vector
<char> buf(kLength
);
188 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
189 TestCompletionCallback read_callback
;
192 reader_
->Read(wrapped_buffer
.get(), kLength
, read_callback
.callback()));
193 EXPECT_EQ(static_cast<int>(kLength
), read_callback
.WaitForResult());
194 const std::vector
<char> expected(bytes_
.begin() + kOffset
,
195 bytes_
.begin() + kOffset
+ kLength
);
196 EXPECT_EQ(expected
, buf
);
199 TEST_F(UploadFileElementReaderTest
, FileChanged
) {
200 base::PlatformFileInfo info
;
201 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_
, &info
));
203 // Expect one second before the actual modification time to simulate change.
204 const base::Time expected_modification_time
=
205 info
.last_modified
- base::TimeDelta::FromSeconds(1);
207 new UploadFileElementReader(base::MessageLoopProxy::current().get(),
211 expected_modification_time
));
212 TestCompletionCallback init_callback
;
213 ASSERT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback
.callback()));
214 EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED
, init_callback
.WaitForResult());
217 TEST_F(UploadFileElementReaderTest
, WrongPath
) {
218 const base::FilePath
wrong_path(FILE_PATH_LITERAL("wrong_path"));
220 new UploadFileElementReader(base::MessageLoopProxy::current().get(),
225 TestCompletionCallback init_callback
;
226 ASSERT_EQ(ERR_IO_PENDING
, reader_
->Init(init_callback
.callback()));
227 EXPECT_EQ(OK
, init_callback
.WaitForResult());
228 EXPECT_EQ(0U, reader_
->GetContentLength());
229 EXPECT_EQ(0U, reader_
->BytesRemaining());
233 class UploadFileElementReaderSyncTest
: public PlatformTest
{
235 virtual void SetUp() OVERRIDE
{
236 // Some tests (*.ReadPartially) rely on bytes_.size() being even.
237 const char kData
[] = "123456789abcdefghi";
238 bytes_
.assign(kData
, kData
+ arraysize(kData
) - 1);
240 ASSERT_TRUE(temp_dir_
.CreateUniqueTempDir());
242 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_
.path(),
245 static_cast<int>(bytes_
.size()),
246 file_util::WriteFile(temp_file_path_
, &bytes_
[0], bytes_
.size()));
248 reader_
.reset(new UploadFileElementReaderSync(
249 temp_file_path_
, 0, kuint64max
, base::Time()));
250 ASSERT_EQ(OK
, reader_
->Init(CompletionCallback()));
251 EXPECT_EQ(bytes_
.size(), reader_
->GetContentLength());
252 EXPECT_EQ(bytes_
.size(), reader_
->BytesRemaining());
253 EXPECT_FALSE(reader_
->IsInMemory());
256 std::vector
<char> bytes_
;
257 scoped_ptr
<UploadElementReader
> reader_
;
258 base::ScopedTempDir temp_dir_
;
259 base::FilePath temp_file_path_
;
262 TEST_F(UploadFileElementReaderSyncTest
, ReadPartially
) {
263 const size_t kHalfSize
= bytes_
.size() / 2;
264 ASSERT_EQ(bytes_
.size(), kHalfSize
* 2);
265 std::vector
<char> buf(kHalfSize
);
266 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
268 static_cast<int>(buf
.size()),
269 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
270 EXPECT_EQ(bytes_
.size() - buf
.size(), reader_
->BytesRemaining());
271 EXPECT_EQ(std::vector
<char>(bytes_
.begin(), bytes_
.begin() + kHalfSize
), buf
);
274 static_cast<int>(buf
.size()),
275 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
276 EXPECT_EQ(0U, reader_
->BytesRemaining());
277 EXPECT_EQ(std::vector
<char>(bytes_
.begin() + kHalfSize
, bytes_
.end()), buf
);
280 TEST_F(UploadFileElementReaderSyncTest
, ReadAll
) {
281 std::vector
<char> buf(bytes_
.size());
282 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
284 static_cast<int>(buf
.size()),
285 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
286 EXPECT_EQ(0U, reader_
->BytesRemaining());
287 EXPECT_EQ(bytes_
, buf
);
288 // Try to read again.
290 0, reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
293 TEST_F(UploadFileElementReaderSyncTest
, ReadTooMuch
) {
294 const size_t kTooLargeSize
= bytes_
.size() * 2;
295 std::vector
<char> buf(kTooLargeSize
);
296 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
298 static_cast<int>(bytes_
.size()),
299 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
300 EXPECT_EQ(0U, reader_
->BytesRemaining());
301 buf
.resize(bytes_
.size()); // Resize to compare.
302 EXPECT_EQ(bytes_
, buf
);
305 TEST_F(UploadFileElementReaderSyncTest
, MultipleInit
) {
306 std::vector
<char> buf(bytes_
.size());
307 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
311 static_cast<int>(buf
.size()),
312 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
313 EXPECT_EQ(0U, reader_
->BytesRemaining());
314 EXPECT_EQ(bytes_
, buf
);
316 // Call Init() again to reset the state.
317 ASSERT_EQ(OK
, reader_
->Init(CompletionCallback()));
318 EXPECT_EQ(bytes_
.size(), reader_
->GetContentLength());
319 EXPECT_EQ(bytes_
.size(), reader_
->BytesRemaining());
323 static_cast<int>(buf
.size()),
324 reader_
->Read(wrapped_buffer
.get(), buf
.size(), CompletionCallback()));
325 EXPECT_EQ(0U, reader_
->BytesRemaining());
326 EXPECT_EQ(bytes_
, buf
);
329 TEST_F(UploadFileElementReaderSyncTest
, Range
) {
330 const uint64 kOffset
= 2;
331 const uint64 kLength
= bytes_
.size() - kOffset
* 3;
332 reader_
.reset(new UploadFileElementReaderSync(
333 temp_file_path_
, kOffset
, kLength
, base::Time()));
334 ASSERT_EQ(OK
, reader_
->Init(CompletionCallback()));
335 EXPECT_EQ(kLength
, reader_
->GetContentLength());
336 EXPECT_EQ(kLength
, reader_
->BytesRemaining());
337 std::vector
<char> buf(kLength
);
338 scoped_refptr
<IOBuffer
> wrapped_buffer
= new WrappedIOBuffer(&buf
[0]);
339 EXPECT_EQ(static_cast<int>(kLength
),
340 reader_
->Read(wrapped_buffer
.get(), kLength
, CompletionCallback()));
341 const std::vector
<char> expected(bytes_
.begin() + kOffset
,
342 bytes_
.begin() + kOffset
+ kLength
);
343 EXPECT_EQ(expected
, buf
);
346 TEST_F(UploadFileElementReaderSyncTest
, FileChanged
) {
347 base::PlatformFileInfo info
;
348 ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_
, &info
));
350 // Expect one second before the actual modification time to simulate change.
351 const base::Time expected_modification_time
=
352 info
.last_modified
- base::TimeDelta::FromSeconds(1);
353 reader_
.reset(new UploadFileElementReaderSync(
354 temp_file_path_
, 0, kuint64max
, expected_modification_time
));
355 EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED
, reader_
->Init(CompletionCallback()));
358 TEST_F(UploadFileElementReaderSyncTest
, WrongPath
) {
359 const base::FilePath
wrong_path(FILE_PATH_LITERAL("wrong_path"));
360 reader_
.reset(new UploadFileElementReaderSync(
361 wrong_path
, 0, kuint64max
, base::Time()));
362 ASSERT_EQ(OK
, reader_
->Init(CompletionCallback()));
363 EXPECT_EQ(0U, reader_
->GetContentLength());
364 EXPECT_EQ(0U, reader_
->BytesRemaining());