net/base/upload_disk_cache_entry_element_reader_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/upload_disk_cache_entry_element_reader.h"
   6
   7 #include <stdint.h>
   8
   9 #include <algorithm>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/bind.h"
  15 #include "base/callback.h"
  16 #include "base/logging.h"
  17 #include "base/macros.h"
  18 #include "base/memory/ref_counted.h"
  19 #include "base/memory/scoped_ptr.h"
  20 #include "base/time/time.h"
  21 #include "net/base/io_buffer.h"
  22 #include "net/base/net_errors.h"
  23 #include "net/base/test_completion_callback.h"
  24 #include "net/disk_cache/disk_cache.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "testing/platform_test.h"
  27
  28 namespace net {
  29 namespace {
  30
  31 const int kTestDiskCacheStreamIndex = 0;
  32
  33 const char kDataKey[] = "a key";
  34
  35 const char kData[] = "this is data in a disk cache entry";
  36 const size_t kDataSize = arraysize(kData) - 1;
  37
  38 // A disk_cache::Entry that arbitrarily delays the completion of a read
  39 // operation to allow testing some races without flake. This is particularly
  40 // relevant in this unit test, which uses the always-synchronous MEMORY_CACHE.
  41 class DelayedReadEntry : public disk_cache::Entry {
  42  public:
  43   explicit DelayedReadEntry(disk_cache::ScopedEntryPtr entry)
  44       : entry_(entry.Pass()) {}
  45   ~DelayedReadEntry() override { EXPECT_FALSE(HasPendingReadCallbacks()); }
  46
  47   bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); }
  48
  49   void RunPendingReadCallbacks() {
  50     std::vector<base::Callback<void(void)>> callbacks;
  51     pending_read_callbacks_.swap(callbacks);
  52     for (const auto& callback : callbacks)
  53       callback.Run();
  54   }
  55
  56   // From disk_cache::Entry:
  57   void Doom() override { entry_->Doom(); }
  58
  59   void Close() override { delete this; }  // Note this is required by the API.
  60
  61   std::string GetKey() const override { return entry_->GetKey(); }
  62
  63   base::Time GetLastUsed() const override { return entry_->GetLastUsed(); }
  64
  65   base::Time GetLastModified() const override {
  66     return entry_->GetLastModified();
  67   }
  68
  69   int32 GetDataSize(int index) const override {
  70     return entry_->GetDataSize(index);
  71   }
  72
  73   int ReadData(int index,
  74                int offset,
  75                IOBuffer* buf,
  76                int buf_len,
  77                const CompletionCallback& original_callback) override {
  78     TestCompletionCallback callback;
  79     int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback());
  80     DCHECK_NE(rv, ERR_IO_PENDING)
  81         << "Test expects to use a MEMORY_CACHE instance, which is synchronous.";
  82     pending_read_callbacks_.push_back(base::Bind(original_callback, rv));
  83     return ERR_IO_PENDING;
  84   }
  85
  86   int WriteData(int index,
  87                 int offset,
  88                 IOBuffer* buf,
  89                 int buf_len,
  90                 const CompletionCallback& callback,
  91                 bool truncate) override {
  92     return entry_->WriteData(index, offset, buf, buf_len, callback, truncate);
  93   }
  94
  95   int ReadSparseData(int64 offset,
  96                      IOBuffer* buf,
  97                      int buf_len,
  98                      const CompletionCallback& callback) override {
  99     return entry_->ReadSparseData(offset, buf, buf_len, callback);
 100   }
 101
 102   int WriteSparseData(int64 offset,
 103                       IOBuffer* buf,
 104                       int buf_len,
 105                       const CompletionCallback& callback) override {
 106     return entry_->WriteSparseData(offset, buf, buf_len, callback);
 107   }
 108
 109   int GetAvailableRange(int64 offset,
 110                         int len,
 111                         int64* start,
 112                         const CompletionCallback& callback) override {
 113     return entry_->GetAvailableRange(offset, len, start, callback);
 114   }
 115
 116   bool CouldBeSparse() const override { return entry_->CouldBeSparse(); }
 117
 118   void CancelSparseIO() override { entry_->CancelSparseIO(); }
 119
 120   int ReadyForSparseIO(const CompletionCallback& callback) override {
 121     return entry_->ReadyForSparseIO(callback);
 122   }
 123
 124  private:
 125   disk_cache::ScopedEntryPtr entry_;
 126   std::vector<base::Callback<void(void)>> pending_read_callbacks_;
 127 };
 128
 129 class UploadDiskCacheEntryElementReaderTest : public PlatformTest {
 130  public:
 131   UploadDiskCacheEntryElementReaderTest() {}
 132
 133   ~UploadDiskCacheEntryElementReaderTest() override {}
 134
 135   void SetUp() override {
 136     TestCompletionCallback callback;
 137     int rv = disk_cache::CreateCacheBackend(
 138         MEMORY_CACHE, CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false,
 139         nullptr, nullptr, &cache_, callback.callback());
 140     ASSERT_EQ(OK, callback.GetResult(rv));
 141
 142     disk_cache::Entry* tmp_entry = nullptr;
 143     rv = cache_->CreateEntry(kDataKey, &tmp_entry, callback.callback());
 144     ASSERT_EQ(OK, callback.GetResult(rv));
 145     entry_.reset(tmp_entry);
 146
 147     scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(kData);
 148     rv = entry_->WriteData(kTestDiskCacheStreamIndex, 0, io_buffer.get(),
 149                            kDataSize, callback.callback(), false);
 150     EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 151   }
 152
 153   void set_entry(disk_cache::ScopedEntryPtr entry) { entry_.swap(entry); }
 154   disk_cache::Entry* entry() { return entry_.get(); }
 155   disk_cache::ScopedEntryPtr release_entry() { return entry_.Pass(); }
 156
 157  private:
 158   scoped_ptr<disk_cache::Backend> cache_;
 159   disk_cache::ScopedEntryPtr entry_;
 160 };
 161
 162 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAll) {
 163   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 164                                            0, kDataSize);
 165   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 166
 167   char read_buffer[kDataSize];
 168   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 169
 170   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 171   TestCompletionCallback callback;
 172   int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
 173   EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 174   EXPECT_EQ(0U, reader.BytesRemaining())
 175       << "Expected a single read of |kDataSize| to retrieve entire entry.";
 176   EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
 177 }
 178
 179 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadPartially) {
 180   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 181                                            0, kDataSize);
 182   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 183
 184   const size_t kReadBuffer1Size = kDataSize / 3;
 185   char read_buffer1[kReadBuffer1Size];
 186   std::fill(read_buffer1, read_buffer1 + arraysize(read_buffer1), '\0');
 187
 188   scoped_refptr<IOBuffer> io_buffer1 = new WrappedIOBuffer(read_buffer1);
 189
 190   const size_t kReadBuffer2Size = kDataSize - kReadBuffer1Size;
 191   char read_buffer2[kReadBuffer2Size];
 192   scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2);
 193
 194   TestCompletionCallback callback;
 195   int rv = reader.Read(io_buffer1.get(), kReadBuffer1Size, callback.callback());
 196   EXPECT_EQ(static_cast<int>(kReadBuffer1Size), callback.GetResult(rv));
 197   EXPECT_EQ(static_cast<uint64_t>(kReadBuffer2Size), reader.BytesRemaining());
 198
 199   rv = reader.Read(io_buffer2.get(), kReadBuffer2Size, callback.callback());
 200   EXPECT_EQ(static_cast<int>(kReadBuffer2Size), callback.GetResult(rv));
 201   EXPECT_EQ(0U, reader.BytesRemaining());
 202
 203   EXPECT_EQ(std::string(kData, kDataSize),
 204             std::string(read_buffer1, kReadBuffer1Size) +
 205                 std::string(read_buffer2, kReadBuffer2Size));
 206 }
 207
 208 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadTooMuch) {
 209   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 210                                            0, kDataSize);
 211   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 212
 213   const size_t kTooLargeSize = kDataSize + kDataSize / 2;
 214
 215   char read_buffer[kTooLargeSize];
 216   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 217
 218   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 219   TestCompletionCallback callback;
 220   int rv = reader.Read(io_buffer.get(), kTooLargeSize, callback.callback());
 221   EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 222   EXPECT_EQ(0U, reader.BytesRemaining());
 223   EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
 224 }
 225
 226 TEST_F(UploadDiskCacheEntryElementReaderTest, ReadAsync) {
 227   DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry());
 228   set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry));
 229
 230   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 231                                            0, kDataSize);
 232
 233   char read_buffer[kDataSize];
 234   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 235
 236   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 237   TestCompletionCallback callback;
 238   int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
 239   EXPECT_EQ(ERR_IO_PENDING, rv);
 240   EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
 241   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 242
 243   delayed_read_entry->RunPendingReadCallbacks();
 244   EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 245   EXPECT_EQ(0U, reader.BytesRemaining())
 246       << "Expected a single read of |kDataSize| to retrieve entire entry.";
 247   EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
 248 }
 249
 250 TEST_F(UploadDiskCacheEntryElementReaderTest, MultipleInit) {
 251   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 252                                            0, kDataSize);
 253   char read_buffer[kDataSize];
 254   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 255
 256   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 257   TestCompletionCallback callback;
 258   int rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
 259   EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 260   EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
 261
 262   rv = reader.Init(callback.callback());
 263   EXPECT_EQ(OK, callback.GetResult(rv));
 264   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 265   rv = reader.Read(io_buffer.get(), kDataSize, callback.callback());
 266   EXPECT_EQ(static_cast<int>(kDataSize), callback.GetResult(rv));
 267   EXPECT_EQ(std::string(kData, kDataSize), std::string(read_buffer, kDataSize));
 268 }
 269
 270 TEST_F(UploadDiskCacheEntryElementReaderTest, InitDuringAsyncOperation) {
 271   DelayedReadEntry* delayed_read_entry = new DelayedReadEntry(release_entry());
 272   set_entry(disk_cache::ScopedEntryPtr(delayed_read_entry));
 273
 274   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 275                                            0, kDataSize);
 276   char read_buffer[kDataSize];
 277   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 278
 279   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 280   TestCompletionCallback read_callback;
 281   int rv = reader.Read(io_buffer.get(), kDataSize, read_callback.callback());
 282   EXPECT_EQ(ERR_IO_PENDING, rv);
 283   EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
 284   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 285
 286   TestCompletionCallback init_callback;
 287   rv = reader.Init(init_callback.callback());
 288   EXPECT_EQ(OK, init_callback.GetResult(rv));
 289
 290   delayed_read_entry->RunPendingReadCallbacks();
 291   EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks());
 292   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 293
 294   char read_buffer2[kDataSize];
 295   std::fill(read_buffer2, read_buffer2 + arraysize(read_buffer2), '\0');
 296   scoped_refptr<IOBuffer> io_buffer2 = new WrappedIOBuffer(read_buffer2);
 297   TestCompletionCallback read_callback2;
 298   rv = reader.Read(io_buffer2.get(), kDataSize, read_callback2.callback());
 299   EXPECT_EQ(ERR_IO_PENDING, rv);
 300   EXPECT_TRUE(delayed_read_entry->HasPendingReadCallbacks());
 301   EXPECT_EQ(static_cast<uint64_t>(kDataSize), reader.BytesRemaining());
 302
 303   delayed_read_entry->RunPendingReadCallbacks();
 304   EXPECT_FALSE(delayed_read_entry->HasPendingReadCallbacks());
 305   read_callback2.WaitForResult();  // Succeeds if this does not deadlock.
 306   EXPECT_EQ(std::string(kData, kDataSize),
 307             std::string(read_buffer2, kDataSize));
 308 }
 309
 310 TEST_F(UploadDiskCacheEntryElementReaderTest, Range) {
 311   const size_t kOffset = kDataSize / 4;
 312   const size_t kLength = kDataSize / 3;
 313
 314   UploadDiskCacheEntryElementReader reader(entry(), kTestDiskCacheStreamIndex,
 315                                            kOffset, kLength);
 316   EXPECT_EQ(static_cast<uint64_t>(kLength), reader.BytesRemaining());
 317
 318   char read_buffer[kLength];
 319   std::fill(read_buffer, read_buffer + arraysize(read_buffer), '\0');
 320
 321   scoped_refptr<IOBuffer> io_buffer = new WrappedIOBuffer(read_buffer);
 322   TestCompletionCallback callback;
 323   int rv = reader.Read(io_buffer.get(), kLength, callback.callback());
 324   EXPECT_EQ(static_cast<int>(kLength), callback.GetResult(rv));
 325   EXPECT_EQ(0U, reader.BytesRemaining());
 326   EXPECT_EQ(std::string(kData + kOffset, kLength),
 327             std::string(read_buffer, kLength));
 328 }
 329
 330 }  // namespace
 331 }  // namespace net