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

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

Issue 10878082: net: Move file operation code from UploadData to UploadDataStream (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 8 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 | Annotate | Revision Log
« no previous file with comments | « net/base/upload_data_stream.cc ('k') | net/base/upload_data_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
OLDNEW
« no previous file with comments | « net/base/upload_data_stream.cc ('k') | net/base/upload_data_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698