Index: net/base/upload_disk_cache_entry_element_reader_unittest.cc |
diff --git a/net/base/upload_disk_cache_entry_element_reader_unittest.cc b/net/base/upload_disk_cache_entry_element_reader_unittest.cc |
deleted file mode 100644 |
index 7321acc9cd5b54bc544cc984c4b0cc4a734988b9..0000000000000000000000000000000000000000 |
--- a/net/base/upload_disk_cache_entry_element_reader_unittest.cc |
+++ /dev/null |
@@ -1,331 +0,0 @@ |
-// Copyright 2015 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/upload_disk_cache_entry_element_reader.h" |
- |
-#include <stdint.h> |
- |
-#include <algorithm> |
-#include <string> |
-#include <vector> |
- |
-#include "base/basictypes.h" |
-#include "base/bind.h" |
-#include "base/callback.h" |
-#include "base/logging.h" |
-#include "base/macros.h" |
-#include "base/memory/ref_counted.h" |
-#include "base/memory/scoped_ptr.h" |
-#include "base/time/time.h" |
-#include "net/base/io_buffer.h" |
-#include "net/base/net_errors.h" |
-#include "net/base/test_completion_callback.h" |
-#include "net/disk_cache/disk_cache.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
-#include "testing/platform_test.h" |
- |
-namespace net { |
-namespace { |
- |
-const int kTestDiskCacheStreamIndex = 0; |
- |
-const char kDataKey[] = "a key"; |
- |
-const char kData[] = "this is data in a disk cache entry"; |
-const size_t kDataSize = arraysize(kData) - 1; |
- |
-// A disk_cache::Entry that arbitrarily delays the completion of a read |
-// operation to allow testing some races without flake. This is particularly |
-// relevant in this unit test, which uses the always-synchronous MEMORY_CACHE. |
-class DelayedReadEntry : public disk_cache::Entry { |
- public: |
- explicit DelayedReadEntry(disk_cache::ScopedEntryPtr entry) |
- : entry_(entry.Pass()) {} |
- ~DelayedReadEntry() override { EXPECT_FALSE(HasPendingReadCallbacks()); } |
- |
- bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); } |
- |
- void RunPendingReadCallbacks() { |
- std::vector<base::Callback<void(void)>> callbacks; |
- pending_read_callbacks_.swap(callbacks); |
- for (const auto& callback : callbacks) |
- callback.Run(); |
- } |
- |
- // From disk_cache::Entry: |
- void Doom() override { entry_->Doom(); } |
- |
- void Close() override { delete this; } // Note this is required by the API. |
- |
- std::string GetKey() const override { return entry_->GetKey(); } |
- |
- base::Time GetLastUsed() const override { return entry_->GetLastUsed(); } |
- |
- base::Time GetLastModified() const override { |
- return entry_->GetLastModified(); |
- } |
- |
- int32 GetDataSize(int index) const override { |
- return entry_->GetDataSize(index); |
- } |
- |
- int ReadData(int index, |
- int offset, |
- IOBuffer* buf, |
- int buf_len, |
- const CompletionCallback& original_callback) override { |
- TestCompletionCallback callback; |
- int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback()); |
- DCHECK_NE(rv, ERR_IO_PENDING) |
- << "Test expects to use a MEMORY_CACHE instance, which is synchronous."; |
- pending_read_callbacks_.push_back(base::Bind(original_callback, rv)); |
- return ERR_IO_PENDING; |
- } |
- |
- int WriteData(int index, |
- int offset, |
- IOBuffer* buf, |
- int buf_len, |
- const CompletionCallback& callback, |
- bool truncate) override { |
- return entry_->WriteData(index, offset, buf, buf_len, callback, truncate); |
- } |
- |
- int ReadSparseData(int64 offset, |
- IOBuffer* buf, |
- int buf_len, |
- const CompletionCallback& callback) override { |
- return entry_->ReadSparseData(offset, buf, buf_len, callback); |
- } |
- |
- int WriteSparseData(int64 offset, |
- IOBuffer* buf, |
- int buf_len, |
- const CompletionCallback& callback) override { |
- return entry_->WriteSparseData(offset, buf, buf_len, callback); |
- } |
- |
- int GetAvailableRange(int64 offset, |
- int len, |
- int64* start, |
- const CompletionCallback& callback) override { |
- return entry_->GetAvailableRange(offset, len, start, callback); |
- } |
- |
- bool CouldBeSparse() const override { return entry_->CouldBeSparse(); } |
- |
- void CancelSparseIO() override { entry_->CancelSparseIO(); } |
- |
- int ReadyForSparseIO(const CompletionCallback& callback) override { |
- return entry_->ReadyForSparseIO(callback); |
- } |
- |
- private: |
- disk_cache::ScopedEntryPtr entry_; |
- std::vector<base::Callback<void(void)>> pending_read_callbacks_; |
-}; |
- |
-class UploadDiskCacheEntryElementReaderTest : public PlatformTest { |
- public: |
- UploadDiskCacheEntryElementReaderTest() {} |
- |
- ~UploadDiskCacheEntryElementReaderTest() override {} |
- |
- void SetUp() override { |
- TestCompletionCallback callback; |
- int rv = disk_cache::CreateCacheBackend( |
- MEMORY_CACHE, CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false, |
- nullptr, nullptr, &cache_, callback.callback()); |
- ASSERT_EQ(OK, callback.GetResult(rv)); |
- |
- disk_cache::Entry* tmp_entry = nullptr; |
- rv = cache_->CreateEntry(kDataKey, &tmp_entry, callback.callback()); |
- ASSERT_EQ(OK, callback.GetResult(rv)); |
- entry_.reset(tmp_entry); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(kData); |
- rv = entry_->WriteData(kTestDiskCacheStreamIndex, 0, io_buffer.get(), |
- kDataSize, callback.callback(), false); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- } |
- |
- void set_entry(disk_cache::ScopedEntryPtr entry) { entry_.swap(entry); } |
- disk_cache::Entry* entry() { return entry_.get(); } |
- disk_cache::ScopedEntryPtr release_entry() { return entry_.Pass(); } |
- |
- private: |
- scoped_ptr<disk_cache::Backend> cache_; |
- disk_cache::ScopedEntryPtr entry_; |
-}; |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAll) { |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- char read_buffer[kDataSize]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- EXPECT_EQ(0U, reader.BytesRemaining()) |
- << "Expected a single read of |kDataSize| to retrieve entire entry."; |
- EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, ReadPartially) { |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- const size_t kReadBuffer1Size = kDataSize / 3; |
- char read_buffer1[kReadBuffer1Size]; |
- std::fill(read_buffer1, read_buffer1 + arraysize(read_buffer1), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer1 = new WrappedIOBuffer(read_buffer1); |
- |
- const size_t kReadBuffer2Size = kDataSize - kReadBuffer1Size; |
- char read_buffer2[kReadBuffer2Size]; |
- scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2); |
- |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer1.get(), kReadBuffer1Size, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kReadBuffer1Size), callback.GetResult(rv)); |
- EXPECT_EQ(static_cast<uint64_t>(kReadBuffer2Size), reader.BytesRemaining()); |
- |
- rv = reader.Read(io_buffer2.get(), kReadBuffer2Size, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kReadBuffer2Size), callback.GetResult(rv)); |
- EXPECT_EQ(0U, reader.BytesRemaining()); |
- |
- EXPECT_EQ(std::string(kData, kDataSize), |
- std::string(read_buffer1, kReadBuffer1Size) + |
- std::string(read_buffer2, kReadBuffer2Size)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, ReadTooMuch) { |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- const size_t kTooLargeSize = kDataSize + kDataSize / 2; |
- |
- char read_buffer[kTooLargeSize]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer.get(), kTooLargeSize, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- EXPECT_EQ(0U, reader.BytesRemaining()); |
- EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAsync) { |
- DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry()); |
- set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry)); |
- |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- |
- char read_buffer[kDataSize]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
- EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- delayed_read_entry->RunPendingReadCallbacks(); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- EXPECT_EQ(0U, reader.BytesRemaining()) |
- << "Expected a single read of |kDataSize| to retrieve entire entry."; |
- EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, MultipleInit) { |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- char read_buffer[kDataSize]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
- |
- rv = reader.Init(callback.callback()); |
- EXPECT_EQ(OK, callback.GetResult(rv)); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- rv = reader.Read(io_buffer.get(), kDataSize, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv)); |
- EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, InitDuringAsyncOperation) { |
- DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry()); |
- set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry)); |
- |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- 0, kDataSize); |
- char read_buffer[kDataSize]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback read_callback; |
- int rv = reader.Read(io_buffer.get(), kDataSize, read_callback.callback()); |
- EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- TestCompletionCallback init_callback; |
- rv = reader.Init(init_callback.callback()); |
- EXPECT_EQ(OK, init_callback.GetResult(rv)); |
- |
- delayed_read_entry->RunPendingReadCallbacks(); |
- EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks()); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- char read_buffer2[kDataSize]; |
- std::fill(read_buffer2, read_buffer2 + arraysize(read_buffer2), '\0'); |
- scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2); |
- TestCompletionCallback read_callback2; |
- rv = reader.Read(io_buffer2.get(), kDataSize, read_callback2.callback()); |
- EXPECT_EQ(ERR_IO_PENDING, rv); |
- EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks()); |
- EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining()); |
- |
- delayed_read_entry->RunPendingReadCallbacks(); |
- EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks()); |
- read_callback2.WaitForResult(); // Succeeds if this does not deadlock. |
- EXPECT_EQ(std::string(kData, kDataSize), |
- std::string(read_buffer2, kDataSize)); |
-} |
- |
-TEST_F(UploadDiskCacheEntryElementReaderTest, Range) { |
- const size_t kOffset = kDataSize / 4; |
- const size_t kLength = kDataSize / 3; |
- |
- UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex, |
- kOffset, kLength); |
- EXPECT_EQ(static_cast<uint64_t>(kLength), reader.BytesRemaining()); |
- |
- char read_buffer[kLength]; |
- std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0'); |
- |
- scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer); |
- TestCompletionCallback callback; |
- int rv = reader.Read(io_buffer.get(), kLength, callback.callback()); |
- EXPECT_EQ(static_cast<int>(kLength), callback.GetResult(rv)); |
- EXPECT_EQ(0U, reader.BytesRemaining()); |
- EXPECT_EQ(std::string(kData + kOffset, kLength), |
- std::string(read_buffer, kLength)); |
-} |
- |
-} // namespace |
-} // namespace net |