[TEST ONLY] Run tests for 2030353002

net/base/elements_upload_data_stream_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/elements_upload_data_stream.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 214 matching lines @@
       std::numeric_limits<uint64_t>::max(), base::Time())));
 
   TestCompletionCallback init_callback;
   std::unique_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(std::move(element_readers_), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kFakeSize, stream->size());
   EXPECT_EQ(0U, stream->position());
+
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   EXPECT_FALSE(stream->IsEOF());
-  uint64_t read_counter = 0;
-  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream->IsEOF()) {
-    TestCompletionCallback read_callback;
-    ASSERT_EQ(
-        ERR_IO_PENDING,
-        stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
-    int bytes_read = read_callback.WaitForResult();
-    ASSERT_LE(0, bytes_read);  // Not an error.
-    read_counter += bytes_read;
-    EXPECT_EQ(read_counter, stream->position());
-  }
-  // UpdateDataStream will pad out the file with 0 bytes so that the HTTP
-  // transaction doesn't hang.  Therefore we expected the full size.
-  EXPECT_EQ(kFakeSize, read_counter);
-  EXPECT_EQ(read_counter, stream->position());
+
+  TestCompletionCallback read_callback;
+  ASSERT_EQ(ERR_IO_PENDING,
+            stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
+  int bytes_read = read_callback.WaitForResult();
+
+  // UpdateDataStream will return error if there is something wrong.
+  // Thus, |bytes_read| is actual error.
+  EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, bytes_read);
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
 }
 
 TEST_F(ElementsUploadDataStreamTest, ReadErrorSync) {
   // This element cannot be read.
   std::unique_ptr<MockUploadElementReader> reader(
       new MockUploadElementReader(kTestDataSize, true));
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(ERR_FAILED);
   element_readers_.push_back(std::move(reader));
 
   // This element is ignored because of the error from the previous reader.
   element_readers_.push_back(
       base::WrapUnique(new UploadBytesElementReader(kTestData, kTestDataSize)));
 
   std::unique_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(std::move(element_readers_), 0));
 
   // Run Init().
   ASSERT_EQ(OK, stream->Init(CompletionCallback()));
   EXPECT_EQ(kTestDataSize*2, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
-  EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
+  EXPECT_EQ(ERR_FAILED,
             stream->Read(buf.get(), kTestBufferSize, CompletionCallback()));
-  EXPECT_EQ(kTestDataSize * 2, stream->position());
-  EXPECT_TRUE(stream->IsEOF());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
 
   // The buffer is filled with zero.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
-            std::count(buf->data(), buf->data() + kTestBufferSize, 0));
+  EXPECT_EQ(0, std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(ElementsUploadDataStreamTest, ReadErrorAsync) {
   // This element cannot be read.
   std::unique_ptr<MockUploadElementReader> reader(
       new MockUploadElementReader(kTestDataSize, false));
   reader->SetAsyncInitExpectation(OK);
   reader->SetReadExpectation(ERR_FAILED);
   element_readers_.push_back(std::move(reader));
 
@@ skipping 13 matching lines @@
   EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   std::fill_n(buf->data(), kTestBufferSize, -1);
 
   // Read() results in success even when the reader returns error.
   TestCompletionCallback read_callback;
   ASSERT_EQ(ERR_IO_PENDING,
             stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
-  EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
-  EXPECT_EQ(kTestDataSize*2, stream->position());
-  EXPECT_TRUE(stream->IsEOF());
+  EXPECT_EQ(ERR_FAILED, read_callback.WaitForResult());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
 
-  // The buffer is filled with zero.
-  EXPECT_EQ(static_cast<int>(kTestDataSize*2),
-            std::count(buf->data(), buf->data() + kTestBufferSize, 0));
+  // The buffer is empty
+  EXPECT_EQ(0, std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(ElementsUploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   const uint64_t kFileRangeOffset = 1;
@@ skipping 459 matching lines @@
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream->IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
 }
 
 }  // namespace net