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_data_stream.h" | 5 #include "net/base/upload_data_stream.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/basictypes.h" | 9 #include "base/basictypes.h" |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 const base::Time& time, | 48 const base::Time& time, |
49 bool error_expected); | 49 bool error_expected); |
50 | 50 |
51 scoped_refptr<UploadData> upload_data_; | 51 scoped_refptr<UploadData> upload_data_; |
52 }; | 52 }; |
53 | 53 |
54 TEST_F(UploadDataStreamTest, EmptyUploadData) { | 54 TEST_F(UploadDataStreamTest, EmptyUploadData) { |
55 upload_data_->AppendBytes("", 0); | 55 upload_data_->AppendBytes("", 0); |
56 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); | 56 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
57 ASSERT_EQ(OK, stream->Init()); | 57 ASSERT_EQ(OK, stream->Init()); |
| 58 EXPECT_TRUE(stream->IsInMemory()); |
58 ASSERT_TRUE(stream.get()); | 59 ASSERT_TRUE(stream.get()); |
59 EXPECT_EQ(0U, stream->size()); | 60 EXPECT_EQ(0U, stream->size()); |
60 EXPECT_EQ(0U, stream->position()); | 61 EXPECT_EQ(0U, stream->position()); |
61 EXPECT_TRUE(stream->IsEOF()); | 62 EXPECT_TRUE(stream->IsEOF()); |
62 } | 63 } |
63 | 64 |
64 TEST_F(UploadDataStreamTest, ConsumeAll) { | 65 TEST_F(UploadDataStreamTest, ConsumeAllBytes) { |
65 upload_data_->AppendBytes(kTestData, kTestDataSize); | 66 upload_data_->AppendBytes(kTestData, kTestDataSize); |
66 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); | 67 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
67 ASSERT_EQ(OK, stream->Init()); | 68 ASSERT_EQ(OK, stream->Init()); |
| 69 EXPECT_TRUE(stream->IsInMemory()); |
68 ASSERT_TRUE(stream.get()); | 70 ASSERT_TRUE(stream.get()); |
69 EXPECT_EQ(kTestDataSize, stream->size()); | 71 EXPECT_EQ(kTestDataSize, stream->size()); |
70 EXPECT_EQ(0U, stream->position()); | 72 EXPECT_EQ(0U, stream->position()); |
71 EXPECT_FALSE(stream->IsEOF()); | 73 EXPECT_FALSE(stream->IsEOF()); |
72 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 74 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
73 while (!stream->IsEOF()) { | 75 while (!stream->IsEOF()) { |
74 int bytes_read = stream->Read(buf, kTestBufferSize); | 76 int bytes_read = stream->Read(buf, kTestBufferSize); |
75 ASSERT_LE(0, bytes_read); // Not an error. | 77 ASSERT_LE(0, bytes_read); // Not an error. |
76 } | 78 } |
77 EXPECT_EQ(kTestDataSize, stream->position()); | 79 EXPECT_EQ(kTestDataSize, stream->position()); |
78 ASSERT_TRUE(stream->IsEOF()); | 80 ASSERT_TRUE(stream->IsEOF()); |
79 } | 81 } |
80 | 82 |
| 83 TEST_F(UploadDataStreamTest, File) { |
| 84 FilePath temp_file_path; |
| 85 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); |
| 86 ASSERT_EQ(static_cast<int>(kTestDataSize), |
| 87 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
| 88 |
| 89 std::vector<UploadElement> elements; |
| 90 UploadElement element; |
| 91 element.SetToFilePath(temp_file_path); |
| 92 elements.push_back(element); |
| 93 upload_data_->SetElements(elements); |
| 94 |
| 95 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
| 96 ASSERT_EQ(OK, stream->Init()); |
| 97 EXPECT_FALSE(stream->IsInMemory()); |
| 98 ASSERT_TRUE(stream.get()); |
| 99 EXPECT_EQ(kTestDataSize, stream->size()); |
| 100 EXPECT_EQ(0U, stream->position()); |
| 101 EXPECT_FALSE(stream->IsEOF()); |
| 102 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
| 103 while (!stream->IsEOF()) { |
| 104 int bytes_read = stream->Read(buf, kTestBufferSize); |
| 105 ASSERT_LE(0, bytes_read); // Not an error. |
| 106 } |
| 107 EXPECT_EQ(kTestDataSize, stream->position()); |
| 108 ASSERT_TRUE(stream->IsEOF()); |
| 109 file_util::Delete(temp_file_path, false); |
| 110 } |
| 111 |
81 TEST_F(UploadDataStreamTest, FileSmallerThanLength) { | 112 TEST_F(UploadDataStreamTest, FileSmallerThanLength) { |
82 FilePath temp_file_path; | 113 FilePath temp_file_path; |
83 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); | 114 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); |
84 ASSERT_EQ(static_cast<int>(kTestDataSize), | 115 ASSERT_EQ(static_cast<int>(kTestDataSize), |
85 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); | 116 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
86 const uint64 kFakeSize = kTestDataSize*2; | 117 const uint64 kFakeSize = kTestDataSize*2; |
87 | 118 |
88 std::vector<UploadElement> elements; | 119 std::vector<UploadElement> elements; |
89 UploadElement element; | 120 UploadElement element; |
90 element.SetToFilePath(temp_file_path); | 121 element.SetToFilePath(temp_file_path); |
91 element.SetContentLength(kFakeSize); | 122 element.SetContentLength(kFakeSize); |
92 elements.push_back(element); | 123 elements.push_back(element); |
93 upload_data_->SetElements(elements); | 124 upload_data_->SetElements(elements); |
94 EXPECT_EQ(kFakeSize, upload_data_->GetContentLengthSync()); | |
95 | 125 |
96 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); | 126 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
97 ASSERT_EQ(OK, stream->Init()); | 127 ASSERT_EQ(OK, stream->Init()); |
| 128 EXPECT_FALSE(stream->IsInMemory()); |
98 ASSERT_TRUE(stream.get()); | 129 ASSERT_TRUE(stream.get()); |
99 EXPECT_EQ(kFakeSize, stream->size()); | 130 EXPECT_EQ(kFakeSize, stream->size()); |
100 EXPECT_EQ(0U, stream->position()); | 131 EXPECT_EQ(0U, stream->position()); |
101 EXPECT_FALSE(stream->IsEOF()); | 132 EXPECT_FALSE(stream->IsEOF()); |
102 uint64 read_counter = 0; | 133 uint64 read_counter = 0; |
103 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 134 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
104 while (!stream->IsEOF()) { | 135 while (!stream->IsEOF()) { |
105 int bytes_read = stream->Read(buf, kTestBufferSize); | 136 int bytes_read = stream->Read(buf, kTestBufferSize); |
106 ASSERT_LE(0, bytes_read); // Not an error. | 137 ASSERT_LE(0, bytes_read); // Not an error. |
107 read_counter += bytes_read; | 138 read_counter += bytes_read; |
108 EXPECT_EQ(read_counter, stream->position()); | 139 EXPECT_EQ(read_counter, stream->position()); |
109 } | 140 } |
110 // UpdateDataStream will pad out the file with 0 bytes so that the HTTP | 141 // UpdateDataStream will pad out the file with 0 bytes so that the HTTP |
111 // transaction doesn't hang. Therefore we expected the full size. | 142 // transaction doesn't hang. Therefore we expected the full size. |
112 EXPECT_EQ(kFakeSize, read_counter); | 143 EXPECT_EQ(kFakeSize, read_counter); |
113 EXPECT_EQ(read_counter, stream->position()); | 144 EXPECT_EQ(read_counter, stream->position()); |
114 | 145 |
115 file_util::Delete(temp_file_path, false); | 146 file_util::Delete(temp_file_path, false); |
116 } | 147 } |
117 | 148 |
| 149 TEST_F(UploadDataStreamTest, FileAndBytes) { |
| 150 FilePath temp_file_path; |
| 151 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); |
| 152 ASSERT_EQ(static_cast<int>(kTestDataSize), |
| 153 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
| 154 |
| 155 const uint64 kFileRangeOffset = 1; |
| 156 const uint64 kFileRangeLength = 4; |
| 157 upload_data_->AppendFileRange( |
| 158 temp_file_path, kFileRangeOffset, kFileRangeLength, base::Time()); |
| 159 |
| 160 upload_data_->AppendBytes(kTestData, kTestDataSize); |
| 161 |
| 162 const uint64 kStreamSize = kTestDataSize + kFileRangeLength; |
| 163 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
| 164 ASSERT_EQ(OK, stream->Init()); |
| 165 EXPECT_FALSE(stream->IsInMemory()); |
| 166 ASSERT_TRUE(stream.get()); |
| 167 EXPECT_EQ(kStreamSize, stream->size()); |
| 168 EXPECT_EQ(0U, stream->position()); |
| 169 EXPECT_FALSE(stream->IsEOF()); |
| 170 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
| 171 while (!stream->IsEOF()) { |
| 172 int bytes_read = stream->Read(buf, kTestBufferSize); |
| 173 ASSERT_LE(0, bytes_read); // Not an error. |
| 174 } |
| 175 EXPECT_EQ(kStreamSize, stream->position()); |
| 176 ASSERT_TRUE(stream->IsEOF()); |
| 177 |
| 178 file_util::Delete(temp_file_path, false); |
| 179 } |
| 180 |
| 181 TEST_F(UploadDataStreamTest, Chunk) { |
| 182 upload_data_->set_is_chunked(true); |
| 183 upload_data_->AppendChunk(kTestData, kTestDataSize, false); |
| 184 upload_data_->AppendChunk(kTestData, kTestDataSize, true); |
| 185 |
| 186 const uint64 kStreamSize = kTestDataSize*2; |
| 187 scoped_ptr<UploadDataStream> stream(new UploadDataStream(upload_data_)); |
| 188 ASSERT_EQ(OK, stream->Init()); |
| 189 EXPECT_FALSE(stream->IsInMemory()); |
| 190 ASSERT_TRUE(stream.get()); |
| 191 EXPECT_EQ(0U, stream->size()); // Content-Length is 0 for chunked data. |
| 192 EXPECT_EQ(0U, stream->position()); |
| 193 EXPECT_FALSE(stream->IsEOF()); |
| 194 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
| 195 while (!stream->IsEOF()) { |
| 196 int bytes_read = stream->Read(buf, kTestBufferSize); |
| 197 ASSERT_LE(0, bytes_read); // Not an error. |
| 198 } |
| 199 EXPECT_EQ(kStreamSize, stream->position()); |
| 200 ASSERT_TRUE(stream->IsEOF()); |
| 201 } |
| 202 |
118 void UploadDataStreamTest::FileChangedHelper(const FilePath& file_path, | 203 void UploadDataStreamTest::FileChangedHelper(const FilePath& file_path, |
119 const base::Time& time, | 204 const base::Time& time, |
120 bool error_expected) { | 205 bool error_expected) { |
121 std::vector<UploadElement> elements; | 206 std::vector<UploadElement> elements; |
122 UploadElement element; | 207 UploadElement element; |
123 element.SetToFilePathRange(file_path, 1, 2, time); | 208 element.SetToFilePathRange(file_path, 1, 2, time); |
124 elements.push_back(element); | 209 elements.push_back(element); |
125 // Don't use upload_data_ here, as this function is called twice, and | 210 // Don't use upload_data_ here, as this function is called twice, and |
126 // reusing upload_data_ is wrong. | 211 // reusing upload_data_ is wrong. |
127 scoped_refptr<UploadData> upload_data(new UploadData); | 212 scoped_refptr<UploadData> upload_data(new UploadData); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); | 245 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path)); |
161 ASSERT_EQ(static_cast<int>(kTestDataSize), | 246 ASSERT_EQ(static_cast<int>(kTestDataSize), |
162 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); | 247 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
163 | 248 |
164 // Prepare |upload_data_| that contains a file. | 249 // Prepare |upload_data_| that contains a file. |
165 std::vector<UploadElement> elements; | 250 std::vector<UploadElement> elements; |
166 UploadElement element; | 251 UploadElement element; |
167 element.SetToFilePath(temp_file_path); | 252 element.SetToFilePath(temp_file_path); |
168 elements.push_back(element); | 253 elements.push_back(element); |
169 upload_data_->SetElements(elements); | 254 upload_data_->SetElements(elements); |
170 EXPECT_EQ(kTestDataSize, upload_data_->GetContentLengthSync()); | |
171 | 255 |
172 // Confirm that the file is read properly. | 256 // Confirm that the file is read properly. |
173 { | 257 { |
174 UploadDataStream stream(upload_data_); | 258 UploadDataStream stream(upload_data_); |
175 ASSERT_EQ(OK, stream.Init()); | 259 ASSERT_EQ(OK, stream.Init()); |
| 260 EXPECT_EQ(kTestDataSize, stream.size()); |
176 EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream)); | 261 EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream)); |
177 } | 262 } |
178 | 263 |
179 // Reuse |upload_data_| for another UploadDataStream, and confirm that the | 264 // Reuse |upload_data_| for another UploadDataStream, and confirm that the |
180 // file is read properly. | 265 // file is read properly. |
181 { | 266 { |
182 UploadDataStream stream(upload_data_); | 267 UploadDataStream stream(upload_data_); |
183 ASSERT_EQ(OK, stream.Init()); | 268 ASSERT_EQ(OK, stream.Init()); |
| 269 EXPECT_EQ(kTestDataSize, stream.size()); |
184 EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream)); | 270 EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream)); |
185 } | 271 } |
186 | 272 |
187 file_util::Delete(temp_file_path, false); | 273 file_util::Delete(temp_file_path, false); |
188 } | 274 } |
189 | 275 |
190 } // namespace net | 276 } // namespace net |
OLD | NEW |