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

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

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 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
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/elements_upload_data_stream.h" 5 #include "net/base/elements_upload_data_stream.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 8
9 #include <algorithm> 9 #include <algorithm>
10 #include <limits> 10 #include <limits>
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after
147 const base::Time& time, 147 const base::Time& time,
148 bool error_expected); 148 bool error_expected);
149 149
150 base::ScopedTempDir temp_dir_; 150 base::ScopedTempDir temp_dir_;
151 std::vector<std::unique_ptr<UploadElementReader>> element_readers_; 151 std::vector<std::unique_ptr<UploadElementReader>> element_readers_;
152 }; 152 };
153 153
154 TEST_F(ElementsUploadDataStreamTest, EmptyUploadData) { 154 TEST_F(ElementsUploadDataStreamTest, EmptyUploadData) {
155 std::unique_ptr<UploadDataStream> stream( 155 std::unique_ptr<UploadDataStream> stream(
156 new ElementsUploadDataStream(std::move(element_readers_), 0)); 156 new ElementsUploadDataStream(std::move(element_readers_), 0));
157 ASSERT_THAT(stream->Init(CompletionCallback(), BoundNetLog()), IsOk()); 157 ASSERT_THAT(stream->Init(CompletionCallback(), NetLogWithSource()), IsOk());
158 EXPECT_TRUE(stream->IsInMemory()); 158 EXPECT_TRUE(stream->IsInMemory());
159 EXPECT_EQ(0U, stream->size()); 159 EXPECT_EQ(0U, stream->size());
160 EXPECT_EQ(0U, stream->position()); 160 EXPECT_EQ(0U, stream->position());
161 EXPECT_TRUE(stream->IsEOF()); 161 EXPECT_TRUE(stream->IsEOF());
162 } 162 }
163 163
164 TEST_F(ElementsUploadDataStreamTest, ConsumeAllBytes) { 164 TEST_F(ElementsUploadDataStreamTest, ConsumeAllBytes) {
165 element_readers_.push_back( 165 element_readers_.push_back(
166 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize)); 166 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
167 std::unique_ptr<UploadDataStream> stream( 167 std::unique_ptr<UploadDataStream> stream(
168 new ElementsUploadDataStream(std::move(element_readers_), 0)); 168 new ElementsUploadDataStream(std::move(element_readers_), 0));
169 ASSERT_THAT(stream->Init(CompletionCallback(), BoundNetLog()), IsOk()); 169 ASSERT_THAT(stream->Init(CompletionCallback(), NetLogWithSource()), IsOk());
170 EXPECT_TRUE(stream->IsInMemory()); 170 EXPECT_TRUE(stream->IsInMemory());
171 EXPECT_EQ(kTestDataSize, stream->size()); 171 EXPECT_EQ(kTestDataSize, stream->size());
172 EXPECT_EQ(0U, stream->position()); 172 EXPECT_EQ(0U, stream->position());
173 EXPECT_FALSE(stream->IsEOF()); 173 EXPECT_FALSE(stream->IsEOF());
174 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 174 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
175 while (!stream->IsEOF()) { 175 while (!stream->IsEOF()) {
176 int bytes_read = 176 int bytes_read =
177 stream->Read(buf.get(), kTestBufferSize, CompletionCallback()); 177 stream->Read(buf.get(), kTestBufferSize, CompletionCallback());
178 ASSERT_LE(0, bytes_read); // Not an error. 178 ASSERT_LE(0, bytes_read); // Not an error.
179 } 179 }
180 EXPECT_EQ(kTestDataSize, stream->position()); 180 EXPECT_EQ(kTestDataSize, stream->position());
181 ASSERT_TRUE(stream->IsEOF()); 181 ASSERT_TRUE(stream->IsEOF());
182 } 182 }
183 183
184 TEST_F(ElementsUploadDataStreamTest, File) { 184 TEST_F(ElementsUploadDataStreamTest, File) {
185 base::FilePath temp_file_path; 185 base::FilePath temp_file_path;
186 ASSERT_TRUE( 186 ASSERT_TRUE(
187 base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &temp_file_path)); 187 base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &temp_file_path));
188 ASSERT_EQ(static_cast<int>(kTestDataSize), 188 ASSERT_EQ(static_cast<int>(kTestDataSize),
189 base::WriteFile(temp_file_path, kTestData, kTestDataSize)); 189 base::WriteFile(temp_file_path, kTestData, kTestDataSize));
190 190
191 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>( 191 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
192 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, 192 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
193 std::numeric_limits<uint64_t>::max(), base::Time())); 193 std::numeric_limits<uint64_t>::max(), base::Time()));
194 194
195 TestCompletionCallback init_callback; 195 TestCompletionCallback init_callback;
196 std::unique_ptr<UploadDataStream> stream( 196 std::unique_ptr<UploadDataStream> stream(
197 new ElementsUploadDataStream(std::move(element_readers_), 0)); 197 new ElementsUploadDataStream(std::move(element_readers_), 0));
198 ASSERT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 198 ASSERT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
199 IsError(ERR_IO_PENDING)); 199 IsError(ERR_IO_PENDING));
200 ASSERT_THAT(init_callback.WaitForResult(), IsOk()); 200 ASSERT_THAT(init_callback.WaitForResult(), IsOk());
201 EXPECT_FALSE(stream->IsInMemory()); 201 EXPECT_FALSE(stream->IsInMemory());
202 EXPECT_EQ(kTestDataSize, stream->size()); 202 EXPECT_EQ(kTestDataSize, stream->size());
203 EXPECT_EQ(0U, stream->position()); 203 EXPECT_EQ(0U, stream->position());
204 EXPECT_FALSE(stream->IsEOF()); 204 EXPECT_FALSE(stream->IsEOF());
205 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 205 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
206 while (!stream->IsEOF()) { 206 while (!stream->IsEOF()) {
207 TestCompletionCallback read_callback; 207 TestCompletionCallback read_callback;
208 ASSERT_EQ( 208 ASSERT_EQ(
(...skipping 16 matching lines...) Expand all
225 UploadFileElementReader::ScopedOverridingContentLengthForTests 225 UploadFileElementReader::ScopedOverridingContentLengthForTests
226 overriding_content_length(kFakeSize); 226 overriding_content_length(kFakeSize);
227 227
228 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>( 228 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
229 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, 229 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
230 std::numeric_limits<uint64_t>::max(), base::Time())); 230 std::numeric_limits<uint64_t>::max(), base::Time()));
231 231
232 TestCompletionCallback init_callback; 232 TestCompletionCallback init_callback;
233 std::unique_ptr<UploadDataStream> stream( 233 std::unique_ptr<UploadDataStream> stream(
234 new ElementsUploadDataStream(std::move(element_readers_), 0)); 234 new ElementsUploadDataStream(std::move(element_readers_), 0));
235 ASSERT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 235 ASSERT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
236 IsError(ERR_IO_PENDING)); 236 IsError(ERR_IO_PENDING));
237 ASSERT_THAT(init_callback.WaitForResult(), IsOk()); 237 ASSERT_THAT(init_callback.WaitForResult(), IsOk());
238 EXPECT_FALSE(stream->IsInMemory()); 238 EXPECT_FALSE(stream->IsInMemory());
239 EXPECT_EQ(kFakeSize, stream->size()); 239 EXPECT_EQ(kFakeSize, stream->size());
240 EXPECT_EQ(0U, stream->position()); 240 EXPECT_EQ(0U, stream->position());
241 241
242 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 242 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
243 EXPECT_FALSE(stream->IsEOF()); 243 EXPECT_FALSE(stream->IsEOF());
244 244
245 TestCompletionCallback read_callback; 245 TestCompletionCallback read_callback;
(...skipping 21 matching lines...) Expand all
267 element_readers_.push_back(std::move(reader)); 267 element_readers_.push_back(std::move(reader));
268 268
269 // This element is ignored because of the error from the previous reader. 269 // This element is ignored because of the error from the previous reader.
270 element_readers_.push_back( 270 element_readers_.push_back(
271 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize)); 271 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
272 272
273 std::unique_ptr<UploadDataStream> stream( 273 std::unique_ptr<UploadDataStream> stream(
274 new ElementsUploadDataStream(std::move(element_readers_), 0)); 274 new ElementsUploadDataStream(std::move(element_readers_), 0));
275 275
276 // Run Init(). 276 // Run Init().
277 ASSERT_THAT(stream->Init(CompletionCallback(), BoundNetLog()), IsOk()); 277 ASSERT_THAT(stream->Init(CompletionCallback(), NetLogWithSource()), IsOk());
278 EXPECT_EQ(kTestDataSize*2, stream->size()); 278 EXPECT_EQ(kTestDataSize*2, stream->size());
279 EXPECT_EQ(0U, stream->position()); 279 EXPECT_EQ(0U, stream->position());
280 EXPECT_FALSE(stream->IsEOF()); 280 EXPECT_FALSE(stream->IsEOF());
281 281
282 // Prepare a buffer filled with non-zero data. 282 // Prepare a buffer filled with non-zero data.
283 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 283 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
284 std::fill_n(buf->data(), kTestBufferSize, -1); 284 std::fill_n(buf->data(), kTestBufferSize, -1);
285 285
286 // Read() results in success even when the reader returns error. 286 // Read() results in success even when the reader returns error.
287 EXPECT_EQ(ERR_FAILED, 287 EXPECT_EQ(ERR_FAILED,
(...skipping 15 matching lines...) Expand all
303 303
304 // This element is ignored because of the error from the previous reader. 304 // This element is ignored because of the error from the previous reader.
305 element_readers_.push_back( 305 element_readers_.push_back(
306 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize)); 306 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
307 307
308 std::unique_ptr<UploadDataStream> stream( 308 std::unique_ptr<UploadDataStream> stream(
309 new ElementsUploadDataStream(std::move(element_readers_), 0)); 309 new ElementsUploadDataStream(std::move(element_readers_), 0));
310 310
311 // Run Init(). 311 // Run Init().
312 TestCompletionCallback init_callback; 312 TestCompletionCallback init_callback;
313 ASSERT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 313 ASSERT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
314 IsError(ERR_IO_PENDING)); 314 IsError(ERR_IO_PENDING));
315 EXPECT_THAT(init_callback.WaitForResult(), IsOk()); 315 EXPECT_THAT(init_callback.WaitForResult(), IsOk());
316 EXPECT_EQ(kTestDataSize*2, stream->size()); 316 EXPECT_EQ(kTestDataSize*2, stream->size());
317 EXPECT_EQ(0U, stream->position()); 317 EXPECT_EQ(0U, stream->position());
318 EXPECT_FALSE(stream->IsEOF()); 318 EXPECT_FALSE(stream->IsEOF());
319 319
320 // Prepare a buffer filled with non-zero data. 320 // Prepare a buffer filled with non-zero data.
321 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 321 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
322 std::fill_n(buf->data(), kTestBufferSize, -1); 322 std::fill_n(buf->data(), kTestBufferSize, -1);
323 323
(...skipping 22 matching lines...) Expand all
346 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 346 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path,
347 kFileRangeOffset, kFileRangeLength, base::Time())); 347 kFileRangeOffset, kFileRangeLength, base::Time()));
348 348
349 element_readers_.push_back( 349 element_readers_.push_back(
350 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize)); 350 base::MakeUnique<UploadBytesElementReader>(kTestData, kTestDataSize));
351 351
352 const uint64_t kStreamSize = kTestDataSize + kFileRangeLength; 352 const uint64_t kStreamSize = kTestDataSize + kFileRangeLength;
353 TestCompletionCallback init_callback; 353 TestCompletionCallback init_callback;
354 std::unique_ptr<UploadDataStream> stream( 354 std::unique_ptr<UploadDataStream> stream(
355 new ElementsUploadDataStream(std::move(element_readers_), 0)); 355 new ElementsUploadDataStream(std::move(element_readers_), 0));
356 ASSERT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 356 ASSERT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
357 IsError(ERR_IO_PENDING)); 357 IsError(ERR_IO_PENDING));
358 ASSERT_THAT(init_callback.WaitForResult(), IsOk()); 358 ASSERT_THAT(init_callback.WaitForResult(), IsOk());
359 EXPECT_FALSE(stream->IsInMemory()); 359 EXPECT_FALSE(stream->IsInMemory());
360 EXPECT_EQ(kStreamSize, stream->size()); 360 EXPECT_EQ(kStreamSize, stream->size());
361 EXPECT_EQ(0U, stream->position()); 361 EXPECT_EQ(0U, stream->position());
362 EXPECT_FALSE(stream->IsEOF()); 362 EXPECT_FALSE(stream->IsEOF());
363 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 363 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
364 while (!stream->IsEOF()) { 364 while (!stream->IsEOF()) {
365 TestCompletionCallback read_callback; 365 TestCompletionCallback read_callback;
366 const int result = 366 const int result =
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
399 std::unique_ptr<MockUploadElementReader> reader5( 399 std::unique_ptr<MockUploadElementReader> reader5(
400 new MockUploadElementReader(kTestDataSize, true)); 400 new MockUploadElementReader(kTestDataSize, true));
401 EXPECT_CALL(*reader5, Init(_)).WillOnce(Return(OK)); 401 EXPECT_CALL(*reader5, Init(_)).WillOnce(Return(OK));
402 element_readers_.push_back(std::move(reader5)); 402 element_readers_.push_back(std::move(reader5));
403 403
404 std::unique_ptr<UploadDataStream> stream( 404 std::unique_ptr<UploadDataStream> stream(
405 new ElementsUploadDataStream(std::move(element_readers_), 0)); 405 new ElementsUploadDataStream(std::move(element_readers_), 0));
406 406
407 // Run Init(). 407 // Run Init().
408 TestCompletionCallback callback; 408 TestCompletionCallback callback;
409 ASSERT_THAT(stream->Init(callback.callback(), BoundNetLog()), 409 ASSERT_THAT(stream->Init(callback.callback(), NetLogWithSource()),
410 IsError(ERR_IO_PENDING)); 410 IsError(ERR_IO_PENDING));
411 EXPECT_THAT(callback.WaitForResult(), IsOk()); 411 EXPECT_THAT(callback.WaitForResult(), IsOk());
412 } 412 }
413 413
414 // Init() of a reader fails asynchronously. 414 // Init() of a reader fails asynchronously.
415 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureAsync) { 415 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureAsync) {
416 // Create UploadDataStream with a mock reader. 416 // Create UploadDataStream with a mock reader.
417 std::unique_ptr<MockUploadElementReader> reader( 417 std::unique_ptr<MockUploadElementReader> reader(
418 new MockUploadElementReader(kTestDataSize, false)); 418 new MockUploadElementReader(kTestDataSize, false));
419 reader->SetAsyncInitExpectation(ERR_FAILED); 419 reader->SetAsyncInitExpectation(ERR_FAILED);
420 element_readers_.push_back(std::move(reader)); 420 element_readers_.push_back(std::move(reader));
421 421
422 std::unique_ptr<UploadDataStream> stream( 422 std::unique_ptr<UploadDataStream> stream(
423 new ElementsUploadDataStream(std::move(element_readers_), 0)); 423 new ElementsUploadDataStream(std::move(element_readers_), 0));
424 424
425 // Run Init(). 425 // Run Init().
426 TestCompletionCallback callback; 426 TestCompletionCallback callback;
427 ASSERT_THAT(stream->Init(callback.callback(), BoundNetLog()), 427 ASSERT_THAT(stream->Init(callback.callback(), NetLogWithSource()),
428 IsError(ERR_IO_PENDING)); 428 IsError(ERR_IO_PENDING));
429 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED)); 429 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED));
430 } 430 }
431 431
432 // Init() of a reader fails synchronously. 432 // Init() of a reader fails synchronously.
433 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureSync) { 433 TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureSync) {
434 // Create UploadDataStream with mock readers. 434 // Create UploadDataStream with mock readers.
435 std::unique_ptr<MockUploadElementReader> reader( 435 std::unique_ptr<MockUploadElementReader> reader(
436 new MockUploadElementReader(kTestDataSize, false)); 436 new MockUploadElementReader(kTestDataSize, false));
437 reader->SetAsyncInitExpectation(OK); 437 reader->SetAsyncInitExpectation(OK);
438 element_readers_.push_back(std::move(reader)); 438 element_readers_.push_back(std::move(reader));
439 439
440 std::unique_ptr<MockUploadElementReader> reader2( 440 std::unique_ptr<MockUploadElementReader> reader2(
441 new MockUploadElementReader(kTestDataSize, true)); 441 new MockUploadElementReader(kTestDataSize, true));
442 EXPECT_CALL(*reader2, Init(_)).WillOnce(Return(ERR_FAILED)); 442 EXPECT_CALL(*reader2, Init(_)).WillOnce(Return(ERR_FAILED));
443 element_readers_.push_back(std::move(reader2)); 443 element_readers_.push_back(std::move(reader2));
444 444
445 std::unique_ptr<UploadDataStream> stream( 445 std::unique_ptr<UploadDataStream> stream(
446 new ElementsUploadDataStream(std::move(element_readers_), 0)); 446 new ElementsUploadDataStream(std::move(element_readers_), 0));
447 447
448 // Run Init(). 448 // Run Init().
449 TestCompletionCallback callback; 449 TestCompletionCallback callback;
450 ASSERT_THAT(stream->Init(callback.callback(), BoundNetLog()), 450 ASSERT_THAT(stream->Init(callback.callback(), NetLogWithSource()),
451 IsError(ERR_IO_PENDING)); 451 IsError(ERR_IO_PENDING));
452 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED)); 452 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED));
453 } 453 }
454 454
455 // Read with a buffer whose size is same as the data. 455 // Read with a buffer whose size is same as the data.
456 TEST_F(ElementsUploadDataStreamTest, ReadAsyncWithExactSizeBuffer) { 456 TEST_F(ElementsUploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
457 element_readers_.push_back( 457 element_readers_.push_back(
458 base::WrapUnique(new UploadBytesElementReader(kTestData, kTestDataSize))); 458 base::WrapUnique(new UploadBytesElementReader(kTestData, kTestDataSize)));
459 std::unique_ptr<UploadDataStream> stream( 459 std::unique_ptr<UploadDataStream> stream(
460 new ElementsUploadDataStream(std::move(element_readers_), 0)); 460 new ElementsUploadDataStream(std::move(element_readers_), 0));
461 461
462 ASSERT_THAT(stream->Init(CompletionCallback(), BoundNetLog()), IsOk()); 462 ASSERT_THAT(stream->Init(CompletionCallback(), NetLogWithSource()), IsOk());
463 EXPECT_TRUE(stream->IsInMemory()); 463 EXPECT_TRUE(stream->IsInMemory());
464 EXPECT_EQ(kTestDataSize, stream->size()); 464 EXPECT_EQ(kTestDataSize, stream->size());
465 EXPECT_EQ(0U, stream->position()); 465 EXPECT_EQ(0U, stream->position());
466 EXPECT_FALSE(stream->IsEOF()); 466 EXPECT_FALSE(stream->IsEOF());
467 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize); 467 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
468 int bytes_read = stream->Read(buf.get(), kTestDataSize, CompletionCallback()); 468 int bytes_read = stream->Read(buf.get(), kTestDataSize, CompletionCallback());
469 ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read); // Not an error. 469 ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read); // Not an error.
470 EXPECT_EQ(kTestDataSize, stream->position()); 470 EXPECT_EQ(kTestDataSize, stream->position());
471 ASSERT_TRUE(stream->IsEOF()); 471 ASSERT_TRUE(stream->IsEOF());
472 } 472 }
(...skipping 23 matching lines...) Expand all
496 new MockUploadElementReader(kTestDataSize, false)); 496 new MockUploadElementReader(kTestDataSize, false));
497 reader4->SetAsyncInitExpectation(OK); 497 reader4->SetAsyncInitExpectation(OK);
498 reader4->SetReadExpectation(kTestDataSize); 498 reader4->SetReadExpectation(kTestDataSize);
499 element_readers_.push_back(std::move(reader4)); 499 element_readers_.push_back(std::move(reader4));
500 500
501 std::unique_ptr<UploadDataStream> stream( 501 std::unique_ptr<UploadDataStream> stream(
502 new ElementsUploadDataStream(std::move(element_readers_), 0)); 502 new ElementsUploadDataStream(std::move(element_readers_), 0));
503 503
504 // Run Init(). 504 // Run Init().
505 TestCompletionCallback init_callback; 505 TestCompletionCallback init_callback;
506 EXPECT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 506 EXPECT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
507 IsError(ERR_IO_PENDING)); 507 IsError(ERR_IO_PENDING));
508 EXPECT_THAT(init_callback.WaitForResult(), IsOk()); 508 EXPECT_THAT(init_callback.WaitForResult(), IsOk());
509 509
510 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); 510 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
511 511
512 // Consume the first element. 512 // Consume the first element.
513 TestCompletionCallback read_callback1; 513 TestCompletionCallback read_callback1;
514 EXPECT_EQ(static_cast<int>(kTestDataSize), 514 EXPECT_EQ(static_cast<int>(kTestDataSize),
515 stream->Read(buf.get(), kTestDataSize, read_callback1.callback())); 515 stream->Read(buf.get(), kTestDataSize, read_callback1.callback()));
516 base::RunLoop().RunUntilIdle(); 516 base::RunLoop().RunUntilIdle();
(...skipping 20 matching lines...) Expand all
537 bool error_expected) { 537 bool error_expected) {
538 // Don't use element_readers_ here, as this function is called twice, and 538 // Don't use element_readers_ here, as this function is called twice, and
539 // reusing element_readers_ is wrong. 539 // reusing element_readers_ is wrong.
540 std::vector<std::unique_ptr<UploadElementReader>> element_readers; 540 std::vector<std::unique_ptr<UploadElementReader>> element_readers;
541 element_readers.push_back(base::MakeUnique<UploadFileElementReader>( 541 element_readers.push_back(base::MakeUnique<UploadFileElementReader>(
542 base::ThreadTaskRunnerHandle::Get().get(), file_path, 1, 2, time)); 542 base::ThreadTaskRunnerHandle::Get().get(), file_path, 1, 2, time));
543 543
544 TestCompletionCallback init_callback; 544 TestCompletionCallback init_callback;
545 std::unique_ptr<UploadDataStream> stream( 545 std::unique_ptr<UploadDataStream> stream(
546 new ElementsUploadDataStream(std::move(element_readers), 0)); 546 new ElementsUploadDataStream(std::move(element_readers), 0));
547 ASSERT_THAT(stream->Init(init_callback.callback(), BoundNetLog()), 547 ASSERT_THAT(stream->Init(init_callback.callback(), NetLogWithSource()),
548 IsError(ERR_IO_PENDING)); 548 IsError(ERR_IO_PENDING));
549 int error_code = init_callback.WaitForResult(); 549 int error_code = init_callback.WaitForResult();
550 if (error_expected) 550 if (error_expected)
551 ASSERT_THAT(error_code, IsError(ERR_UPLOAD_FILE_CHANGED)); 551 ASSERT_THAT(error_code, IsError(ERR_UPLOAD_FILE_CHANGED));
552 else 552 else
553 ASSERT_THAT(error_code, IsOk()); 553 ASSERT_THAT(error_code, IsOk());
554 } 554 }
555 555
556 TEST_F(ElementsUploadDataStreamTest, FileChanged) { 556 TEST_F(ElementsUploadDataStreamTest, FileChanged) {
557 base::FilePath temp_file_path; 557 base::FilePath temp_file_path;
(...skipping 28 matching lines...) Expand all
586 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, 586 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
587 std::numeric_limits<uint64_t>::max(), base::Time())); 587 std::numeric_limits<uint64_t>::max(), base::Time()));
588 std::unique_ptr<UploadDataStream> stream( 588 std::unique_ptr<UploadDataStream> stream(
589 new ElementsUploadDataStream(std::move(element_readers_), 0)); 589 new ElementsUploadDataStream(std::move(element_readers_), 0));
590 590
591 std::string expected_data(kTestData, kTestData + kTestDataSize); 591 std::string expected_data(kTestData, kTestData + kTestDataSize);
592 expected_data += expected_data; 592 expected_data += expected_data;
593 593
594 // Call Init(). 594 // Call Init().
595 TestCompletionCallback init_callback1; 595 TestCompletionCallback init_callback1;
596 ASSERT_THAT(stream->Init(init_callback1.callback(), BoundNetLog()), 596 ASSERT_THAT(stream->Init(init_callback1.callback(), NetLogWithSource()),
597 IsError(ERR_IO_PENDING)); 597 IsError(ERR_IO_PENDING));
598 ASSERT_THAT(init_callback1.WaitForResult(), IsOk()); 598 ASSERT_THAT(init_callback1.WaitForResult(), IsOk());
599 EXPECT_FALSE(stream->IsEOF()); 599 EXPECT_FALSE(stream->IsEOF());
600 EXPECT_EQ(kTestDataSize*2, stream->size()); 600 EXPECT_EQ(kTestDataSize*2, stream->size());
601 601
602 // Read. 602 // Read.
603 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get())); 603 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
604 EXPECT_TRUE(stream->IsEOF()); 604 EXPECT_TRUE(stream->IsEOF());
605 605
606 // Call Init() again to reset. 606 // Call Init() again to reset.
607 TestCompletionCallback init_callback2; 607 TestCompletionCallback init_callback2;
608 ASSERT_THAT(stream->Init(init_callback2.callback(), BoundNetLog()), 608 ASSERT_THAT(stream->Init(init_callback2.callback(), NetLogWithSource()),
609 IsError(ERR_IO_PENDING)); 609 IsError(ERR_IO_PENDING));
610 ASSERT_THAT(init_callback2.WaitForResult(), IsOk()); 610 ASSERT_THAT(init_callback2.WaitForResult(), IsOk());
611 EXPECT_FALSE(stream->IsEOF()); 611 EXPECT_FALSE(stream->IsEOF());
612 EXPECT_EQ(kTestDataSize*2, stream->size()); 612 EXPECT_EQ(kTestDataSize*2, stream->size());
613 613
614 // Read again. 614 // Read again.
615 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get())); 615 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
616 EXPECT_TRUE(stream->IsEOF()); 616 EXPECT_TRUE(stream->IsEOF());
617 } 617 }
618 618
(...skipping 11 matching lines...) Expand all
630 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>( 630 element_readers_.push_back(base::MakeUnique<UploadFileElementReader>(
631 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, 631 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0,
632 std::numeric_limits<uint64_t>::max(), base::Time())); 632 std::numeric_limits<uint64_t>::max(), base::Time()));
633 std::unique_ptr<UploadDataStream> stream( 633 std::unique_ptr<UploadDataStream> stream(
634 new ElementsUploadDataStream(std::move(element_readers_), 0)); 634 new ElementsUploadDataStream(std::move(element_readers_), 0));
635 635
636 std::string expected_data(kTestData, kTestData + kTestDataSize); 636 std::string expected_data(kTestData, kTestData + kTestDataSize);
637 expected_data += expected_data; 637 expected_data += expected_data;
638 638
639 // Call Init(). 639 // Call Init().
640 ASSERT_THAT(stream->Init(test_callback.callback(), BoundNetLog()), 640 ASSERT_THAT(stream->Init(test_callback.callback(), NetLogWithSource()),
641 IsError(ERR_IO_PENDING)); 641 IsError(ERR_IO_PENDING));
642 EXPECT_THAT(test_callback.WaitForResult(), IsOk()); 642 EXPECT_THAT(test_callback.WaitForResult(), IsOk());
643 EXPECT_FALSE(stream->IsEOF()); 643 EXPECT_FALSE(stream->IsEOF());
644 EXPECT_EQ(kTestDataSize*2, stream->size()); 644 EXPECT_EQ(kTestDataSize*2, stream->size());
645 645
646 // Read. 646 // Read.
647 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get())); 647 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
648 EXPECT_TRUE(stream->IsEOF()); 648 EXPECT_TRUE(stream->IsEOF());
649 649
650 // Call Init() again to reset. 650 // Call Init() again to reset.
651 ASSERT_THAT(stream->Init(test_callback.callback(), BoundNetLog()), 651 ASSERT_THAT(stream->Init(test_callback.callback(), NetLogWithSource()),
652 IsError(ERR_IO_PENDING)); 652 IsError(ERR_IO_PENDING));
653 EXPECT_THAT(test_callback.WaitForResult(), IsOk()); 653 EXPECT_THAT(test_callback.WaitForResult(), IsOk());
654 EXPECT_FALSE(stream->IsEOF()); 654 EXPECT_FALSE(stream->IsEOF());
655 EXPECT_EQ(kTestDataSize*2, stream->size()); 655 EXPECT_EQ(kTestDataSize*2, stream->size());
656 656
657 // Read again. 657 // Read again.
658 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get())); 658 EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
659 EXPECT_TRUE(stream->IsEOF()); 659 EXPECT_TRUE(stream->IsEOF());
660 } 660 }
661 661
(...skipping 12 matching lines...) Expand all
674 std::numeric_limits<uint64_t>::max(), base::Time())); 674 std::numeric_limits<uint64_t>::max(), base::Time()));
675 std::unique_ptr<UploadDataStream> stream( 675 std::unique_ptr<UploadDataStream> stream(
676 new ElementsUploadDataStream(std::move(element_readers_), 0)); 676 new ElementsUploadDataStream(std::move(element_readers_), 0));
677 677
678 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize); 678 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
679 expected_data.insert(expected_data.end(), kTestData, 679 expected_data.insert(expected_data.end(), kTestData,
680 kTestData + kTestDataSize); 680 kTestData + kTestDataSize);
681 681
682 // Call Init(). 682 // Call Init().
683 TestCompletionCallback init_callback1; 683 TestCompletionCallback init_callback1;
684 ASSERT_THAT(stream->Init(init_callback1.callback(), BoundNetLog()), 684 ASSERT_THAT(stream->Init(init_callback1.callback(), NetLogWithSource()),
685 IsError(ERR_IO_PENDING)); 685 IsError(ERR_IO_PENDING));
686 EXPECT_THAT(init_callback1.WaitForResult(), IsOk()); 686 EXPECT_THAT(init_callback1.WaitForResult(), IsOk());
687 EXPECT_FALSE(stream->IsEOF()); 687 EXPECT_FALSE(stream->IsEOF());
688 EXPECT_EQ(kTestDataSize*2, stream->size()); 688 EXPECT_EQ(kTestDataSize*2, stream->size());
689 689
690 // Read some. 690 // Read some.
691 TestCompletionCallback read_callback1; 691 TestCompletionCallback read_callback1;
692 std::vector<char> buf(kTestDataSize + kTestDataSize/2); 692 std::vector<char> buf(kTestDataSize + kTestDataSize/2);
693 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); 693 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
694 EXPECT_EQ( 694 EXPECT_EQ(
695 ERR_IO_PENDING, 695 ERR_IO_PENDING,
696 stream->Read(wrapped_buffer.get(), buf.size(), 696 stream->Read(wrapped_buffer.get(), buf.size(),
697 read_callback1.callback())); 697 read_callback1.callback()));
698 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); 698 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
699 EXPECT_EQ(buf.size(), stream->position()); 699 EXPECT_EQ(buf.size(), stream->position());
700 700
701 // Call Init to reset the state. 701 // Call Init to reset the state.
702 TestCompletionCallback init_callback2; 702 TestCompletionCallback init_callback2;
703 ASSERT_THAT(stream->Init(init_callback2.callback(), BoundNetLog()), 703 ASSERT_THAT(stream->Init(init_callback2.callback(), NetLogWithSource()),
704 IsError(ERR_IO_PENDING)); 704 IsError(ERR_IO_PENDING));
705 EXPECT_THAT(init_callback2.WaitForResult(), IsOk()); 705 EXPECT_THAT(init_callback2.WaitForResult(), IsOk());
706 EXPECT_FALSE(stream->IsEOF()); 706 EXPECT_FALSE(stream->IsEOF());
707 EXPECT_EQ(kTestDataSize*2, stream->size()); 707 EXPECT_EQ(kTestDataSize*2, stream->size());
708 708
709 // Read. 709 // Read.
710 TestCompletionCallback read_callback2; 710 TestCompletionCallback read_callback2;
711 std::vector<char> buf2(kTestDataSize*2); 711 std::vector<char> buf2(kTestDataSize*2);
712 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); 712 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
713 EXPECT_EQ(ERR_IO_PENDING, 713 EXPECT_EQ(ERR_IO_PENDING,
(...skipping 18 matching lines...) Expand all
732 std::numeric_limits<uint64_t>::max(), base::Time())); 732 std::numeric_limits<uint64_t>::max(), base::Time()));
733 std::unique_ptr<UploadDataStream> stream( 733 std::unique_ptr<UploadDataStream> stream(
734 new ElementsUploadDataStream(std::move(element_readers_), 0)); 734 new ElementsUploadDataStream(std::move(element_readers_), 0));
735 735
736 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize); 736 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
737 expected_data.insert(expected_data.end(), kTestData, 737 expected_data.insert(expected_data.end(), kTestData,
738 kTestData + kTestDataSize); 738 kTestData + kTestDataSize);
739 739
740 // Start Init. 740 // Start Init.
741 TestCompletionCallback init_callback1; 741 TestCompletionCallback init_callback1;
742 EXPECT_THAT(stream->Init(init_callback1.callback(), BoundNetLog()), 742 EXPECT_THAT(stream->Init(init_callback1.callback(), NetLogWithSource()),
743 IsError(ERR_IO_PENDING)); 743 IsError(ERR_IO_PENDING));
744 744
745 // Call Init again to cancel the previous init. 745 // Call Init again to cancel the previous init.
746 TestCompletionCallback init_callback2; 746 TestCompletionCallback init_callback2;
747 EXPECT_THAT(stream->Init(init_callback2.callback(), BoundNetLog()), 747 EXPECT_THAT(stream->Init(init_callback2.callback(), NetLogWithSource()),
748 IsError(ERR_IO_PENDING)); 748 IsError(ERR_IO_PENDING));
749 EXPECT_THAT(init_callback2.WaitForResult(), IsOk()); 749 EXPECT_THAT(init_callback2.WaitForResult(), IsOk());
750 EXPECT_FALSE(stream->IsEOF()); 750 EXPECT_FALSE(stream->IsEOF());
751 EXPECT_EQ(kTestDataSize*2, stream->size()); 751 EXPECT_EQ(kTestDataSize*2, stream->size());
752 752
753 // Read. 753 // Read.
754 TestCompletionCallback read_callback2; 754 TestCompletionCallback read_callback2;
755 std::vector<char> buf2(kTestDataSize*2); 755 std::vector<char> buf2(kTestDataSize*2);
756 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); 756 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
757 EXPECT_EQ(ERR_IO_PENDING, 757 EXPECT_EQ(ERR_IO_PENDING,
(...skipping 22 matching lines...) Expand all
780 std::numeric_limits<uint64_t>::max(), base::Time())); 780 std::numeric_limits<uint64_t>::max(), base::Time()));
781 std::unique_ptr<UploadDataStream> stream( 781 std::unique_ptr<UploadDataStream> stream(
782 new ElementsUploadDataStream(std::move(element_readers_), 0)); 782 new ElementsUploadDataStream(std::move(element_readers_), 0));
783 783
784 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize); 784 std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
785 expected_data.insert(expected_data.end(), kTestData, 785 expected_data.insert(expected_data.end(), kTestData,
786 kTestData + kTestDataSize); 786 kTestData + kTestDataSize);
787 787
788 // Call Init(). 788 // Call Init().
789 TestCompletionCallback init_callback1; 789 TestCompletionCallback init_callback1;
790 ASSERT_THAT(stream->Init(init_callback1.callback(), BoundNetLog()), 790 ASSERT_THAT(stream->Init(init_callback1.callback(), NetLogWithSource()),
791 IsError(ERR_IO_PENDING)); 791 IsError(ERR_IO_PENDING));
792 EXPECT_THAT(init_callback1.WaitForResult(), IsOk()); 792 EXPECT_THAT(init_callback1.WaitForResult(), IsOk());
793 EXPECT_FALSE(stream->IsEOF()); 793 EXPECT_FALSE(stream->IsEOF());
794 EXPECT_EQ(kTestDataSize*2, stream->size()); 794 EXPECT_EQ(kTestDataSize*2, stream->size());
795 795
796 // Start reading. 796 // Start reading.
797 TestCompletionCallback read_callback1; 797 TestCompletionCallback read_callback1;
798 std::vector<char> buf(kTestDataSize*2); 798 std::vector<char> buf(kTestDataSize*2);
799 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); 799 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
800 EXPECT_EQ( 800 EXPECT_EQ(
801 ERR_IO_PENDING, 801 ERR_IO_PENDING,
802 stream->Read(wrapped_buffer.get(), buf.size(), 802 stream->Read(wrapped_buffer.get(), buf.size(),
803 read_callback1.callback())); 803 read_callback1.callback()));
804 804
805 // Call Init to cancel the previous read. 805 // Call Init to cancel the previous read.
806 TestCompletionCallback init_callback2; 806 TestCompletionCallback init_callback2;
807 EXPECT_THAT(stream->Init(init_callback2.callback(), BoundNetLog()), 807 EXPECT_THAT(stream->Init(init_callback2.callback(), NetLogWithSource()),
808 IsError(ERR_IO_PENDING)); 808 IsError(ERR_IO_PENDING));
809 EXPECT_THAT(init_callback2.WaitForResult(), IsOk()); 809 EXPECT_THAT(init_callback2.WaitForResult(), IsOk());
810 EXPECT_FALSE(stream->IsEOF()); 810 EXPECT_FALSE(stream->IsEOF());
811 EXPECT_EQ(kTestDataSize*2, stream->size()); 811 EXPECT_EQ(kTestDataSize*2, stream->size());
812 812
813 // Read. 813 // Read.
814 TestCompletionCallback read_callback2; 814 TestCompletionCallback read_callback2;
815 std::vector<char> buf2(kTestDataSize*2); 815 std::vector<char> buf2(kTestDataSize*2);
816 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); 816 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
817 EXPECT_EQ(ERR_IO_PENDING, 817 EXPECT_EQ(ERR_IO_PENDING,
818 stream->Read( 818 stream->Read(
819 wrapped_buffer2.get(), buf2.size(), read_callback2.callback())); 819 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
820 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); 820 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
821 EXPECT_EQ(expected_data, buf2); 821 EXPECT_EQ(expected_data, buf2);
822 EXPECT_TRUE(stream->IsEOF()); 822 EXPECT_TRUE(stream->IsEOF());
823 823
824 // Make sure callbacks are not called for cancelled operations. 824 // Make sure callbacks are not called for cancelled operations.
825 EXPECT_FALSE(read_callback1.have_result()); 825 EXPECT_FALSE(read_callback1.have_result());
826 } 826 }
827 827
828 } // namespace net 828 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698