| // 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 <utility> |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/files/file.h" |
| #include "base/files/file_util.h" |
| #include "base/macros.h" |
| #include "base/metrics/field_trial.h" |
| #include "base/metrics/field_trial_param_associator.h" |
| #include "base/run_loop.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_util.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/mock_entropy_provider.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/threading/platform_thread.h" |
| #include "net/base/completion_once_callback.h" |
| #include "net/base/io_buffer.h" |
| #include "net/base/net_errors.h" |
| #include "net/base/request_priority.h" |
| #include "net/base/test_completion_callback.h" |
| #include "net/disk_cache/blockfile/backend_impl.h" |
| #include "net/disk_cache/blockfile/entry_impl.h" |
| #include "net/disk_cache/cache_util.h" |
| #include "net/disk_cache/disk_cache_test_base.h" |
| #include "net/disk_cache/disk_cache_test_util.h" |
| #include "net/disk_cache/memory/mem_entry_impl.h" |
| #include "net/disk_cache/simple/simple_backend_impl.h" |
| #include "net/disk_cache/simple/simple_entry_format.h" |
| #include "net/disk_cache/simple/simple_entry_impl.h" |
| #include "net/disk_cache/simple/simple_histogram_enums.h" |
| #include "net/disk_cache/simple/simple_synchronous_entry.h" |
| #include "net/disk_cache/simple/simple_test_util.h" |
| #include "net/disk_cache/simple/simple_util.h" |
| #include "net/test/gtest_util.h" |
| #include "starboard/memory.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using net::test::IsError; |
| using net::test::IsOk; |
| |
| using base::Time; |
| using disk_cache::ScopedEntryPtr; |
| |
| // Tests that can run with different types of caches. |
| class DiskCacheEntryTest : public DiskCacheTestWithCache { |
| public: |
| void InternalSyncIOBackground(disk_cache::Entry* entry); |
| void ExternalSyncIOBackground(disk_cache::Entry* entry); |
| |
| protected: |
| void InternalSyncIO(); |
| void InternalAsyncIO(); |
| void ExternalSyncIO(); |
| void ExternalAsyncIO(); |
| void ReleaseBuffer(int stream_index); |
| void StreamAccess(); |
| void GetKey(); |
| void GetTimes(int stream_index); |
| void GrowData(int stream_index); |
| void TruncateData(int stream_index); |
| void ZeroLengthIO(int stream_index); |
| void Buffering(); |
| void SizeAtCreate(); |
| void SizeChanges(int stream_index); |
| void ReuseEntry(int size, int stream_index); |
| void InvalidData(int stream_index); |
| void ReadWriteDestroyBuffer(int stream_index); |
| void DoomNormalEntry(); |
| void DoomEntryNextToOpenEntry(); |
| void DoomedEntry(int stream_index); |
| void BasicSparseIO(); |
| void HugeSparseIO(); |
| void GetAvailableRange(); |
| void CouldBeSparse(); |
| void UpdateSparseEntry(); |
| void DoomSparseEntry(); |
| void PartialSparseEntry(); |
| bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int data_size); |
| bool SimpleCacheThirdStreamFileExists(const char* key); |
| void SyncDoomEntry(const char* key); |
| void UseAfterBackendDestruction(); |
| }; |
| |
| // This part of the test runs on the background thread. |
| void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) { |
| const int kSize1 = 10; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| EXPECT_EQ(0, entry->ReadData(0, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback())); |
| base::strlcpy(buffer1->data(), "the data", kSize1); |
| EXPECT_EQ(10, entry->WriteData(0, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback(), false)); |
| memset(buffer1->data(), 0, kSize1); |
| EXPECT_EQ(10, entry->ReadData(0, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback())); |
| EXPECT_STREQ("the data", buffer1->data()); |
| |
| const int kSize2 = 5000; |
| const int kSize3 = 10000; |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| scoped_refptr<net::IOBuffer> buffer3 = |
| base::MakeRefCounted<net::IOBuffer>(kSize3); |
| memset(buffer3->data(), 0, kSize3); |
| CacheTestFillBuffer(buffer2->data(), kSize2, false); |
| base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); |
| EXPECT_EQ(5000, entry->WriteData(1, 1500, buffer2.get(), kSize2, |
| net::CompletionOnceCallback(), false)); |
| memset(buffer2->data(), 0, kSize2); |
| EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_STREQ("big data goes here", buffer2->data()); |
| EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500)); |
| EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| |
| EXPECT_EQ(0, entry->ReadData(1, 6500, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(6500, entry->ReadData(1, 0, buffer3.get(), kSize3, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(8192, entry->WriteData(1, 0, buffer3.get(), 8192, |
| net::CompletionOnceCallback(), false)); |
| EXPECT_EQ(8192, entry->ReadData(1, 0, buffer3.get(), kSize3, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(8192, entry->GetDataSize(1)); |
| |
| // We need to delete the memory buffer on this thread. |
| EXPECT_EQ( |
| 0, entry->WriteData(0, 0, NULL, 0, net::CompletionOnceCallback(), true)); |
| EXPECT_EQ( |
| 0, entry->WriteData(1, 0, NULL, 0, net::CompletionOnceCallback(), true)); |
| } |
| |
| // We need to support synchronous IO even though it is not a supported operation |
| // from the point of view of the disk cache's public interface, because we use |
| // it internally, not just by a few tests, but as part of the implementation |
| // (see sparse_control.cc, for example). |
| void DiskCacheEntryTest::InternalSyncIO() { |
| disk_cache::Entry* entry = NULL; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| ASSERT_TRUE(NULL != entry); |
| |
| // The bulk of the test runs from within the callback, on the cache thread. |
| RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground, |
| base::Unretained(this), |
| entry)); |
| |
| |
| entry->Doom(); |
| entry->Close(); |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, InternalSyncIO) { |
| InitCache(); |
| InternalSyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| InternalSyncIO(); |
| } |
| |
| void DiskCacheEntryTest::InternalAsyncIO() { |
| disk_cache::Entry* entry = NULL; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| ASSERT_TRUE(NULL != entry); |
| |
| // Avoid using internal buffers for the test. We have to write something to |
| // the entry and close it so that we flush the internal buffer to disk. After |
| // that, IO operations will be really hitting the disk. We don't care about |
| // the content, so just extending the entry is enough (all extensions zero- |
| // fill any holes). |
| EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false)); |
| EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry("the first key", &entry), IsOk()); |
| |
| MessageLoopHelper helper; |
| // Let's verify that each IO goes to the right callback object. |
| CallbackTest callback1(&helper, false); |
| CallbackTest callback2(&helper, false); |
| CallbackTest callback3(&helper, false); |
| CallbackTest callback4(&helper, false); |
| CallbackTest callback5(&helper, false); |
| CallbackTest callback6(&helper, false); |
| CallbackTest callback7(&helper, false); |
| CallbackTest callback8(&helper, false); |
| CallbackTest callback9(&helper, false); |
| CallbackTest callback10(&helper, false); |
| CallbackTest callback11(&helper, false); |
| CallbackTest callback12(&helper, false); |
| CallbackTest callback13(&helper, false); |
| |
| const int kSize1 = 10; |
| const int kSize2 = 5000; |
| const int kSize3 = 10000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| scoped_refptr<net::IOBuffer> buffer3 = |
| base::MakeRefCounted<net::IOBuffer>(kSize3); |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| CacheTestFillBuffer(buffer2->data(), kSize2, false); |
| CacheTestFillBuffer(buffer3->data(), kSize3, false); |
| |
| EXPECT_EQ(0, |
| entry->ReadData( |
| 0, |
| 15 * 1024, |
| buffer1.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback1)))); |
| base::strlcpy(buffer1->data(), "the data", kSize1); |
| int expected = 0; |
| int ret = entry->WriteData( |
| 0, |
| 0, |
| buffer1.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), |
| false); |
| EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| memset(buffer2->data(), 0, kSize2); |
| ret = entry->ReadData( |
| 0, |
| 0, |
| buffer2.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback3))); |
| EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_STREQ("the data", buffer2->data()); |
| |
| base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); |
| ret = entry->WriteData( |
| 1, |
| 1500, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback4)), |
| true); |
| EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| memset(buffer3->data(), 0, kSize3); |
| ret = entry->ReadData( |
| 1, |
| 1511, |
| buffer3.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback5))); |
| EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_STREQ("big data goes here", buffer3->data()); |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback6))); |
| EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| memset(buffer3->data(), 0, kSize3); |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500)); |
| ret = entry->ReadData( |
| 1, |
| 5000, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback7))); |
| EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer3.get(), |
| kSize3, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback9))); |
| EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| ret = entry->WriteData( |
| 1, |
| 0, |
| buffer3.get(), |
| 8192, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback10)), |
| true); |
| EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer3.get(), |
| kSize3, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback11))); |
| EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_EQ(8192, entry->GetDataSize(1)); |
| |
| ret = entry->ReadData( |
| 0, |
| 0, |
| buffer1.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback12))); |
| EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback13))); |
| EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| |
| EXPECT_FALSE(helper.callback_reused_error()); |
| |
| entry->Doom(); |
| entry->Close(); |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, InternalAsyncIO) { |
| InitCache(); |
| InternalAsyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| InternalAsyncIO(); |
| } |
| |
| // This part of the test runs on the background thread. |
| void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) { |
| const int kSize1 = 17000; |
| const int kSize2 = 25000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| CacheTestFillBuffer(buffer2->data(), kSize2, false); |
| base::strlcpy(buffer1->data(), "the data", kSize1); |
| EXPECT_EQ(17000, entry->WriteData(0, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback(), false)); |
| memset(buffer1->data(), 0, kSize1); |
| EXPECT_EQ(17000, entry->ReadData(0, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback())); |
| EXPECT_STREQ("the data", buffer1->data()); |
| |
| base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); |
| EXPECT_EQ(25000, entry->WriteData(1, 10000, buffer2.get(), kSize2, |
| net::CompletionOnceCallback(), false)); |
| memset(buffer2->data(), 0, kSize2); |
| EXPECT_EQ(24989, entry->ReadData(1, 10011, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_STREQ("big data goes here", buffer2->data()); |
| EXPECT_EQ(25000, entry->ReadData(1, 0, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(5000, entry->ReadData(1, 30000, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| |
| EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2.get(), kSize2, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(17000, entry->ReadData(1, 0, buffer1.get(), kSize1, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(17000, entry->WriteData(1, 20000, buffer1.get(), kSize1, |
| net::CompletionOnceCallback(), false)); |
| EXPECT_EQ(37000, entry->GetDataSize(1)); |
| |
| // We need to delete the memory buffer on this thread. |
| EXPECT_EQ( |
| 0, entry->WriteData(0, 0, NULL, 0, net::CompletionOnceCallback(), true)); |
| EXPECT_EQ( |
| 0, entry->WriteData(1, 0, NULL, 0, net::CompletionOnceCallback(), true)); |
| } |
| |
| void DiskCacheEntryTest::ExternalSyncIO() { |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| |
| // The bulk of the test runs from within the callback, on the cache thread. |
| RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground, |
| base::Unretained(this), |
| entry)); |
| |
| entry->Doom(); |
| entry->Close(); |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ExternalSyncIO) { |
| InitCache(); |
| ExternalSyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| ExternalSyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| ExternalSyncIO(); |
| } |
| |
| void DiskCacheEntryTest::ExternalAsyncIO() { |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| |
| int expected = 0; |
| |
| MessageLoopHelper helper; |
| // Let's verify that each IO goes to the right callback object. |
| CallbackTest callback1(&helper, false); |
| CallbackTest callback2(&helper, false); |
| CallbackTest callback3(&helper, false); |
| CallbackTest callback4(&helper, false); |
| CallbackTest callback5(&helper, false); |
| CallbackTest callback6(&helper, false); |
| CallbackTest callback7(&helper, false); |
| CallbackTest callback8(&helper, false); |
| CallbackTest callback9(&helper, false); |
| |
| const int kSize1 = 17000; |
| const int kSize2 = 25000; |
| const int kSize3 = 25000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| scoped_refptr<net::IOBuffer> buffer3 = |
| base::MakeRefCounted<net::IOBuffer>(kSize3); |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| CacheTestFillBuffer(buffer2->data(), kSize2, false); |
| CacheTestFillBuffer(buffer3->data(), kSize3, false); |
| base::strlcpy(buffer1->data(), "the data", kSize1); |
| int ret = entry->WriteData( |
| 0, |
| 0, |
| buffer1.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback1)), |
| false); |
| EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| |
| memset(buffer2->data(), 0, kSize1); |
| ret = entry->ReadData( |
| 0, |
| 0, |
| buffer2.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback2))); |
| EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_STREQ("the data", buffer2->data()); |
| |
| base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); |
| ret = entry->WriteData( |
| 1, |
| 10000, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback3)), |
| false); |
| EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| |
| memset(buffer3->data(), 0, kSize3); |
| ret = entry->ReadData( |
| 1, |
| 10011, |
| buffer3.get(), |
| kSize3, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback4))); |
| EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_STREQ("big data goes here", buffer3->data()); |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback5))); |
| EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| memset(buffer3->data(), 0, kSize3); |
| EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000)); |
| ret = entry->ReadData( |
| 1, |
| 30000, |
| buffer2.get(), |
| kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback6))); |
| EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| ret = entry->ReadData( |
| 1, 35000, buffer2.get(), kSize2, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback7))); |
| EXPECT_TRUE(0 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| ret = entry->ReadData( |
| 1, |
| 0, |
| buffer1.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback8))); |
| EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| ret = entry->WriteData( |
| 1, |
| 20000, |
| buffer3.get(), |
| kSize1, |
| base::Bind(&CallbackTest::Run, base::Unretained(&callback9)), |
| false); |
| EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); |
| if (net::ERR_IO_PENDING == ret) |
| expected++; |
| |
| EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); |
| EXPECT_EQ(37000, entry->GetDataSize(1)); |
| |
| EXPECT_FALSE(helper.callback_reused_error()); |
| |
| entry->Doom(); |
| entry->Close(); |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ExternalAsyncIO) { |
| InitCache(); |
| ExternalAsyncIO(); |
| } |
| |
| // TODO(http://crbug.com/497101): This test is flaky. |
| #if defined(OS_IOS) |
| #define MAYBE_ExternalAsyncIONoBuffer DISABLED_ExternalAsyncIONoBuffer |
| #else |
| #define MAYBE_ExternalAsyncIONoBuffer ExternalAsyncIONoBuffer |
| #endif |
| TEST_F(DiskCacheEntryTest, MAYBE_ExternalAsyncIONoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| ExternalAsyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| ExternalAsyncIO(); |
| } |
| |
| // Tests that IOBuffers are not referenced after IO completes. |
| void DiskCacheEntryTest::ReleaseBuffer(int stream_index) { |
| disk_cache::Entry* entry = NULL; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| ASSERT_TRUE(NULL != entry); |
| |
| const int kBufferSize = 1024; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kBufferSize); |
| CacheTestFillBuffer(buffer->data(), kBufferSize, false); |
| |
| net::ReleaseBufferCompletionCallback cb(buffer.get()); |
| int rv = entry->WriteData( |
| stream_index, 0, buffer.get(), kBufferSize, cb.callback(), false); |
| EXPECT_EQ(kBufferSize, cb.GetResult(rv)); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ReleaseBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| ReleaseBuffer(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| ReleaseBuffer(0); |
| } |
| |
| void DiskCacheEntryTest::StreamAccess() { |
| disk_cache::Entry* entry = NULL; |
| ASSERT_THAT(CreateEntry("the first key", &entry), IsOk()); |
| ASSERT_TRUE(NULL != entry); |
| |
| const int kBufferSize = 1024; |
| const int kNumStreams = 3; |
| scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams]; |
| for (int i = 0; i < kNumStreams; i++) { |
| reference_buffers[i] = base::MakeRefCounted<net::IOBuffer>(kBufferSize); |
| CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false); |
| } |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kBufferSize); |
| for (int i = 0; i < kNumStreams; i++) { |
| EXPECT_EQ( |
| kBufferSize, |
| WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false)); |
| memset(buffer1->data(), 0, kBufferSize); |
| EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize)); |
| EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer1->data(), |
| kBufferSize)); |
| } |
| EXPECT_EQ(net::ERR_INVALID_ARGUMENT, |
| ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize)); |
| entry->Close(); |
| |
| // Open the entry and read it in chunks, including a read past the end. |
| ASSERT_THAT(OpenEntry("the first key", &entry), IsOk()); |
| ASSERT_TRUE(NULL != entry); |
| const int kReadBufferSize = 600; |
| const int kFinalReadSize = kBufferSize - kReadBufferSize; |
| static_assert(kFinalReadSize < kReadBufferSize, |
| "should be exactly two reads"); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kReadBufferSize); |
| for (int i = 0; i < kNumStreams; i++) { |
| memset(buffer2->data(), 0, kReadBufferSize); |
| EXPECT_EQ(kReadBufferSize, |
| ReadData(entry, i, 0, buffer2.get(), kReadBufferSize)); |
| EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer2->data(), |
| kReadBufferSize)); |
| |
| memset(buffer2->data(), 0, kReadBufferSize); |
| EXPECT_EQ( |
| kFinalReadSize, |
| ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize)); |
| EXPECT_EQ(0, memcmp(reference_buffers[i]->data() + kReadBufferSize, |
| buffer2->data(), kFinalReadSize)); |
| } |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, StreamAccess) { |
| InitCache(); |
| StreamAccess(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| StreamAccess(); |
| } |
| |
| void DiskCacheEntryTest::GetKey() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_EQ(key, entry->GetKey()) << "short key"; |
| entry->Close(); |
| |
| int seed = static_cast<int>(Time::Now().ToInternalValue()); |
| srand(seed); |
| char key_buffer[20000]; |
| |
| CacheTestFillBuffer(key_buffer, 3000, true); |
| key_buffer[1000] = '\0'; |
| |
| key = key_buffer; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key"; |
| entry->Close(); |
| |
| key_buffer[1000] = 'p'; |
| key_buffer[3000] = '\0'; |
| key = key_buffer; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(key == entry->GetKey()) << "medium size key"; |
| entry->Close(); |
| |
| CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true); |
| key_buffer[19999] = '\0'; |
| |
| key = key_buffer; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(key == entry->GetKey()) << "long key"; |
| entry->Close(); |
| |
| CacheTestFillBuffer(key_buffer, 0x4000, true); |
| key_buffer[0x4000] = '\0'; |
| |
| key = key_buffer; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(key == entry->GetKey()) << "16KB key"; |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GetKey) { |
| InitCache(); |
| GetKey(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| GetKey(); |
| } |
| |
| void DiskCacheEntryTest::GetTimes(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| |
| Time t1 = Time::Now(); |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(entry->GetLastModified() >= t1); |
| EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed()); |
| |
| AddDelay(); |
| Time t2 = Time::Now(); |
| EXPECT_TRUE(t2 > t1); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 200, NULL, 0, false)); |
| if (type_ == net::APP_CACHE) { |
| EXPECT_TRUE(entry->GetLastModified() < t2); |
| } else { |
| EXPECT_TRUE(entry->GetLastModified() >= t2); |
| } |
| EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed()); |
| |
| AddDelay(); |
| Time t3 = Time::Now(); |
| EXPECT_TRUE(t3 > t2); |
| const int kSize = 200; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 0, buffer.get(), kSize)); |
| if (type_ == net::APP_CACHE) { |
| EXPECT_TRUE(entry->GetLastUsed() < t2); |
| EXPECT_TRUE(entry->GetLastModified() < t2); |
| } else if (type_ == net::SHADER_CACHE) { |
| EXPECT_TRUE(entry->GetLastUsed() < t3); |
| EXPECT_TRUE(entry->GetLastModified() < t3); |
| } else { |
| EXPECT_TRUE(entry->GetLastUsed() >= t3); |
| EXPECT_TRUE(entry->GetLastModified() < t3); |
| } |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GetTimes) { |
| InitCache(); |
| GetTimes(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| GetTimes(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, AppCacheGetTimes) { |
| SetCacheType(net::APP_CACHE); |
| InitCache(); |
| GetTimes(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes) { |
| SetCacheType(net::SHADER_CACHE); |
| InitCache(); |
| GetTimes(0); |
| } |
| |
| void DiskCacheEntryTest::GrowData(int stream_index) { |
| std::string key1("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key1, &entry), IsOk()); |
| |
| const int kSize = 20000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer1->data(), kSize, false); |
| memset(buffer2->data(), 0, kSize); |
| |
| base::strlcpy(buffer1->data(), "the data", kSize); |
| EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false)); |
| EXPECT_EQ(10, ReadData(entry, stream_index, 0, buffer2.get(), 10)); |
| EXPECT_STREQ("the data", buffer2->data()); |
| EXPECT_EQ(10, entry->GetDataSize(stream_index)); |
| |
| EXPECT_EQ(2000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 2000, false)); |
| EXPECT_EQ(2000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); |
| |
| EXPECT_EQ(20000, |
| WriteData(entry, stream_index, 0, buffer1.get(), kSize, false)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); |
| entry->Close(); |
| |
| memset(buffer2->data(), 0, kSize); |
| std::string key2("Second key"); |
| ASSERT_THAT(CreateEntry(key2, &entry), IsOk()); |
| EXPECT_EQ(10, WriteData(entry, stream_index, 0, buffer1.get(), 10, false)); |
| EXPECT_EQ(10, entry->GetDataSize(stream_index)); |
| entry->Close(); |
| |
| // Go from an internal address to a bigger block size. |
| ASSERT_THAT(OpenEntry(key2, &entry), IsOk()); |
| EXPECT_EQ(2000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 2000, false)); |
| EXPECT_EQ(2000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); |
| entry->Close(); |
| memset(buffer2->data(), 0, kSize); |
| |
| // Go from an internal address to an external one. |
| ASSERT_THAT(OpenEntry(key2, &entry), IsOk()); |
| EXPECT_EQ(20000, |
| WriteData(entry, stream_index, 0, buffer1.get(), kSize, false)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); |
| entry->Close(); |
| |
| // Double check the size from disk. |
| ASSERT_THAT(OpenEntry(key2, &entry), IsOk()); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| |
| // Now extend the entry without actual data. |
| EXPECT_EQ(0, WriteData(entry, stream_index, 45500, buffer1.get(), 0, false)); |
| entry->Close(); |
| |
| // And check again from disk. |
| ASSERT_THAT(OpenEntry(key2, &entry), IsOk()); |
| EXPECT_EQ(45500, entry->GetDataSize(stream_index)); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GrowData) { |
| InitCache(); |
| GrowData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| GrowData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| GrowData(0); |
| } |
| |
| void DiskCacheEntryTest::TruncateData(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize1 = 20000; |
| const int kSize2 = 20000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| memset(buffer2->data(), 0, kSize2); |
| |
| // Simple truncation: |
| EXPECT_EQ(200, WriteData(entry, stream_index, 0, buffer1.get(), 200, false)); |
| EXPECT_EQ(200, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, false)); |
| EXPECT_EQ(200, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(100, WriteData(entry, stream_index, 0, buffer1.get(), 100, true)); |
| EXPECT_EQ(100, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 50, buffer1.get(), 0, true)); |
| EXPECT_EQ(50, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true)); |
| EXPECT_EQ(0, entry->GetDataSize(stream_index)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| |
| // Go to an external file. |
| EXPECT_EQ(20000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 20000, true)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(20000, ReadData(entry, stream_index, 0, buffer2.get(), 20000)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000)); |
| memset(buffer2->data(), 0, kSize2); |
| |
| // External file truncation |
| EXPECT_EQ(18000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 18000, false)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(18000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 18000, true)); |
| EXPECT_EQ(18000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 17500, buffer1.get(), 0, true)); |
| EXPECT_EQ(17500, entry->GetDataSize(stream_index)); |
| |
| // And back to an internal block. |
| EXPECT_EQ(600, |
| WriteData(entry, stream_index, 1000, buffer1.get(), 600, true)); |
| EXPECT_EQ(1600, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer2.get(), 600)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600)); |
| EXPECT_EQ(1000, ReadData(entry, stream_index, 0, buffer2.get(), 1000)); |
| EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) |
| << "Preserves previous data"; |
| |
| // Go from external file to zero length. |
| EXPECT_EQ(20000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 20000, true)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer1.get(), 0, true)); |
| EXPECT_EQ(0, entry->GetDataSize(stream_index)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, TruncateData) { |
| InitCache(); |
| TruncateData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| TruncateData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| TruncateData(0); |
| } |
| |
| void DiskCacheEntryTest::ZeroLengthIO(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| EXPECT_EQ(0, ReadData(entry, stream_index, 0, NULL, 0)); |
| EXPECT_EQ(0, WriteData(entry, stream_index, 0, NULL, 0, false)); |
| |
| // This write should extend the entry. |
| EXPECT_EQ(0, WriteData(entry, stream_index, 1000, NULL, 0, false)); |
| EXPECT_EQ(0, ReadData(entry, stream_index, 500, NULL, 0)); |
| EXPECT_EQ(0, ReadData(entry, stream_index, 2000, NULL, 0)); |
| EXPECT_EQ(1000, entry->GetDataSize(stream_index)); |
| |
| EXPECT_EQ(0, WriteData(entry, stream_index, 100000, NULL, 0, true)); |
| EXPECT_EQ(0, ReadData(entry, stream_index, 50000, NULL, 0)); |
| EXPECT_EQ(100000, entry->GetDataSize(stream_index)); |
| |
| // Let's verify the actual content. |
| const int kSize = 20; |
| const char zeros[kSize] = {}; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 500, buffer.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); |
| |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 5000, buffer.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); |
| |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 50000, buffer.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ZeroLengthIO) { |
| InitCache(); |
| ZeroLengthIO(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| ZeroLengthIO(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| ZeroLengthIO(0); |
| } |
| |
| // Tests that we handle the content correctly when buffering, a feature of the |
| // standard cache that permits fast responses to certain reads. |
| void DiskCacheEntryTest::Buffering() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 200; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer1->data(), kSize, true); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| |
| EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false)); |
| entry->Close(); |
| |
| // Write a little more and read what we wrote before. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false)); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| |
| // Now go to an external file. |
| EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false)); |
| entry->Close(); |
| |
| // Write something else and verify old data. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| |
| // Extend the file some more. |
| EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false)); |
| entry->Close(); |
| |
| // And now make sure that we can deal with data in both places (ram/disk). |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false)); |
| |
| // We should not overwrite the data at 18000 with this. |
| EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| |
| EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100)); |
| |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100)); |
| |
| // Extend the file again and read before without closing the entry. |
| EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false)); |
| EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, Buffering) { |
| InitCache(); |
| Buffering(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, BufferingNoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| Buffering(); |
| } |
| |
| // Checks that entries are zero length when created. |
| void DiskCacheEntryTest::SizeAtCreate() { |
| const char key[] = "the first key"; |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kNumStreams = 3; |
| for (int i = 0; i < kNumStreams; ++i) |
| EXPECT_EQ(0, entry->GetDataSize(i)); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SizeAtCreate) { |
| InitCache(); |
| SizeAtCreate(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| SizeAtCreate(); |
| } |
| |
| // Some extra tests to make sure that buffering works properly when changing |
| // the entry size. |
| void DiskCacheEntryTest::SizeChanges(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 200; |
| const char zeros[kSize] = {}; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer1->data(), kSize, true); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 0, buffer1.get(), kSize, true)); |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 17000, buffer1.get(), kSize, true)); |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 23000, buffer1.get(), kSize, true)); |
| entry->Close(); |
| |
| // Extend the file and read between the old size and the new write. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(23000 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true)); |
| EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 24000, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize)); |
| |
| // Read at the end of the old file size. |
| EXPECT_EQ( |
| kSize, |
| ReadData(entry, stream_index, 23000 + kSize - 35, buffer2.get(), kSize)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35)); |
| |
| // Read slightly before the last write. |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 24900, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); |
| |
| // Extend the entry a little more. |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 26000, buffer1.get(), kSize, true)); |
| EXPECT_EQ(26000 + kSize, entry->GetDataSize(stream_index)); |
| CacheTestFillBuffer(buffer2->data(), kSize, true); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 25900, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); |
| |
| // And now reduce the size. |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 25000, buffer1.get(), kSize, true)); |
| EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ( |
| 28, |
| ReadData(entry, stream_index, 25000 + kSize - 28, buffer2.get(), kSize)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28)); |
| |
| // Reduce the size with a buffer that is not extending the size. |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 24000, buffer1.get(), kSize, false)); |
| EXPECT_EQ(25000 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 24500, buffer1.get(), kSize, true)); |
| EXPECT_EQ(24500 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 23900, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); |
| |
| // And now reduce the size below the old size. |
| EXPECT_EQ(kSize, |
| WriteData(entry, stream_index, 19000, buffer1.get(), kSize, true)); |
| EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(kSize, ReadData(entry, stream_index, 18900, buffer2.get(), kSize)); |
| EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); |
| EXPECT_TRUE( |
| !memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); |
| |
| // Verify that the actual file is truncated. |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(19000 + kSize, entry->GetDataSize(stream_index)); |
| |
| // Extend the newly opened file with a zero length write, expect zero fill. |
| EXPECT_EQ( |
| 0, |
| WriteData(entry, stream_index, 20000 + kSize, buffer1.get(), 0, false)); |
| EXPECT_EQ(kSize, |
| ReadData(entry, stream_index, 19000 + kSize, buffer1.get(), kSize)); |
| EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SizeChanges) { |
| InitCache(); |
| SizeChanges(1); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| SizeChanges(1); |
| } |
| |
| // Write more than the total cache capacity but to a single entry. |size| is the |
| // amount of bytes to write each time. |
| void DiskCacheEntryTest::ReuseEntry(int size, int stream_index) { |
| std::string key1("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key1, &entry), IsOk()); |
| |
| entry->Close(); |
| std::string key2("the second key"); |
| ASSERT_THAT(CreateEntry(key2, &entry), IsOk()); |
| |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(size); |
| CacheTestFillBuffer(buffer->data(), size, false); |
| |
| for (int i = 0; i < 15; i++) { |
| EXPECT_EQ(0, WriteData(entry, stream_index, 0, buffer.get(), 0, true)); |
| EXPECT_EQ(size, |
| WriteData(entry, stream_index, 0, buffer.get(), size, false)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key2, &entry), IsOk()); |
| } |
| |
| entry->Close(); |
| ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry"; |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ReuseExternalEntry) { |
| SetMaxSize(200 * 1024); |
| InitCache(); |
| ReuseEntry(20 * 1024, 0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) { |
| SetMemoryOnlyMode(); |
| SetMaxSize(200 * 1024); |
| InitCache(); |
| ReuseEntry(20 * 1024, 0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ReuseInternalEntry) { |
| SetMaxSize(100 * 1024); |
| InitCache(); |
| ReuseEntry(10 * 1024, 0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) { |
| SetMemoryOnlyMode(); |
| SetMaxSize(100 * 1024); |
| InitCache(); |
| ReuseEntry(10 * 1024, 0); |
| } |
| |
| // Reading somewhere that was not written should return zeros. |
| void DiskCacheEntryTest::InvalidData(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize1 = 20000; |
| const int kSize2 = 20000; |
| const int kSize3 = 20000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| scoped_refptr<net::IOBuffer> buffer3 = |
| base::MakeRefCounted<net::IOBuffer>(kSize3); |
| |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| memset(buffer2->data(), 0, kSize2); |
| |
| // Simple data grow: |
| EXPECT_EQ(200, |
| WriteData(entry, stream_index, 400, buffer1.get(), 200, false)); |
| EXPECT_EQ(600, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(100, ReadData(entry, stream_index, 300, buffer3.get(), 100)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| |
| // The entry is now on disk. Load it and extend it. |
| EXPECT_EQ(200, |
| WriteData(entry, stream_index, 800, buffer1.get(), 200, false)); |
| EXPECT_EQ(1000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(100, ReadData(entry, stream_index, 700, buffer3.get(), 100)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| |
| // This time using truncate. |
| EXPECT_EQ(200, |
| WriteData(entry, stream_index, 1800, buffer1.get(), 200, true)); |
| EXPECT_EQ(2000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(100, ReadData(entry, stream_index, 1500, buffer3.get(), 100)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); |
| |
| // Go to an external file. |
| EXPECT_EQ(200, |
| WriteData(entry, stream_index, 19800, buffer1.get(), 200, false)); |
| EXPECT_EQ(20000, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(4000, ReadData(entry, stream_index, 14000, buffer3.get(), 4000)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000)); |
| |
| // And back to an internal block. |
| EXPECT_EQ(600, |
| WriteData(entry, stream_index, 1000, buffer1.get(), 600, true)); |
| EXPECT_EQ(1600, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(600, ReadData(entry, stream_index, 1000, buffer3.get(), 600)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600)); |
| |
| // Extend it again. |
| EXPECT_EQ(600, |
| WriteData(entry, stream_index, 2000, buffer1.get(), 600, false)); |
| EXPECT_EQ(2600, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(200, ReadData(entry, stream_index, 1800, buffer3.get(), 200)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200)); |
| |
| // And again (with truncation flag). |
| EXPECT_EQ(600, |
| WriteData(entry, stream_index, 3000, buffer1.get(), 600, true)); |
| EXPECT_EQ(3600, entry->GetDataSize(stream_index)); |
| EXPECT_EQ(200, ReadData(entry, stream_index, 2800, buffer3.get(), 200)); |
| EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, InvalidData) { |
| InitCache(); |
| InvalidData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) { |
| InitCache(); |
| cache_impl_->SetFlags(disk_cache::kNoBuffering); |
| InvalidData(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| InvalidData(0); |
| } |
| |
| // Tests that the cache preserves the buffer of an IO operation. |
| void DiskCacheEntryTest::ReadWriteDestroyBuffer(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 200; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| |
| net::TestCompletionCallback cb; |
| EXPECT_EQ(net::ERR_IO_PENDING, |
| entry->WriteData( |
| stream_index, 0, buffer.get(), kSize, cb.callback(), false)); |
| |
| // Release our reference to the buffer. |
| buffer = NULL; |
| EXPECT_EQ(kSize, cb.WaitForResult()); |
| |
| // And now test with a Read(). |
| buffer = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| |
| EXPECT_EQ( |
| net::ERR_IO_PENDING, |
| entry->ReadData(stream_index, 0, buffer.get(), kSize, cb.callback())); |
| buffer = NULL; |
| EXPECT_EQ(kSize, cb.WaitForResult()); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) { |
| InitCache(); |
| ReadWriteDestroyBuffer(0); |
| } |
| |
| void DiskCacheEntryTest::DoomNormalEntry() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| entry->Doom(); |
| entry->Close(); |
| |
| const int kSize = 20000; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer->data(), kSize, true); |
| buffer->data()[19999] = '\0'; |
| |
| key = buffer->data(); |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false)); |
| EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false)); |
| entry->Doom(); |
| entry->Close(); |
| |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, DoomEntry) { |
| InitCache(); |
| DoomNormalEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| DoomNormalEntry(); |
| } |
| |
| // Tests dooming an entry that's linked to an open entry. |
| void DiskCacheEntryTest::DoomEntryNextToOpenEntry() { |
| disk_cache::Entry* entry1; |
| disk_cache::Entry* entry2; |
| ASSERT_THAT(CreateEntry("fixed", &entry1), IsOk()); |
| entry1->Close(); |
| ASSERT_THAT(CreateEntry("foo", &entry1), IsOk()); |
| entry1->Close(); |
| ASSERT_THAT(CreateEntry("bar", &entry1), IsOk()); |
| entry1->Close(); |
| |
| ASSERT_THAT(OpenEntry("foo", &entry1), IsOk()); |
| ASSERT_THAT(OpenEntry("bar", &entry2), IsOk()); |
| entry2->Doom(); |
| entry2->Close(); |
| |
| ASSERT_THAT(OpenEntry("foo", &entry2), IsOk()); |
| entry2->Doom(); |
| entry2->Close(); |
| entry1->Close(); |
| |
| ASSERT_THAT(OpenEntry("fixed", &entry1), IsOk()); |
| entry1->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) { |
| InitCache(); |
| DoomEntryNextToOpenEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) { |
| SetNewEviction(); |
| InitCache(); |
| DoomEntryNextToOpenEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) { |
| SetCacheType(net::APP_CACHE); |
| InitCache(); |
| DoomEntryNextToOpenEntry(); |
| } |
| |
| // Verify that basic operations work as expected with doomed entries. |
| void DiskCacheEntryTest::DoomedEntry(int stream_index) { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| entry->Doom(); |
| |
| FlushQueueForTest(); |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| Time initial = Time::Now(); |
| AddDelay(); |
| |
| const int kSize1 = 2000; |
| const int kSize2 = 2000; |
| scoped_refptr<net::IOBuffer> buffer1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize1); |
| scoped_refptr<net::IOBuffer> buffer2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize2); |
| CacheTestFillBuffer(buffer1->data(), kSize1, false); |
| memset(buffer2->data(), 0, kSize2); |
| |
| EXPECT_EQ(2000, |
| WriteData(entry, stream_index, 0, buffer1.get(), 2000, false)); |
| EXPECT_EQ(2000, ReadData(entry, stream_index, 0, buffer2.get(), 2000)); |
| EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1)); |
| EXPECT_EQ(key, entry->GetKey()); |
| EXPECT_TRUE(initial < entry->GetLastModified()); |
| EXPECT_TRUE(initial < entry->GetLastUsed()); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, DoomedEntry) { |
| InitCache(); |
| DoomedEntry(0); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| DoomedEntry(0); |
| } |
| |
| // Tests that we discard entries if the data is missing. |
| TEST_F(DiskCacheEntryTest, MissingData) { |
| InitCache(); |
| |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| // Write to an external file. |
| const int kSize = 20000; |
| scoped_refptr<net::IOBuffer> buffer = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buffer->data(), kSize, false); |
| EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false)); |
| entry->Close(); |
| FlushQueueForTest(); |
| |
| disk_cache::Addr address(0x80000001); |
| base::FilePath name = cache_impl_->GetFileName(address); |
| EXPECT_TRUE(base::DeleteFile(name, false)); |
| |
| // Attempt to read the data. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_EQ(net::ERR_FILE_NOT_FOUND, |
| ReadData(entry, 0, 0, buffer.get(), kSize)); |
| entry->Close(); |
| |
| // The entry should be gone. |
| ASSERT_NE(net::OK, OpenEntry(key, &entry)); |
| } |
| |
| // Test that child entries in a memory cache backend are not visible from |
| // enumerations. |
| TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| |
| const int kSize = 4096; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| std::string key("the first key"); |
| disk_cache::Entry* parent_entry; |
| ASSERT_THAT(CreateEntry(key, &parent_entry), IsOk()); |
| |
| // Writes to the parent entry. |
| EXPECT_EQ(kSize, parent_entry->WriteSparseData( |
| 0, buf.get(), kSize, net::CompletionOnceCallback())); |
| |
| // This write creates a child entry and writes to it. |
| EXPECT_EQ(kSize, parent_entry->WriteSparseData( |
| 8192, buf.get(), kSize, net::CompletionOnceCallback())); |
| |
| parent_entry->Close(); |
| |
| // Perform the enumerations. |
| std::unique_ptr<TestIterator> iter = CreateIterator(); |
| disk_cache::Entry* entry = NULL; |
| int count = 0; |
| while (iter->OpenNextEntry(&entry) == net::OK) { |
| ASSERT_TRUE(entry != NULL); |
| ++count; |
| disk_cache::MemEntryImpl* mem_entry = |
| reinterpret_cast<disk_cache::MemEntryImpl*>(entry); |
| EXPECT_EQ(disk_cache::MemEntryImpl::PARENT_ENTRY, mem_entry->type()); |
| mem_entry->Close(); |
| } |
| EXPECT_EQ(1, count); |
| } |
| |
| // Writes |buf_1| to offset and reads it back as |buf_2|. |
| void VerifySparseIO(disk_cache::Entry* entry, |
| int64_t offset, |
| net::IOBuffer* buf_1, |
| int size, |
| net::IOBuffer* buf_2) { |
| net::TestCompletionCallback cb; |
| |
| memset(buf_2->data(), 0, size); |
| int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(ret)); |
| |
| ret = entry->WriteSparseData(offset, buf_1, size, cb.callback()); |
| EXPECT_EQ(size, cb.GetResult(ret)); |
| |
| ret = entry->ReadSparseData(offset, buf_2, size, cb.callback()); |
| EXPECT_EQ(size, cb.GetResult(ret)); |
| |
| EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size)); |
| } |
| |
| // Reads |size| bytes from |entry| at |offset| and verifies that they are the |
| // same as the content of the provided |buffer|. |
| void VerifyContentSparseIO(disk_cache::Entry* entry, |
| int64_t offset, |
| char* buffer, |
| int size) { |
| net::TestCompletionCallback cb; |
| |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(size); |
| memset(buf_1->data(), 0, size); |
| int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback()); |
| EXPECT_EQ(size, cb.GetResult(ret)); |
| EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size)); |
| } |
| |
| void DiskCacheEntryTest::BasicSparseIO() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 2048; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| // Write at offset 0. |
| VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get()); |
| |
| // Write at offset 0x400000 (4 MB). |
| VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get()); |
| |
| // Write at offset 0x800000000 (32 GB). |
| VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get()); |
| |
| entry->Close(); |
| |
| // Check everything again. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| VerifyContentSparseIO(entry, 0, buf_1->data(), kSize); |
| VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize); |
| VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, BasicSparseIO) { |
| InitCache(); |
| BasicSparseIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| BasicSparseIO(); |
| } |
| |
| void DiskCacheEntryTest::HugeSparseIO() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| // Write 1.2 MB so that we cover multiple entries. |
| const int kSize = 1200 * 1024; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| // Write at offset 0x20F0000 (33 MB - 64 KB). |
| VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get()); |
| entry->Close(); |
| |
| // Check it again. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, HugeSparseIO) { |
| InitCache(); |
| HugeSparseIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| HugeSparseIO(); |
| } |
| |
| void DiskCacheEntryTest::GetAvailableRange() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 16 * 1024; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB). |
| EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize)); |
| EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize)); |
| |
| // We stop at the first empty block. |
| int64_t start; |
| net::TestCompletionCallback cb; |
| int rv = entry->GetAvailableRange( |
| 0x20F0000, kSize * 2, &start, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(0x20F0000, start); |
| |
| start = 0; |
| rv = entry->GetAvailableRange(0, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| rv = entry->GetAvailableRange( |
| 0x20F0000 - kSize, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(0x20F0000, start); |
| |
| // We should be able to Read based on the results of GetAvailableRange. |
| start = -1; |
| rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| |
| start = 0; |
| rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback()); |
| EXPECT_EQ(0x2000, cb.GetResult(rv)); |
| EXPECT_EQ(0x20F2000, start); |
| EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize)); |
| |
| // Make sure that we respect the |len| argument. |
| start = 0; |
| rv = entry->GetAvailableRange( |
| 0x20F0001 - kSize, kSize, &start, cb.callback()); |
| EXPECT_EQ(1, cb.GetResult(rv)); |
| EXPECT_EQ(0x20F0000, start); |
| |
| // Use very small ranges. Write at offset 50. |
| const int kTinyLen = 10; |
| EXPECT_EQ(kTinyLen, WriteSparseData(entry, 50, buf.get(), kTinyLen)); |
| |
| start = -1; |
| rv = entry->GetAvailableRange(kTinyLen * 2, kTinyLen, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| EXPECT_EQ(kTinyLen * 2, start); |
| |
| // Get a huge range with maximum boundary |
| start = -1; |
| rv = entry->GetAvailableRange(0x2100000, std::numeric_limits<int32_t>::max(), |
| &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GetAvailableRange) { |
| InitCache(); |
| GetAvailableRange(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| GetAvailableRange(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, GetAvailableRangeBlockFileDiscontinuous) { |
| // crbug.com/791056 --- blockfile problem when there is a sub-KiB write before |
| // a bunch of full 1KiB blocks, and a GetAvailableRange is issued to which |
| // both are a potentially relevant. |
| InitCache(); |
| |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| scoped_refptr<net::IOBuffer> buf_2k = |
| base::MakeRefCounted<net::IOBuffer>(2 * 1024); |
| CacheTestFillBuffer(buf_2k->data(), 2 * 1024, false); |
| |
| const int kSmallSize = 612; // sub-1k |
| scoped_refptr<net::IOBuffer> buf_small = |
| base::MakeRefCounted<net::IOBuffer>(kSmallSize); |
| CacheTestFillBuffer(buf_small->data(), kSmallSize, false); |
| |
| // Sets some bits for blocks representing 1K ranges [1024, 3072), |
| // which will be relevant for the next GetAvailableRange call. |
| EXPECT_EQ(2 * 1024, WriteSparseData(entry, /* offset = */ 1024, buf_2k.get(), |
| /* size = */ 2 * 1024)); |
| |
| // Now record a partial write from start of the first kb. |
| EXPECT_EQ(kSmallSize, WriteSparseData(entry, /* offset = */ 0, |
| buf_small.get(), kSmallSize)); |
| |
| // Try to query a range starting from that block 0. |
| // The cache tracks: [0, 612) [1024, 3072). |
| // The request is for: [812, 2059) so response should be [1024, 2059), which |
| // has lenth = 1035. Previously this return a negative number for rv. |
| int64_t start = -1; |
| net::TestCompletionCallback cb; |
| int rv = entry->GetAvailableRange(812, 1247, &start, cb.callback()); |
| EXPECT_EQ(1035, cb.GetResult(rv)); |
| EXPECT_EQ(1024, start); |
| |
| // Now query [512, 1536). This matches both [512, 612) and [1024, 1536), |
| // so this should return [512, 612). |
| rv = entry->GetAvailableRange(512, 1024, &start, cb.callback()); |
| EXPECT_EQ(100, cb.GetResult(rv)); |
| EXPECT_EQ(512, start); |
| |
| // Now query next portion, [612, 1636). This now just should produce |
| // [1024, 1636) |
| rv = entry->GetAvailableRange(612, 1024, &start, cb.callback()); |
| EXPECT_EQ(612, cb.GetResult(rv)); |
| EXPECT_EQ(1024, start); |
| |
| // Do a continuous small write, this one at [3072, 3684). |
| // This means the cache tracks [1024, 3072) via bitmaps and [3072, 3684) |
| // as the last write. |
| EXPECT_EQ(kSmallSize, WriteSparseData(entry, /* offset = */ 3072, |
| buf_small.get(), kSmallSize)); |
| |
| // Query [2048, 4096). Should get [2048, 3684) |
| rv = entry->GetAvailableRange(2048, 2048, &start, cb.callback()); |
| EXPECT_EQ(1636, cb.GetResult(rv)); |
| EXPECT_EQ(2048, start); |
| |
| // Now write at [4096, 4708). Since only one sub-kb thing is tracked, this |
| // now tracks [1024, 3072) via bitmaps and [4096, 4708) as the last write. |
| EXPECT_EQ(kSmallSize, WriteSparseData(entry, /* offset = */ 4096, |
| buf_small.get(), kSmallSize)); |
| |
| // Query [2048, 4096). Should get [2048, 3072) |
| rv = entry->GetAvailableRange(2048, 2048, &start, cb.callback()); |
| EXPECT_EQ(1024, cb.GetResult(rv)); |
| EXPECT_EQ(2048, start); |
| |
| // Query 2K more after that: [3072, 5120). Should get [4096, 4708) |
| rv = entry->GetAvailableRange(3072, 2048, &start, cb.callback()); |
| EXPECT_EQ(612, cb.GetResult(rv)); |
| EXPECT_EQ(4096, start); |
| |
| // Also double-check that offsets within later children are correctly |
| // computed. |
| EXPECT_EQ(kSmallSize, WriteSparseData(entry, /* offset = */ 0x200400, |
| buf_small.get(), kSmallSize)); |
| rv = entry->GetAvailableRange(0x100000, 0x200000, &start, cb.callback()); |
| EXPECT_EQ(kSmallSize, cb.GetResult(rv)); |
| EXPECT_EQ(0x200400, start); |
| |
| entry->Close(); |
| } |
| |
| // Tests that non-sequential writes that are not aligned with the minimum sparse |
| // data granularity (1024 bytes) do in fact result in dropped data. |
| TEST_F(DiskCacheEntryTest, SparseWriteDropped) { |
| InitCache(); |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 180; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| // Do small writes (180 bytes) that get increasingly close to a 1024-byte |
| // boundary. All data should be dropped until a boundary is crossed, at which |
| // point the data after the boundary is saved (at least for a while). |
| int offset = 1024 - 500; |
| int rv = 0; |
| net::TestCompletionCallback cb; |
| int64_t start; |
| for (int i = 0; i < 5; i++) { |
| // Check result of last GetAvailableRange. |
| EXPECT_EQ(0, rv); |
| |
| rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| |
| rv = entry->GetAvailableRange(offset - 100, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| |
| rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback()); |
| rv = cb.GetResult(rv); |
| if (!rv) { |
| rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| rv = 0; |
| } |
| offset += 1024 * i + 100; |
| } |
| |
| // The last write started 100 bytes below a bundary, so there should be 80 |
| // bytes after the boundary. |
| EXPECT_EQ(80, rv); |
| EXPECT_EQ(1024 * 7, start); |
| rv = entry->ReadSparseData(start, buf_2.get(), kSize, cb.callback()); |
| EXPECT_EQ(80, cb.GetResult(rv)); |
| EXPECT_EQ( |
| 0, memcmp(buf_1.get()->data() + 100, buf_2.get()->data(), 80)); |
| |
| // And even that part is dropped when another write changes the offset. |
| offset = start; |
| rv = entry->WriteSparseData(0, buf_1.get(), kSize, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| |
| rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| entry->Close(); |
| } |
| |
| // Tests that small sequential writes are not dropped. |
| TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped) { |
| InitCache(); |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 180; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| // Any starting offset is fine as long as it is 1024-bytes aligned. |
| int rv = 0; |
| net::TestCompletionCallback cb; |
| int64_t start; |
| int64_t offset = 1024 * 11; |
| for (; offset < 20000; offset += kSize) { |
| rv = entry->WriteSparseData(offset, buf_1.get(), kSize, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| |
| rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(offset, start); |
| |
| rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(0, |
| memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize)); |
| } |
| |
| entry->Close(); |
| FlushQueueForTest(); |
| |
| // Verify again the last write made. |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| offset -= kSize; |
| rv = entry->GetAvailableRange(offset, kSize, &start, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(offset, start); |
| |
| rv = entry->ReadSparseData(offset, buf_2.get(), kSize, cb.callback()); |
| EXPECT_EQ(kSize, cb.GetResult(rv)); |
| EXPECT_EQ(0, |
| memcmp(buf_1.get()->data(), buf_2.get()->data(), kSize)); |
| |
| entry->Close(); |
| } |
| |
| void DiskCacheEntryTest::CouldBeSparse() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 16 * 1024; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| // Write at offset 0x20F0000 (33 MB - 64 KB). |
| EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize)); |
| |
| EXPECT_TRUE(entry->CouldBeSparse()); |
| entry->Close(); |
| |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_TRUE(entry->CouldBeSparse()); |
| entry->Close(); |
| |
| // Now verify a regular entry. |
| key.assign("another key"); |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| EXPECT_FALSE(entry->CouldBeSparse()); |
| |
| EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false)); |
| EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false)); |
| EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false)); |
| |
| EXPECT_FALSE(entry->CouldBeSparse()); |
| entry->Close(); |
| |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| EXPECT_FALSE(entry->CouldBeSparse()); |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, CouldBeSparse) { |
| InitCache(); |
| CouldBeSparse(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| CouldBeSparse(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| |
| const int kSize = 8192; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| // This loop writes back to back starting from offset 0 and 9000. |
| for (int i = 0; i < kSize; i += 1024) { |
| scoped_refptr<net::WrappedIOBuffer> buf_3 = |
| base::MakeRefCounted<net::WrappedIOBuffer>(buf_1->data() + i); |
| VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get()); |
| VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get()); |
| } |
| |
| // Make sure we have data written. |
| VerifyContentSparseIO(entry, 0, buf_1->data(), kSize); |
| VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize); |
| |
| // This tests a large write that spans 3 entries from a misaligned offset. |
| VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get()); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| |
| const int kSize = 8192; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| disk_cache::Entry* entry; |
| std::string key("the first key"); |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| // Writes in the middle of an entry. |
| EXPECT_EQ(1024, entry->WriteSparseData(0, buf.get(), 1024, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(1024, entry->WriteSparseData(5120, buf.get(), 1024, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(1024, entry->WriteSparseData(10000, buf.get(), 1024, |
| net::CompletionOnceCallback())); |
| |
| // Writes in the middle of an entry and spans 2 child entries. |
| EXPECT_EQ(8192, entry->WriteSparseData(50000, buf.get(), 8192, |
| net::CompletionOnceCallback())); |
| |
| int64_t start; |
| net::TestCompletionCallback cb; |
| // Test that we stop at a discontinuous child at the second block. |
| int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback()); |
| EXPECT_EQ(1024, cb.GetResult(rv)); |
| EXPECT_EQ(0, start); |
| |
| // Test that number of bytes is reported correctly when we start from the |
| // middle of a filled region. |
| rv = entry->GetAvailableRange(512, 10000, &start, cb.callback()); |
| EXPECT_EQ(512, cb.GetResult(rv)); |
| EXPECT_EQ(512, start); |
| |
| // Test that we found bytes in the child of next block. |
| rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback()); |
| EXPECT_EQ(1024, cb.GetResult(rv)); |
| EXPECT_EQ(5120, start); |
| |
| // Test that the desired length is respected. It starts within a filled |
| // region. |
| rv = entry->GetAvailableRange(5500, 512, &start, cb.callback()); |
| EXPECT_EQ(512, cb.GetResult(rv)); |
| EXPECT_EQ(5500, start); |
| |
| // Test that the desired length is respected. It starts before a filled |
| // region. |
| rv = entry->GetAvailableRange(5000, 620, &start, cb.callback()); |
| EXPECT_EQ(500, cb.GetResult(rv)); |
| EXPECT_EQ(5120, start); |
| |
| // Test that multiple blocks are scanned. |
| rv = entry->GetAvailableRange(40000, 20000, &start, cb.callback()); |
| EXPECT_EQ(8192, cb.GetResult(rv)); |
| EXPECT_EQ(50000, start); |
| |
| entry->Close(); |
| } |
| |
| void DiskCacheEntryTest::UpdateSparseEntry() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry1; |
| ASSERT_THAT(CreateEntry(key, &entry1), IsOk()); |
| |
| const int kSize = 2048; |
| scoped_refptr<net::IOBuffer> buf_1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| scoped_refptr<net::IOBuffer> buf_2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf_1->data(), kSize, false); |
| |
| // Write at offset 0. |
| VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get()); |
| entry1->Close(); |
| |
| // Write at offset 2048. |
| ASSERT_THAT(OpenEntry(key, &entry1), IsOk()); |
| VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get()); |
| |
| disk_cache::Entry* entry2; |
| ASSERT_THAT(CreateEntry("the second key", &entry2), IsOk()); |
| |
| entry1->Close(); |
| entry2->Close(); |
| FlushQueueForTest(); |
| if (memory_only_ || simple_cache_mode_) |
| EXPECT_EQ(2, cache_->GetEntryCount()); |
| else |
| EXPECT_EQ(3, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, UpdateSparseEntry) { |
| SetCacheType(net::MEDIA_CACHE); |
| InitCache(); |
| UpdateSparseEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) { |
| SetMemoryOnlyMode(); |
| SetCacheType(net::MEDIA_CACHE); |
| InitCache(); |
| UpdateSparseEntry(); |
| } |
| |
| void DiskCacheEntryTest::DoomSparseEntry() { |
| std::string key1("the first key"); |
| std::string key2("the second key"); |
| disk_cache::Entry *entry1, *entry2; |
| ASSERT_THAT(CreateEntry(key1, &entry1), IsOk()); |
| ASSERT_THAT(CreateEntry(key2, &entry2), IsOk()); |
| |
| const int kSize = 4 * 1024; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| int64_t offset = 1024; |
| // Write to a bunch of ranges. |
| for (int i = 0; i < 12; i++) { |
| EXPECT_EQ(kSize, WriteSparseData(entry1, offset, buf.get(), kSize)); |
| // Keep the second map under the default size. |
| if (i < 9) |
| EXPECT_EQ(kSize, WriteSparseData(entry2, offset, buf.get(), kSize)); |
| |
| offset *= 4; |
| } |
| |
| if (memory_only_ || simple_cache_mode_) |
| EXPECT_EQ(2, cache_->GetEntryCount()); |
| else |
| EXPECT_EQ(15, cache_->GetEntryCount()); |
| |
| // Doom the first entry while it's still open. |
| entry1->Doom(); |
| entry1->Close(); |
| entry2->Close(); |
| |
| // Doom the second entry after it's fully saved. |
| EXPECT_THAT(DoomEntry(key2), IsOk()); |
| |
| // Make sure we do all needed work. This may fail for entry2 if between Close |
| // and DoomEntry the system decides to remove all traces of the file from the |
| // system cache so we don't see that there is pending IO. |
| base::RunLoop().RunUntilIdle(); |
| |
| if (memory_only_) { |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } else { |
| if (5 == cache_->GetEntryCount()) { |
| // Most likely we are waiting for the result of reading the sparse info |
| // (it's always async on Posix so it is easy to miss). Unfortunately we |
| // don't have any signal to watch for so we can only wait. |
| base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500)); |
| base::RunLoop().RunUntilIdle(); |
| } |
| EXPECT_EQ(0, cache_->GetEntryCount()); |
| } |
| } |
| |
| TEST_F(DiskCacheEntryTest, DoomSparseEntry) { |
| UseCurrentThread(); |
| InitCache(); |
| DoomSparseEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| DoomSparseEntry(); |
| } |
| |
| // A TestCompletionCallback wrapper that deletes the cache from within the |
| // callback. The way TestCompletionCallback works means that all tasks (even |
| // new ones) are executed by the message loop before returning to the caller so |
| // the only way to simulate a race is to execute what we want on the callback. |
| class SparseTestCompletionCallback: public net::TestCompletionCallback { |
| public: |
| explicit SparseTestCompletionCallback( |
| std::unique_ptr<disk_cache::Backend> cache) |
| : cache_(std::move(cache)) {} |
| |
| private: |
| void SetResult(int result) override { |
| cache_.reset(); |
| TestCompletionCallback::SetResult(result); |
| } |
| |
| std::unique_ptr<disk_cache::Backend> cache_; |
| DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback); |
| }; |
| |
| // Tests that we don't crash when the backend is deleted while we are working |
| // deleting the sub-entries of a sparse entry. |
| TEST_F(DiskCacheEntryTest, DoomSparseEntry2) { |
| UseCurrentThread(); |
| InitCache(); |
| std::string key("the key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 4 * 1024; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| int64_t offset = 1024; |
| // Write to a bunch of ranges. |
| for (int i = 0; i < 12; i++) { |
| EXPECT_EQ(kSize, entry->WriteSparseData(offset, buf.get(), kSize, |
| net::CompletionOnceCallback())); |
| offset *= 4; |
| } |
| EXPECT_EQ(9, cache_->GetEntryCount()); |
| |
| entry->Close(); |
| disk_cache::Backend* cache = cache_.get(); |
| SparseTestCompletionCallback cb(std::move(cache_)); |
| int rv = cache->DoomEntry(key, net::HIGHEST, cb.callback()); |
| EXPECT_THAT(rv, IsError(net::ERR_IO_PENDING)); |
| EXPECT_THAT(cb.WaitForResult(), IsOk()); |
| } |
| |
| void DiskCacheEntryTest::PartialSparseEntry() { |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| // We should be able to deal with IO that is not aligned to the block size |
| // of a sparse entry, at least to write a big range without leaving holes. |
| const int kSize = 4 * 1024; |
| const int kSmallSize = 128; |
| scoped_refptr<net::IOBuffer> buf1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf1->data(), kSize, false); |
| |
| // The first write is just to extend the entry. The third write occupies |
| // a 1KB block partially, it may not be written internally depending on the |
| // implementation. |
| EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize)); |
| EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize)); |
| EXPECT_EQ(kSmallSize, |
| WriteSparseData(entry, 1080321, buf1.get(), kSmallSize)); |
| entry->Close(); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| |
| scoped_refptr<net::IOBuffer> buf2 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| memset(buf2->data(), 0, kSize); |
| EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize)); |
| |
| EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize)); |
| EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); |
| EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize)); |
| |
| // This read should not change anything. |
| if (memory_only_ || simple_cache_mode_) |
| EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize)); |
| else |
| EXPECT_EQ(0, ReadSparseData(entry, 24000, buf2.get(), kSize)); |
| |
| EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize)); |
| EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize)); |
| |
| int rv; |
| int64_t start; |
| net::TestCompletionCallback cb; |
| if (memory_only_ || simple_cache_mode_) { |
| rv = entry->GetAvailableRange(0, 600, &start, cb.callback()); |
| EXPECT_EQ(100, cb.GetResult(rv)); |
| EXPECT_EQ(500, start); |
| } else { |
| rv = entry->GetAvailableRange(0, 2048, &start, cb.callback()); |
| EXPECT_EQ(1024, cb.GetResult(rv)); |
| EXPECT_EQ(1024, start); |
| } |
| rv = entry->GetAvailableRange(kSize, kSize, &start, cb.callback()); |
| EXPECT_EQ(500, cb.GetResult(rv)); |
| EXPECT_EQ(kSize, start); |
| rv = entry->GetAvailableRange(20 * 1024, 10000, &start, cb.callback()); |
| if (memory_only_ || simple_cache_mode_) |
| EXPECT_EQ(3616, cb.GetResult(rv)); |
| else |
| EXPECT_EQ(3072, cb.GetResult(rv)); |
| |
| EXPECT_EQ(20 * 1024, start); |
| |
| // 1. Query before a filled 1KB block. |
| // 2. Query within a filled 1KB block. |
| // 3. Query beyond a filled 1KB block. |
| if (memory_only_ || simple_cache_mode_) { |
| rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback()); |
| EXPECT_EQ(3496, cb.GetResult(rv)); |
| EXPECT_EQ(20000, start); |
| } else { |
| rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback()); |
| EXPECT_EQ(3016, cb.GetResult(rv)); |
| EXPECT_EQ(20480, start); |
| } |
| rv = entry->GetAvailableRange(3073, kSize, &start, cb.callback()); |
| EXPECT_EQ(1523, cb.GetResult(rv)); |
| EXPECT_EQ(3073, start); |
| rv = entry->GetAvailableRange(4600, kSize, &start, cb.callback()); |
| EXPECT_EQ(0, cb.GetResult(rv)); |
| EXPECT_EQ(4600, start); |
| |
| // Now make another write and verify that there is no hole in between. |
| EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize)); |
| rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback()); |
| EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv)); |
| EXPECT_EQ(1024, start); |
| EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize)); |
| EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); |
| EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500)); |
| |
| entry->Close(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, PartialSparseEntry) { |
| InitCache(); |
| PartialSparseEntry(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) { |
| SetMemoryOnlyMode(); |
| InitCache(); |
| PartialSparseEntry(); |
| } |
| |
| // Tests that corrupt sparse children are removed automatically. |
| TEST_F(DiskCacheEntryTest, CleanupSparseEntry) { |
| InitCache(); |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 4 * 1024; |
| scoped_refptr<net::IOBuffer> buf1 = |
| base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf1->data(), kSize, false); |
| |
| const int k1Meg = 1024 * 1024; |
| EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize)); |
| EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize)); |
| EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize)); |
| entry->Close(); |
| EXPECT_EQ(4, cache_->GetEntryCount()); |
| |
| std::unique_ptr<TestIterator> iter = CreateIterator(); |
| int count = 0; |
| std::string child_key[2]; |
| while (iter->OpenNextEntry(&entry) == net::OK) { |
| ASSERT_TRUE(entry != NULL); |
| // Writing to an entry will alter the LRU list and invalidate the iterator. |
| if (entry->GetKey() != key && count < 2) |
| child_key[count++] = entry->GetKey(); |
| entry->Close(); |
| } |
| for (int i = 0; i < 2; i++) { |
| ASSERT_THAT(OpenEntry(child_key[i], &entry), IsOk()); |
| // Overwrite the header's magic and signature. |
| EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false)); |
| entry->Close(); |
| } |
| |
| EXPECT_EQ(4, cache_->GetEntryCount()); |
| ASSERT_THAT(OpenEntry(key, &entry), IsOk()); |
| |
| // Two children should be gone. One while reading and one while writing. |
| EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize)); |
| EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize)); |
| EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize)); |
| |
| // We never touched this one. |
| EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize)); |
| entry->Close(); |
| |
| // We re-created one of the corrupt children. |
| EXPECT_EQ(3, cache_->GetEntryCount()); |
| } |
| |
| TEST_F(DiskCacheEntryTest, CancelSparseIO) { |
| UseCurrentThread(); |
| InitCache(); |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| const int kSize = 40 * 1024; |
| scoped_refptr<net::IOBuffer> buf = base::MakeRefCounted<net::IOBuffer>(kSize); |
| CacheTestFillBuffer(buf->data(), kSize, false); |
| |
| // This will open and write two "real" entries. |
| net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5; |
| int rv = entry->WriteSparseData( |
| 1024 * 1024 - 4096, buf.get(), kSize, cb1.callback()); |
| EXPECT_THAT(rv, IsError(net::ERR_IO_PENDING)); |
| |
| int64_t offset = 0; |
| rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback()); |
| rv = cb5.GetResult(rv); |
| if (!cb1.have_result()) { |
| // We may or may not have finished writing to the entry. If we have not, |
| // we cannot start another operation at this time. |
| EXPECT_THAT(rv, IsError(net::ERR_CACHE_OPERATION_NOT_SUPPORTED)); |
| } |
| |
| // We cancel the pending operation, and register multiple notifications. |
| entry->CancelSparseIO(); |
| EXPECT_THAT(entry->ReadyForSparseIO(cb2.callback()), |
| IsError(net::ERR_IO_PENDING)); |
| EXPECT_THAT(entry->ReadyForSparseIO(cb3.callback()), |
| IsError(net::ERR_IO_PENDING)); |
| entry->CancelSparseIO(); // Should be a no op at this point. |
| EXPECT_THAT(entry->ReadyForSparseIO(cb4.callback()), |
| IsError(net::ERR_IO_PENDING)); |
| |
| if (!cb1.have_result()) { |
| EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
| entry->ReadSparseData(offset, buf.get(), kSize, |
| net::CompletionOnceCallback())); |
| EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
| entry->WriteSparseData(offset, buf.get(), kSize, |
| net::CompletionOnceCallback())); |
| } |
| |
| // Now see if we receive all notifications. Note that we should not be able |
| // to write everything (unless the timing of the system is really weird). |
| rv = cb1.WaitForResult(); |
| EXPECT_TRUE(rv == 4096 || rv == kSize); |
| EXPECT_THAT(cb2.WaitForResult(), IsOk()); |
| EXPECT_THAT(cb3.WaitForResult(), IsOk()); |
| EXPECT_THAT(cb4.WaitForResult(), IsOk()); |
| |
| rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback()); |
| EXPECT_EQ(0, cb5.GetResult(rv)); |
| entry->Close(); |
| } |
| |
| // Tests that we perform sanity checks on an entry's key. Note that there are |
| // other tests that exercise sanity checks by using saved corrupt files. |
| TEST_F(DiskCacheEntryTest, KeySanityCheck) { |
| UseCurrentThread(); |
| InitCache(); |
| std::string key("the first key"); |
| disk_cache::Entry* entry; |
| ASSERT_THAT(CreateEntry(key, &entry), IsOk()); |
| |
| disk_cache::EntryImpl* entry_impl = |
| static_cast<disk_cache::EntryImpl*>(entry); |
| disk_cache::EntryStore* store = entry_impl->entry()->Data(); |
| |
| // We have reserved space for a short key (one block), let's say that the key |
| // takes more than one block, and remove the NULLs after the actual key. |
| store->key_len = 800; |
| memset(store->key + key.size(), 'k', sizeof(store->key) - key.size()); |
| entry_impl->entry()->set_modified(); |
| entry->Close(); |
| |
| // We have a corrupt entry. Now reload it. We should NOT read beyond the |
| // allocated buffer here. |
| ASSERT_NE(net::OK, OpenEntry(key, &entry)); |
| DisableIntegrityCheck(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| InternalAsyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| ExternalAsyncIO(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) { |
| EXPECT_THAT(DoomAllEntries(), IsOk()); |
| ReleaseBuffer(i); |
| } |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| StreamAccess(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheGetKey) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| GetKey(); |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) { |
| EXPECT_THAT(DoomAllEntries(), IsOk()); |
| GetTimes(i); |
| } |
| } |
| |
| TEST_F(DiskCacheEntryTest, SimpleCacheGrowData) { |
| SetSimpleCacheMode(); |
| InitCache(); |
| for (int i = 0; i < disk_cache::kSimpleEntryStreamCount; ++i) { |
| EXPECT_THAT(DoomAllEntries(), IsOk()); |
|
|