blob: 3e9b43bb954929aeb4df4e5452786ed3f61bb1d9 [file] [log] [blame]
// 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 "base/bind_helpers.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/memory/memory_pressure_listener.h"
#include "base/metrics/field_trial.h"
#include "base/run_loop.h"
#include "base/sequenced_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/task/post_task.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/mock_entropy_provider.h"
#include "base/test/scoped_feature_list.h"
#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
#include "base/threading/platform_thread.h"
#include "base/threading/thread_restrictions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/memory_allocator_dump.h"
#include "base/trace_event/process_memory_dump.h"
#include "base/trace_event/trace_event_argument.h"
#include "build/build_config.h"
#include "net/base/cache_type.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/backend_cleanup_tracker.h"
#include "net/disk_cache/blockfile/backend_impl.h"
#include "net/disk_cache/blockfile/entry_impl.h"
#include "net/disk_cache/blockfile/experiments.h"
#include "net/disk_cache/blockfile/histogram_macros.h"
#include "net/disk_cache/blockfile/mapped_file.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_backend_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_histogram_enums.h"
#include "net/disk_cache/simple/simple_index.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 "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using net::test::IsError;
using net::test::IsOk;
using testing::Contains;
using testing::Eq;
using testing::Field;
using testing::Contains;
using testing::ByRef;
#if defined(OS_WIN)
#include "base/win/scoped_handle.h"
#include "starboard/memory.h"
#include "starboard/types.h"
#endif
// Provide a BackendImpl object to macros from histogram_macros.h.
#define CACHE_UMA_BACKEND_IMPL_OBJ backend_
using base::Time;
namespace {
const char kExistingEntryKey[] = "existing entry key";
std::unique_ptr<disk_cache::BackendImpl> CreateExistingEntryCache(
const base::FilePath& cache_path) {
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(cache_path,
/* cleanup_tracker = */ nullptr,
/* cache_thread = */ nullptr,
/* net_log = */ nullptr));
int rv = cache->Init(cb.callback());
if (cb.GetResult(rv) != net::OK)
return std::unique_ptr<disk_cache::BackendImpl>();
disk_cache::Entry* entry = NULL;
rv = cache->CreateEntry(kExistingEntryKey, net::HIGHEST, &entry,
cb.callback());
if (cb.GetResult(rv) != net::OK)
return std::unique_ptr<disk_cache::BackendImpl>();
entry->Close();
return cache;
}
#if defined(OS_FUCHSIA)
// Load tests with large numbers of file descriptors perform poorly on
// virtualized test execution environments.
// TODO(807882): Remove this workaround when virtualized test performance
// improves.
const int kLargeNumEntries = 100;
#else
const int kLargeNumEntries = 512;
#endif
} // namespace
// Tests that can run with different types of caches.
class DiskCacheBackendTest : public DiskCacheTestWithCache {
protected:
// Some utility methods:
// Perform IO operations on the cache until there is pending IO.
int GeneratePendingIO(net::TestCompletionCallback* cb);
// Adds 5 sparse entries. |doomed_start| and |doomed_end| if not NULL,
// will be filled with times, used by DoomEntriesSince and DoomEntriesBetween.
// There are 4 entries after doomed_start and 2 after doomed_end.
void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end);
bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
bool EnumerateAndMatchKeys(int max_to_open,
TestIterator* iter,
std::set<std::string>* keys_to_match,
size_t* count);
// Computes the expected size of entry metadata, i.e. the total size without
// the actual data stored. This depends only on the entry's |key| size.
int GetEntryMetadataSize(std::string key);
// The Simple Backend only tracks the approximate sizes of entries. This
// rounds the exact size appropriately.
int GetRoundedSize(int exact_size);
// Actual tests:
void BackendBasics();
void BackendKeying();
void BackendShutdownWithPendingFileIO(bool fast);
void BackendShutdownWithPendingIO(bool fast);
void BackendShutdownWithPendingCreate(bool fast);
void BackendShutdownWithPendingDoom();
void BackendSetSize();
void BackendLoad();
void BackendChain();
void BackendValidEntry();
void BackendInvalidEntry();
void BackendInvalidEntryRead();
void BackendInvalidEntryWithLoad();
void BackendTrimInvalidEntry();
void BackendTrimInvalidEntry2();
void BackendEnumerations();
void BackendEnumerations2();
void BackendDoomMidEnumeration();
void BackendInvalidEntryEnumeration();
void BackendFixEnumerators();
void BackendDoomRecent();
void BackendDoomBetween();
void BackendCalculateSizeOfAllEntries();
void BackendCalculateSizeOfEntriesBetween();
void BackendTransaction(const std::string& name, int num_entries, bool load);
void BackendRecoverInsert();
void BackendRecoverRemove();
void BackendRecoverWithEviction();
void BackendInvalidEntry2();
void BackendInvalidEntry3();
void BackendInvalidEntry7();
void BackendInvalidEntry8();
void BackendInvalidEntry9(bool eviction);
void BackendInvalidEntry10(bool eviction);
void BackendInvalidEntry11(bool eviction);
void BackendTrimInvalidEntry12();
void BackendDoomAll();
void BackendDoomAll2();
void BackendInvalidRankings();
void BackendInvalidRankings2();
void BackendDisable();
void BackendDisable2();
void BackendDisable3();
void BackendDisable4();
void BackendDisabledAPI();
void BackendEviction();
};
int DiskCacheBackendTest::GeneratePendingIO(net::TestCompletionCallback* cb) {
if (!use_current_thread_ && !simple_cache_mode_) {
ADD_FAILURE();
return net::ERR_FAILED;
}
disk_cache::Entry* entry;
int rv =
cache_->CreateEntry("some key", net::HIGHEST, &entry, cb->callback());
if (cb->GetResult(rv) != net::OK)
return net::ERR_CACHE_CREATE_FAILURE;
const int kSize = 25000;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer->data(), kSize, false);
for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
// We are using the current thread as the cache thread because we want to
// be able to call directly this method to make sure that the OS (instead
// of us switching thread) is returning IO pending.
if (!simple_cache_mode_) {
rv = static_cast<disk_cache::EntryImpl*>(entry)->WriteDataImpl(
0, i, buffer.get(), kSize, cb->callback(), false);
} else {
rv = entry->WriteData(0, i, buffer.get(), kSize, cb->callback(), false);
}
if (rv == net::ERR_IO_PENDING)
break;
if (rv != kSize)
rv = net::ERR_FAILED;
}
// Don't call Close() to avoid going through the queue or we'll deadlock
// waiting for the operation to finish.
if (!simple_cache_mode_)
static_cast<disk_cache::EntryImpl*>(entry)->Release();
else
entry->Close();
return rv;
}
void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
base::Time* doomed_end) {
InitCache();
const int kSize = 50;
// This must be greater than MemEntryImpl::kMaxSparseEntrySize.
const int kOffset = 10 + 1024 * 1024;
disk_cache::Entry* entry0 = NULL;
disk_cache::Entry* entry1 = NULL;
disk_cache::Entry* entry2 = NULL;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer->data(), kSize, false);
ASSERT_THAT(CreateEntry("zeroth", &entry0), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
entry0->Close();
FlushQueueForTest();
AddDelay();
if (doomed_start)
*doomed_start = base::Time::Now();
// Order in rankings list:
// first_part1, first_part2, second_part1, second_part2
ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
entry1->Close();
ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
entry2->Close();
FlushQueueForTest();
AddDelay();
if (doomed_end)
*doomed_end = base::Time::Now();
// Order in rankings list:
// third_part1, fourth_part1, third_part2, fourth_part2
disk_cache::Entry* entry3 = NULL;
disk_cache::Entry* entry4 = NULL;
ASSERT_THAT(CreateEntry("third", &entry3), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
ASSERT_THAT(CreateEntry("fourth", &entry4), IsOk());
ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
ASSERT_EQ(kSize,
WriteSparseData(entry4, kOffset + kSize, buffer.get(), kSize));
entry3->Close();
entry4->Close();
FlushQueueForTest();
AddDelay();
}
// Creates entries based on random keys. Stores these keys in |key_pool|.
bool DiskCacheBackendTest::CreateSetOfRandomEntries(
std::set<std::string>* key_pool) {
const int kNumEntries = 10;
const int initial_entry_count = cache_->GetEntryCount();
for (int i = 0; i < kNumEntries; ++i) {
std::string key = GenerateKey(true);
disk_cache::Entry* entry;
if (CreateEntry(key, &entry) != net::OK) {
return false;
}
key_pool->insert(key);
entry->Close();
}
return key_pool->size() ==
static_cast<size_t>(cache_->GetEntryCount() - initial_entry_count);
}
// Performs iteration over the backend and checks that the keys of entries
// opened are in |keys_to_match|, then erases them. Up to |max_to_open| entries
// will be opened, if it is positive. Otherwise, iteration will continue until
// OpenNextEntry stops returning net::OK.
bool DiskCacheBackendTest::EnumerateAndMatchKeys(
int max_to_open,
TestIterator* iter,
std::set<std::string>* keys_to_match,
size_t* count) {
disk_cache::Entry* entry;
if (!iter)
return false;
while (iter->OpenNextEntry(&entry) == net::OK) {
if (!entry)
return false;
EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
entry->Close();
++(*count);
if (max_to_open >= 0 && static_cast<int>(*count) >= max_to_open)
break;
};
return true;
}
int DiskCacheBackendTest::GetEntryMetadataSize(std::string key) {
// For blockfile and memory backends, it is just the key size.
if (!simple_cache_mode_)
return key.size();
// For the simple cache, we must add the file header and EOF, and that for
// every stream.
return disk_cache::kSimpleEntryStreamCount *
(sizeof(disk_cache::SimpleFileHeader) +
sizeof(disk_cache::SimpleFileEOF) + key.size());
}
int DiskCacheBackendTest::GetRoundedSize(int exact_size) {
if (!simple_cache_mode_)
return exact_size;
return (exact_size + 255) & 0xFFFFFF00;
}
void DiskCacheBackendTest::BackendBasics() {
InitCache();
disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
ASSERT_THAT(CreateEntry("the first key", &entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
EXPECT_NE(net::OK, CreateEntry("the first key", &entry1));
ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
ASSERT_THAT(CreateEntry("some other key", &entry2), IsOk());
ASSERT_TRUE(NULL != entry1);
ASSERT_TRUE(NULL != entry2);
EXPECT_EQ(2, cache_->GetEntryCount());
disk_cache::Entry* entry3 = NULL;
ASSERT_THAT(OpenEntry("some other key", &entry3), IsOk());
ASSERT_TRUE(NULL != entry3);
EXPECT_TRUE(entry2 == entry3);
EXPECT_THAT(DoomEntry("some other key"), IsOk());
EXPECT_EQ(1, cache_->GetEntryCount());
entry1->Close();
entry2->Close();
entry3->Close();
EXPECT_THAT(DoomEntry("the first key"), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
ASSERT_THAT(CreateEntry("the first key", &entry1), IsOk());
ASSERT_THAT(CreateEntry("some other key", &entry2), IsOk());
entry1->Doom();
entry1->Close();
EXPECT_THAT(DoomEntry("some other key"), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
entry2->Close();
}
TEST_F(DiskCacheBackendTest, Basics) {
BackendBasics();
}
TEST_F(DiskCacheBackendTest, NewEvictionBasics) {
SetNewEviction();
BackendBasics();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyBasics) {
SetMemoryOnlyMode();
BackendBasics();
}
TEST_F(DiskCacheBackendTest, AppCacheBasics) {
SetCacheType(net::APP_CACHE);
BackendBasics();
}
TEST_F(DiskCacheBackendTest, ShaderCacheBasics) {
SetCacheType(net::SHADER_CACHE);
BackendBasics();
}
void DiskCacheBackendTest::BackendKeying() {
InitCache();
const char kName1[] = "the first key";
const char kName2[] = "the first Key";
disk_cache::Entry *entry1, *entry2;
ASSERT_THAT(CreateEntry(kName1, &entry1), IsOk());
ASSERT_THAT(CreateEntry(kName2, &entry2), IsOk());
EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
entry2->Close();
char buffer[30];
base::strlcpy(buffer, kName1, arraysize(buffer));
ASSERT_THAT(OpenEntry(buffer, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
base::strlcpy(buffer + 1, kName1, arraysize(buffer) - 1);
ASSERT_THAT(OpenEntry(buffer + 1, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
base::strlcpy(buffer + 3, kName1, arraysize(buffer) - 3);
ASSERT_THAT(OpenEntry(buffer + 3, &entry2), IsOk());
EXPECT_TRUE(entry1 == entry2);
entry2->Close();
// Now verify long keys.
char buffer2[20000];
memset(buffer2, 's', sizeof(buffer2));
buffer2[1023] = '\0';
ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on block file";
entry2->Close();
buffer2[1023] = 'g';
buffer2[19999] = '\0';
ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on external file";
entry2->Close();
entry1->Close();
}
TEST_F(DiskCacheBackendTest, Keying) {
BackendKeying();
}
TEST_F(DiskCacheBackendTest, NewEvictionKeying) {
SetNewEviction();
BackendKeying();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyKeying) {
SetMemoryOnlyMode();
BackendKeying();
}
TEST_F(DiskCacheBackendTest, AppCacheKeying) {
SetCacheType(net::APP_CACHE);
BackendKeying();
}
TEST_F(DiskCacheBackendTest, ShaderCacheKeying) {
SetCacheType(net::SHADER_CACHE);
BackendKeying();
}
TEST_F(DiskCacheTest, CreateBackend) {
net::TestCompletionCallback cb;
{
ASSERT_TRUE(CleanupCacheDir());
// Test the private factory method(s).
std::unique_ptr<disk_cache::Backend> cache;
cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
ASSERT_TRUE(cache.get());
cache.reset();
// Now test the public API.
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path_, 0, false,
NULL, &cache, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
cache.reset();
rv = disk_cache::CreateCacheBackend(
net::MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT, base::FilePath(), 0,
false, NULL, &cache, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
cache.reset();
}
base::RunLoop().RunUntilIdle();
}
TEST_F(DiskCacheTest, MemBackendPostCleanupCallback) {
net::TestCompletionCallback cb;
net::TestClosure on_cleanup;
std::unique_ptr<disk_cache::Backend> cache;
int rv = disk_cache::CreateCacheBackend(
net::MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT, base::FilePath(), 0, false,
nullptr, &cache, on_cleanup.closure(), cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
// The callback should be posted after backend is destroyed.
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(on_cleanup.have_result());
cache.reset();
EXPECT_FALSE(on_cleanup.have_result());
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(on_cleanup.have_result());
}
TEST_F(DiskCacheTest, CreateBackendDouble) {
// Make sure that creation for the second backend for same path happens
// after the first one completes.
net::TestCompletionCallback cb, cb2;
std::unique_ptr<disk_cache::Backend> cache, cache2;
int rv = disk_cache::CreateCacheBackend(
net::APP_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path_, 0, false,
nullptr, &cache, cb.callback());
int rv2 = disk_cache::CreateCacheBackend(
net::APP_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path_, 0, false,
nullptr, &cache2, cb2.callback());
EXPECT_THAT(cb.GetResult(rv), IsOk());
EXPECT_TRUE(cache.get());
disk_cache::FlushCacheThreadForTesting();
// No cache 2 yet.
EXPECT_EQ(net::ERR_IO_PENDING, rv2);
EXPECT_FALSE(cb2.have_result());
cache.reset();
// Now cache2 should exist.
EXPECT_THAT(cb2.GetResult(rv2), IsOk());
EXPECT_TRUE(cache2.get());
}
TEST_F(DiskCacheBackendTest, CreateBackendDoubleOpenEntry) {
// Demonstrate the creation sequencing with an open entry. This is done
// with SimpleCache since the block-file cache cancels most of I/O on
// destruction and blocks for what it can't cancel.
// Don't try to sanity-check things as a blockfile cache
SetSimpleCacheMode();
// Make sure that creation for the second backend for same path happens
// after the first one completes, and all of its ops complete.
net::TestCompletionCallback cb, cb2;
std::unique_ptr<disk_cache::Backend> cache, cache2;
int rv = disk_cache::CreateCacheBackend(
net::APP_CACHE, net::CACHE_BACKEND_SIMPLE, cache_path_, 0, false, nullptr,
&cache, cb.callback());
int rv2 = disk_cache::CreateCacheBackend(
net::APP_CACHE, net::CACHE_BACKEND_SIMPLE, cache_path_, 0, false, nullptr,
&cache2, cb2.callback());
EXPECT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
disk_cache::FlushCacheThreadForTesting();
// No cache 2 yet.
EXPECT_EQ(net::ERR_IO_PENDING, rv2);
EXPECT_FALSE(cb2.have_result());
disk_cache::Entry* entry = nullptr;
rv = cache->CreateEntry("key", net::HIGHEST, &entry, cb.callback());
ASSERT_EQ(net::OK, cb.GetResult(rv));
cache.reset();
// Still doesn't exist.
EXPECT_FALSE(cb2.have_result());
entry->Close();
// Now should exist.
EXPECT_THAT(cb2.GetResult(rv2), IsOk());
EXPECT_TRUE(cache2.get());
}
TEST_F(DiskCacheBackendTest, CreateBackendPostCleanup) {
// Test for the explicit PostCleanupCallback parameter to CreateCacheBackend.
// Extravagant size payload to make reproducing races easier.
const int kBufSize = 256 * 1024;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kBufSize);
CacheTestFillBuffer(buffer->data(), kBufSize, true);
SetSimpleCacheMode();
CleanupCacheDir();
base::RunLoop run_loop;
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::Backend> cache;
int rv = disk_cache::CreateCacheBackend(
net::APP_CACHE, net::CACHE_BACKEND_SIMPLE, cache_path_, 0, false, nullptr,
&cache, run_loop.QuitClosure(), cb.callback());
EXPECT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache.get());
disk_cache::Entry* entry = nullptr;
rv = cache->CreateEntry("key", net::HIGHEST, &entry, cb.callback());
ASSERT_EQ(net::OK, cb.GetResult(rv));
EXPECT_EQ(kBufSize, WriteData(entry, 0, 0, buffer.get(), kBufSize, false));
entry->Close();
cache.reset();
// Wait till the post-cleanup callback.
run_loop.Run();
// All of the payload should be on disk, despite stream 0 being written
// back in the async Close()
base::FilePath entry_path = cache_path_.AppendASCII(
disk_cache::simple_util::GetFilenameFromKeyAndFileIndex("key", 0));
int64_t size = 0;
EXPECT_TRUE(base::GetFileSize(entry_path, &size));
EXPECT_GT(size, kBufSize);
}
// Tests that |BackendImpl| fails to initialize with a missing file.
TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
ASSERT_TRUE(CopyTestCache("bad_entry"));
base::FilePath filename = cache_path_.AppendASCII("data_1");
base::DeleteFile(filename, false);
net::TestCompletionCallback cb;
bool prev = base::ThreadRestrictions::SetIOAllowed(false);
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(cache_path_, nullptr, nullptr,
nullptr));
int rv = cache->Init(cb.callback());
EXPECT_THAT(cb.GetResult(rv), IsError(net::ERR_FAILED));
base::ThreadRestrictions::SetIOAllowed(prev);
cache.reset();
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, MemCacheMemoryDump) {
SetMemoryOnlyMode();
BackendBasics();
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::ProcessMemoryDump pmd(args);
base::trace_event::MemoryAllocatorDump* parent =
pmd.CreateAllocatorDump("net/url_request_context/main/0x123/http_cache");
ASSERT_LT(0u, cache_->DumpMemoryStats(&pmd, parent->absolute_name()));
EXPECT_EQ(2u, pmd.allocator_dumps().size());
const base::trace_event::MemoryAllocatorDump* sub_dump =
pmd.GetAllocatorDump(parent->absolute_name() + "/memory_backend");
ASSERT_NE(nullptr, sub_dump);
using MADEntry = base::trace_event::MemoryAllocatorDump::Entry;
const std::vector<MADEntry>& entries = sub_dump->entries();
ASSERT_THAT(
entries,
Contains(Field(&MADEntry::name,
Eq(base::trace_event::MemoryAllocatorDump::kNameSize))));
ASSERT_THAT(entries,
Contains(Field(&MADEntry::name, Eq("mem_backend_max_size"))));
ASSERT_THAT(entries,
Contains(Field(&MADEntry::name, Eq("mem_backend_size"))));
}
TEST_F(DiskCacheBackendTest, SimpleCacheMemoryDump) {
simple_cache_mode_ = true;
BackendBasics();
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::ProcessMemoryDump pmd(args);
base::trace_event::MemoryAllocatorDump* parent =
pmd.CreateAllocatorDump("net/url_request_context/main/0x123/http_cache");
ASSERT_LT(0u, cache_->DumpMemoryStats(&pmd, parent->absolute_name()));
EXPECT_EQ(2u, pmd.allocator_dumps().size());
const base::trace_event::MemoryAllocatorDump* sub_dump =
pmd.GetAllocatorDump(parent->absolute_name() + "/simple_backend");
ASSERT_NE(nullptr, sub_dump);
using MADEntry = base::trace_event::MemoryAllocatorDump::Entry;
const std::vector<MADEntry>& entries = sub_dump->entries();
ASSERT_THAT(entries,
ElementsAre(Field(
&MADEntry::name,
Eq(base::trace_event::MemoryAllocatorDump::kNameSize))));
}
TEST_F(DiskCacheBackendTest, BlockFileCacheMemoryDump) {
// TODO(jkarlin): If the blockfile cache gets memory dump support, update
// this test.
BackendBasics();
base::trace_event::MemoryDumpArgs args = {
base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND};
base::trace_event::ProcessMemoryDump pmd(args);
base::trace_event::MemoryAllocatorDump* parent =
pmd.CreateAllocatorDump("net/url_request_context/main/0x123/http_cache");
ASSERT_EQ(0u, cache_->DumpMemoryStats(&pmd, parent->absolute_name()));
EXPECT_EQ(1u, pmd.allocator_dumps().size());
}
TEST_F(DiskCacheBackendTest, MemoryListensToMemoryPressure) {
const int kLimit = 16 * 1024;
const int kEntrySize = 256;
SetMaxSize(kLimit);
SetMemoryOnlyMode();
InitCache();
// Fill in to about 80-90% full.
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kEntrySize);
CacheTestFillBuffer(buffer->data(), kEntrySize, false);
for (int i = 0; i < 0.9 * (kLimit / kEntrySize); ++i) {
disk_cache::Entry* entry = nullptr;
ASSERT_EQ(net::OK, CreateEntry(base::IntToString(i), &entry));
EXPECT_EQ(kEntrySize,
WriteData(entry, 0, 0, buffer.get(), kEntrySize, true));
entry->Close();
}
EXPECT_GT(CalculateSizeOfAllEntries(), 0.8 * kLimit);
// Signal low-memory of various sorts, and see how small it gets.
base::MemoryPressureListener::NotifyMemoryPressure(
base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
base::RunLoop().RunUntilIdle();
EXPECT_LT(CalculateSizeOfAllEntries(), 0.5 * kLimit);
base::MemoryPressureListener::NotifyMemoryPressure(
base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
base::RunLoop().RunUntilIdle();
EXPECT_LT(CalculateSizeOfAllEntries(), 0.1 * kLimit);
}
TEST_F(DiskCacheBackendTest, ExternalFiles) {
InitCache();
// First, let's create a file on the folder.
base::FilePath filename = cache_path_.AppendASCII("f_000001");
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer1->data(), kSize, false);
ASSERT_EQ(kSize, base::WriteFile(filename, buffer1->data(), kSize));
// Now let's create a file with the cache.
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
entry->Close();
// And verify that the first file is still there.
scoped_refptr<net::IOBuffer> buffer2(
base::MakeRefCounted<net::IOBuffer>(kSize));
ASSERT_EQ(kSize, base::ReadFile(filename, buffer2->data(), kSize));
EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
}
// Tests that we deal with file-level pending operations at destruction time.
void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
ASSERT_TRUE(CleanupCacheDir());
uint32_t flags = disk_cache::kNoBuffering;
if (!fast)
flags |= disk_cache::kNoRandom;
if (!simple_cache_mode_)
UseCurrentThread();
CreateBackend(flags);
net::TestCompletionCallback cb;
int rv = GeneratePendingIO(&cb);
// The cache destructor will see one pending operation here.
cache_.reset();
if (rv == net::ERR_IO_PENDING) {
if (fast || simple_cache_mode_)
EXPECT_FALSE(cb.have_result());
else
EXPECT_TRUE(cb.have_result());
}
base::RunLoop().RunUntilIdle();
#if !defined(OS_IOS)
// Wait for the actual operation to complete, or we'll keep a file handle that
// may cause issues later. Note that on iOS systems even though this test
// uses a single thread, the actual IO is posted to a worker thread and the
// cache destructor breaks the link to reach cb when the operation completes.
rv = cb.GetResult(rv);
#endif
}
TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO) {
BackendShutdownWithPendingFileIO(false);
}
// Here and below, tests that simulate crashes are not compiled in LeakSanitizer
// builds because they contain a lot of intentional memory leaks.
#if !defined(LEAK_SANITIZER)
// We'll be leaking from this test.
TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO_Fast) {
// The integrity test sets kNoRandom so there's a version mismatch if we don't
// force new eviction.
SetNewEviction();
BackendShutdownWithPendingFileIO(true);
}
#endif
// See crbug.com/330074
#if !defined(OS_IOS)
// Tests that one cache instance is not affected by another one going away.
TEST_F(DiskCacheBackendTest, MultipleInstancesWithPendingFileIO) {
base::ScopedTempDir store;
ASSERT_TRUE(store.CreateUniqueTempDir());
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::Backend> extra_cache;
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store.GetPath(), 0, false,
/* net_log = */ nullptr, &extra_cache, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(extra_cache.get() != NULL);
ASSERT_TRUE(CleanupCacheDir());
SetNewEviction(); // Match the expected behavior for integrity verification.
UseCurrentThread();
CreateBackend(disk_cache::kNoBuffering);
rv = GeneratePendingIO(&cb);
// cache_ has a pending operation, and extra_cache will go away.
extra_cache.reset();
if (rv == net::ERR_IO_PENDING)
EXPECT_FALSE(cb.have_result());
disk_cache::FlushCacheThreadForTesting();
base::RunLoop().RunUntilIdle();
// Wait for the actual operation to complete, or we'll keep a file handle that
// may cause issues later.
rv = cb.GetResult(rv);
}
#endif
// Tests that we deal with background-thread pending operations.
void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
net::TestCompletionCallback cb;
{
ASSERT_TRUE(CleanupCacheDir());
uint32_t flags = disk_cache::kNoBuffering;
if (!fast)
flags |= disk_cache::kNoRandom;
CreateBackend(flags);
disk_cache::Entry* entry;
int rv =
cache_->CreateEntry("some key", net::HIGHEST, &entry, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
// The cache destructor will see one pending operation here.
cache_.reset();
}
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(cb.have_result());
}
TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO) {
BackendShutdownWithPendingIO(false);
}
#if !defined(LEAK_SANITIZER)
// We'll be leaking from this test.
TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO_Fast) {
// The integrity test sets kNoRandom so there's a version mismatch if we don't
// force new eviction.
SetNewEviction();
BackendShutdownWithPendingIO(true);
}
#endif
// Tests that we deal with create-type pending operations.
void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
net::TestCompletionCallback cb;
{
ASSERT_TRUE(CleanupCacheDir());
disk_cache::BackendFlags flags =
fast ? disk_cache::kNone : disk_cache::kNoRandom;
CreateBackend(flags);
disk_cache::Entry* entry;
int rv =
cache_->CreateEntry("some key", net::HIGHEST, &entry, cb.callback());
ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
cache_.reset();
EXPECT_FALSE(cb.have_result());
}
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(cb.have_result());
}
TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate) {
BackendShutdownWithPendingCreate(false);
}
#if !defined(LEAK_SANITIZER)
// We'll be leaking an entry from this test.
TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate_Fast) {
// The integrity test sets kNoRandom so there's a version mismatch if we don't
// force new eviction.
SetNewEviction();
BackendShutdownWithPendingCreate(true);
}
#endif
void DiskCacheBackendTest::BackendShutdownWithPendingDoom() {
net::TestCompletionCallback cb;
{
ASSERT_TRUE(CleanupCacheDir());
disk_cache::BackendFlags flags = disk_cache::kNoRandom;
CreateBackend(flags);
disk_cache::Entry* entry;
int rv =
cache_->CreateEntry("some key", net::HIGHEST, &entry, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
entry = nullptr;
rv = cache_->DoomEntry("some key", net::HIGHEST, cb.callback());
ASSERT_THAT(rv, IsError(net::ERR_IO_PENDING));
cache_.reset();
EXPECT_FALSE(cb.have_result());
}
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(cb.have_result());
}
TEST_F(DiskCacheBackendTest, ShutdownWithPendingDoom) {
BackendShutdownWithPendingDoom();
}
// Disabled on android since this test requires cache creator to create
// blockfile caches.
#if !defined(OS_ANDROID)
TEST_F(DiskCacheTest, TruncatedIndex) {
ASSERT_TRUE(CleanupCacheDir());
base::FilePath index = cache_path_.AppendASCII("index");
ASSERT_EQ(5, base::WriteFile(index, "hello", 5));
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::Backend> backend;
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE, cache_path_, 0, false,
nullptr, &backend, cb.callback());
ASSERT_NE(net::OK, cb.GetResult(rv));
ASSERT_FALSE(backend);
}
#endif
void DiskCacheBackendTest::BackendSetSize() {
const int cache_size = 0x10000; // 64 kB
SetMaxSize(cache_size);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(cache_size);
memset(buffer->data(), 0, cache_size);
EXPECT_EQ(cache_size / 10,
WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false))
<< "normal file";
EXPECT_EQ(net::ERR_FAILED,
WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false))
<< "file size above the limit";
// By doubling the total size, we make this file cacheable.
SetMaxSize(cache_size * 2);
EXPECT_EQ(cache_size / 5,
WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false));
// Let's fill up the cache!.
SetMaxSize(cache_size * 10);
EXPECT_EQ(cache_size * 3 / 4,
WriteData(entry, 0, 0, buffer.get(), cache_size * 3 / 4, false));
entry->Close();
FlushQueueForTest();
SetMaxSize(cache_size);
// The cache is 95% full.
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
EXPECT_EQ(cache_size / 10,
WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false));
disk_cache::Entry* entry2;
ASSERT_THAT(CreateEntry("an extra key", &entry2), IsOk());
EXPECT_EQ(cache_size / 10,
WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
entry2->Close(); // This will trigger the cache trim.
EXPECT_NE(net::OK, OpenEntry(first, &entry2));
FlushQueueForTest(); // Make sure that we are done trimming the cache.
FlushQueueForTest(); // We may have posted two tasks to evict stuff.
entry->Close();
ASSERT_THAT(OpenEntry(second, &entry), IsOk());
EXPECT_EQ(cache_size / 10, entry->GetDataSize(0));
entry->Close();
}
TEST_F(DiskCacheBackendTest, SetSize) {
BackendSetSize();
}
TEST_F(DiskCacheBackendTest, NewEvictionSetSize) {
SetNewEviction();
BackendSetSize();
}
TEST_F(DiskCacheBackendTest, MemoryOnlySetSize) {
SetMemoryOnlyMode();
BackendSetSize();
}
void DiskCacheBackendTest::BackendLoad() {
InitCache();
int seed = static_cast<int>(Time::Now().ToInternalValue());
srand(seed);
disk_cache::Entry* entries[kLargeNumEntries];
for (int i = 0; i < kLargeNumEntries; i++) {
std::string key = GenerateKey(true);
ASSERT_THAT(CreateEntry(key, &entries[i]), IsOk());
}
EXPECT_EQ(kLargeNumEntries, cache_->GetEntryCount());
for (int i = 0; i < kLargeNumEntries; i++) {
int source1 = rand() % kLargeNumEntries;
int source2 = rand() % kLargeNumEntries;
disk_cache::Entry* temp = entries[source1];
entries[source1] = entries[source2];
entries[source2] = temp;
}
for (int i = 0; i < kLargeNumEntries; i++) {
disk_cache::Entry* entry;
ASSERT_THAT(OpenEntry(entries[i]->GetKey(), &entry), IsOk());
EXPECT_TRUE(entry == entries[i]);
entry->Close();
entries[i]->Doom();
entries[i]->Close();
}
FlushQueueForTest();
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, Load) {
// Work with a tiny index table (16 entries)
SetMask(0xf);
SetMaxSize(0x100000);
BackendLoad();
}
TEST_F(DiskCacheBackendTest, NewEvictionLoad) {
SetNewEviction();
// Work with a tiny index table (16 entries)
SetMask(0xf);
SetMaxSize(0x100000);
BackendLoad();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyLoad) {
SetMaxSize(0x100000);
SetMemoryOnlyMode();
BackendLoad();
}
TEST_F(DiskCacheBackendTest, AppCacheLoad) {
SetCacheType(net::APP_CACHE);
// Work with a tiny index table (16 entries)
SetMask(0xf);
SetMaxSize(0x100000);
BackendLoad();
}
TEST_F(DiskCacheBackendTest, ShaderCacheLoad) {
SetCacheType(net::SHADER_CACHE);
// Work with a tiny index table (16 entries)
SetMask(0xf);
SetMaxSize(0x100000);
BackendLoad();
}
// Tests the chaining of an entry to the current head.
void DiskCacheBackendTest::BackendChain() {
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
InitCache();
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("The first key", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("The Second key", &entry), IsOk());
entry->Close();
}
TEST_F(DiskCacheBackendTest, Chain) {
BackendChain();
}
TEST_F(DiskCacheBackendTest, NewEvictionChain) {
SetNewEviction();
BackendChain();
}
TEST_F(DiskCacheBackendTest, AppCacheChain) {
SetCacheType(net::APP_CACHE);
BackendChain();
}
TEST_F(DiskCacheBackendTest, ShaderCacheChain) {
SetCacheType(net::SHADER_CACHE);
BackendChain();
}
TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
SetNewEviction();
InitCache();
disk_cache::Entry* entry;
for (int i = 0; i < 100; i++) {
std::string name(base::StringPrintf("Key %d", i));
ASSERT_THAT(CreateEntry(name, &entry), IsOk());
entry->Close();
if (i < 90) {
// Entries 0 to 89 are in list 1; 90 to 99 are in list 0.
ASSERT_THAT(OpenEntry(name, &entry), IsOk());
entry->Close();
}
}
// The first eviction must come from list 1 (10% limit), the second must come
// from list 0.
TrimForTest(false);
EXPECT_NE(net::OK, OpenEntry("Key 0", &entry));
TrimForTest(false);
EXPECT_NE(net::OK, OpenEntry("Key 90", &entry));
// Double check that we still have the list tails.
ASSERT_THAT(OpenEntry("Key 1", &entry), IsOk());
entry->Close();
ASSERT_THAT(OpenEntry("Key 91", &entry), IsOk());
entry->Close();
}
// Before looking for invalid entries, let's check a valid entry.
void DiskCacheBackendTest::BackendValidEntry() {
InitCache();
std::string key("Some key");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
entry->Close();
SimulateCrash();
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer2->data(), 0, kSize);
EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));
entry->Close();
EXPECT_STREQ(buffer1->data(), buffer2->data());
}
TEST_F(DiskCacheBackendTest, ValidEntry) {
BackendValidEntry();
}
TEST_F(DiskCacheBackendTest, NewEvictionValidEntry) {
SetNewEviction();
BackendValidEntry();
}
// The same logic of the previous test (ValidEntry), but this time force the
// entry to be invalid, simulating a crash in the middle.
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendInvalidEntry() {
InitCache();
std::string key("Some key");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer->data(), 0, kSize);
base::strlcpy(buffer->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
SimulateCrash();
EXPECT_NE(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(0, cache_->GetEntryCount());
}
#if !defined(LEAK_SANITIZER)
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, InvalidEntry) {
BackendInvalidEntry();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry) {
SetNewEviction();
BackendInvalidEntry();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, AppCacheInvalidEntry) {
SetCacheType(net::APP_CACHE);
BackendInvalidEntry();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntry) {
SetCacheType(net::SHADER_CACHE);
BackendInvalidEntry();
}
// Almost the same test, but this time crash the cache after reading an entry.
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendInvalidEntryRead() {
InitCache();
std::string key("Some key");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer->data(), 0, kSize);
base::strlcpy(buffer->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
entry->Close();
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
SimulateCrash();
if (type_ == net::APP_CACHE) {
// Reading an entry and crashing should not make it dirty.
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
EXPECT_EQ(1, cache_->GetEntryCount());
entry->Close();
} else {
EXPECT_NE(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(0, cache_->GetEntryCount());
}
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, InvalidEntryRead) {
BackendInvalidEntryRead();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryRead) {
SetNewEviction();
BackendInvalidEntryRead();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryRead) {
SetCacheType(net::APP_CACHE);
BackendInvalidEntryRead();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryRead) {
SetCacheType(net::SHADER_CACHE);
BackendInvalidEntryRead();
}
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendInvalidEntryWithLoad() {
// Work with a tiny index table (16 entries)
SetMask(0xf);
SetMaxSize(0x100000);
InitCache();
int seed = static_cast<int>(Time::Now().ToInternalValue());
srand(seed);
const int kNumEntries = 100;
disk_cache::Entry* entries[kNumEntries];
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
ASSERT_THAT(CreateEntry(key, &entries[i]), IsOk());
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
for (int i = 0; i < kNumEntries; i++) {
int source1 = rand() % kNumEntries;
int source2 = rand() % kNumEntries;
disk_cache::Entry* temp = entries[source1];
entries[source1] = entries[source2];
entries[source2] = temp;
}
std::string keys[kNumEntries];
for (int i = 0; i < kNumEntries; i++) {
keys[i] = entries[i]->GetKey();
if (i < kNumEntries / 2)
entries[i]->Close();
}
SimulateCrash();
for (int i = kNumEntries / 2; i < kNumEntries; i++) {
disk_cache::Entry* entry;
EXPECT_NE(net::OK, OpenEntry(keys[i], &entry));
}
for (int i = 0; i < kNumEntries / 2; i++) {
disk_cache::Entry* entry;
ASSERT_THAT(OpenEntry(keys[i], &entry), IsOk());
entry->Close();
}
EXPECT_EQ(kNumEntries / 2, cache_->GetEntryCount());
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, InvalidEntryWithLoad) {
BackendInvalidEntryWithLoad();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryWithLoad) {
SetNewEviction();
BackendInvalidEntryWithLoad();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryWithLoad) {
SetCacheType(net::APP_CACHE);
BackendInvalidEntryWithLoad();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryWithLoad) {
SetCacheType(net::SHADER_CACHE);
BackendInvalidEntryWithLoad();
}
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendTrimInvalidEntry() {
const int kSize = 0x3000; // 12 kB
SetMaxSize(kSize * 10);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer->data(), 0, kSize);
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
// Simulate a crash.
SimulateCrash();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
EXPECT_EQ(2, cache_->GetEntryCount());
SetMaxSize(kSize);
entry->Close(); // Trim the cache.
FlushQueueForTest();
// If we evicted the entry in less than 20mS, we have one entry in the cache;
// if it took more than that, we posted a task and we'll delete the second
// entry too.
base::RunLoop().RunUntilIdle();
// This may be not thread-safe in general, but for now it's OK so add some
// ThreadSanitizer annotations to ignore data races on cache_.
// See http://crbug.com/55970
ANNOTATE_IGNORE_READS_BEGIN();
EXPECT_GE(1, cache_->GetEntryCount());
ANNOTATE_IGNORE_READS_END();
EXPECT_NE(net::OK, OpenEntry(first, &entry));
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, TrimInvalidEntry) {
BackendTrimInvalidEntry();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry) {
SetNewEviction();
BackendTrimInvalidEntry();
}
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
SetMask(0xf); // 16-entry table.
const int kSize = 0x3000; // 12 kB
SetMaxSize(kSize * 40);
InitCache();
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer->data(), 0, kSize);
disk_cache::Entry* entry;
// Writing 32 entries to this cache chains most of them.
for (int i = 0; i < 32; i++) {
std::string key(base::StringPrintf("some key %d", i));
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
entry->Close();
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
// Note that we are not closing the entries.
}
// Simulate a crash.
SimulateCrash();
ASSERT_THAT(CreateEntry("Something else", &entry), IsOk());
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
FlushQueueForTest();
EXPECT_EQ(33, cache_->GetEntryCount());
SetMaxSize(kSize);
// For the new eviction code, all corrupt entries are on the second list so
// they are not going away that easy.
if (new_eviction_) {
EXPECT_THAT(DoomAllEntries(), IsOk());
}
entry->Close(); // Trim the cache.
FlushQueueForTest();
// We may abort the eviction before cleaning up everything.
base::RunLoop().RunUntilIdle();
FlushQueueForTest();
// If it's not clear enough: we may still have eviction tasks running at this
// time, so the number of entries is changing while we read it.
ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
EXPECT_GE(30, cache_->GetEntryCount());
ANNOTATE_IGNORE_READS_AND_WRITES_END();
// For extra messiness, the integrity check for the cache can actually cause
// evictions if it's over-capacity, which would race with above. So change the
// size we pass to CheckCacheIntegrity (but don't mess with existing backend's
// state.
size_ = 0;
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, TrimInvalidEntry2) {
BackendTrimInvalidEntry2();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry2) {
SetNewEviction();
BackendTrimInvalidEntry2();
}
#endif // !defined(LEAK_SANITIZER)
void DiskCacheBackendTest::BackendEnumerations() {
InitCache();
Time initial = Time::Now();
const int kNumEntries = 100;
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
Time final = Time::Now();
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
int count = 0;
Time last_modified[kNumEntries];
Time last_used[kNumEntries];
while (iter->OpenNextEntry(&entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
if (count < kNumEntries) {
last_modified[count] = entry->GetLastModified();
last_used[count] = entry->GetLastUsed();
EXPECT_TRUE(initial <= last_modified[count]);
EXPECT_TRUE(final >= last_modified[count]);
}
entry->Close();
count++;
};
EXPECT_EQ(kNumEntries, count);
iter = CreateIterator();
count = 0;
// The previous enumeration should not have changed the timestamps.
while (iter->OpenNextEntry(&entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
if (count < kNumEntries) {
EXPECT_TRUE(last_modified[count] == entry->GetLastModified());
EXPECT_TRUE(last_used[count] == entry->GetLastUsed());
}
entry->Close();
count++;
};
EXPECT_EQ(kNumEntries, count);
}
TEST_F(DiskCacheBackendTest, Enumerations) {
BackendEnumerations();
}
TEST_F(DiskCacheBackendTest, NewEvictionEnumerations) {
SetNewEviction();
BackendEnumerations();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations) {
SetMemoryOnlyMode();
BackendEnumerations();
}
TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations) {
SetCacheType(net::SHADER_CACHE);
BackendEnumerations();
}
TEST_F(DiskCacheBackendTest, AppCacheEnumerations) {
SetCacheType(net::APP_CACHE);
BackendEnumerations();
}
// Verifies enumerations while entries are open.
void DiskCacheBackendTest::BackendEnumerations2() {
InitCache();
const std::string first("first");
const std::string second("second");
disk_cache::Entry *entry1, *entry2;
ASSERT_THAT(CreateEntry(first, &entry1), IsOk());
entry1->Close();
ASSERT_THAT(CreateEntry(second, &entry2), IsOk());
entry2->Close();
FlushQueueForTest();
// Make sure that the timestamp is not the same.
AddDelay();
ASSERT_THAT(OpenEntry(second, &entry1), IsOk());
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), second);
// Two entries and the iterator pointing at "first".
entry1->Close();
entry2->Close();
// The iterator should still be valid, so we should not crash.
ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), first);
entry2->Close();
iter = CreateIterator();
// Modify the oldest entry and get the newest element.
ASSERT_THAT(OpenEntry(first, &entry1), IsOk());
EXPECT_EQ(0, WriteData(entry1, 0, 200, NULL, 0, false));
ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
if (type_ == net::APP_CACHE) {
// The list is not updated.
EXPECT_EQ(entry2->GetKey(), second);
} else {
EXPECT_EQ(entry2->GetKey(), first);
}
entry1->Close();
entry2->Close();
}
TEST_F(DiskCacheBackendTest, Enumerations2) {
BackendEnumerations2();
}
TEST_F(DiskCacheBackendTest, NewEvictionEnumerations2) {
SetNewEviction();
BackendEnumerations2();
}
TEST_F(DiskCacheBackendTest, AppCacheEnumerations2) {
SetCacheType(net::APP_CACHE);
BackendEnumerations2();
}
TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations2) {
SetCacheType(net::SHADER_CACHE);
BackendEnumerations2();
}
void DiskCacheBackendTest::BackendDoomMidEnumeration() {
InitCache();
const int kNumEntries = 100;
std::set<std::string> keys;
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
keys.insert(key);
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
int count = 0;
while (iter->OpenNextEntry(&entry) == net::OK) {
if (count == 0) {
// Delete a random entry from the cache while in the midst of iteration.
auto key_to_doom = keys.begin();
while (*key_to_doom == entry->GetKey())
key_to_doom++;
ASSERT_THAT(DoomEntry(*key_to_doom), IsOk());
ASSERT_EQ(1u, keys.erase(*key_to_doom));
}
ASSERT_NE(nullptr, entry);
EXPECT_EQ(1u, keys.erase(entry->GetKey()));
entry->Close();
count++;
};
EXPECT_EQ(kNumEntries - 1, cache_->GetEntryCount());
EXPECT_EQ(0u, keys.size());
}
TEST_F(DiskCacheBackendTest, DoomEnumerations) {
BackendDoomMidEnumeration();
}
TEST_F(DiskCacheBackendTest, NewEvictionDoomEnumerations) {
SetNewEviction();
BackendDoomMidEnumeration();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEnumerations) {
SetMemoryOnlyMode();
BackendDoomMidEnumeration();
}
TEST_F(DiskCacheBackendTest, ShaderCacheDoomEnumerations) {
SetCacheType(net::SHADER_CACHE);
BackendDoomMidEnumeration();
}
TEST_F(DiskCacheBackendTest, AppCacheDoomEnumerations) {
SetCacheType(net::APP_CACHE);
BackendDoomMidEnumeration();
}
TEST_F(DiskCacheBackendTest, SimpleDoomEnumerations) {
SetSimpleCacheMode();
BackendDoomMidEnumeration();
}
// Verify that ReadData calls do not update the LRU cache
// when using the SHADER_CACHE type.
TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
SetCacheType(net::SHADER_CACHE);
InitCache();
const std::string first("first");
const std::string second("second");
disk_cache::Entry *entry1, *entry2;
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
ASSERT_THAT(CreateEntry(first, &entry1), IsOk());
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
ASSERT_THAT(CreateEntry(second, &entry2), IsOk());
entry2->Close();
FlushQueueForTest();
// Make sure that the timestamp is not the same.
AddDelay();
// Read from the last item in the LRU.
EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
entry1->Close();
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry2), IsOk());
EXPECT_EQ(entry2->GetKey(), second);
entry2->Close();
}
#if !defined(LEAK_SANITIZER)
// Verify handling of invalid entries while doing enumerations.
// We'll be leaking memory from this test.
void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
InitCache();
std::string key("Some key");
disk_cache::Entry *entry, *entry1, *entry2;
ASSERT_THAT(CreateEntry(key, &entry1), IsOk());
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
entry1->Close();
ASSERT_THAT(OpenEntry(key, &entry1), IsOk());
EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
std::string key2("Another key");
ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
entry2->Close();
ASSERT_EQ(2, cache_->GetEntryCount());
SimulateCrash();
std::unique_ptr<TestIterator> iter = CreateIterator();
int count = 0;
while (iter->OpenNextEntry(&entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
EXPECT_EQ(key2, entry->GetKey());
entry->Close();
count++;
};
EXPECT_EQ(1, count);
EXPECT_EQ(1, cache_->GetEntryCount());
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, InvalidEntryEnumeration) {
BackendInvalidEntryEnumeration();
}
// We'll be leaking memory from this test.
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryEnumeration) {
SetNewEviction();
BackendInvalidEntryEnumeration();
}
#endif // !defined(LEAK_SANITIZER)
// Tests that if for some reason entries are modified close to existing cache
// iterators, we don't generate fatal errors or reset the cache.
void DiskCacheBackendTest::BackendFixEnumerators() {
InitCache();
int seed = static_cast<int>(Time::Now().ToInternalValue());
srand(seed);
const int kNumEntries = 10;
for (int i = 0; i < kNumEntries; i++) {
std::string key = GenerateKey(true);
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter1 = CreateIterator(),
iter2 = CreateIterator();
ASSERT_THAT(iter1->OpenNextEntry(&entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
// Let's go to the middle of the list.
for (int i = 0; i < kNumEntries / 2; i++) {
if (entry1)
entry1->Close();
ASSERT_THAT(iter1->OpenNextEntry(&entry1), IsOk());
ASSERT_TRUE(NULL != entry1);
ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
entry2->Close();
}
// Messing up with entry1 will modify entry2->next.
entry1->Doom();
ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
// The link entry2->entry1 should be broken.
EXPECT_NE(entry2->GetKey(), entry1->GetKey());
entry1->Close();
entry2->Close();
// And the second iterator should keep working.
ASSERT_THAT(iter2->OpenNextEntry(&entry2), IsOk());
ASSERT_TRUE(NULL != entry2);
entry2->Close();
}
TEST_F(DiskCacheBackendTest, FixEnumerators) {
BackendFixEnumerators();
}
TEST_F(DiskCacheBackendTest, NewEvictionFixEnumerators) {
SetNewEviction();
BackendFixEnumerators();
}
void DiskCacheBackendTest::BackendDoomRecent() {
InitCache();
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("first", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("second", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle = Time::Now();
ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time final = Time::Now();
ASSERT_EQ(4, cache_->GetEntryCount());
EXPECT_THAT(DoomEntriesSince(final), IsOk());
ASSERT_EQ(4, cache_->GetEntryCount());
EXPECT_THAT(DoomEntriesSince(middle), IsOk());
ASSERT_EQ(2, cache_->GetEntryCount());
ASSERT_THAT(OpenEntry("second", &entry), IsOk());
entry->Close();
}
TEST_F(DiskCacheBackendTest, DoomRecent) {
BackendDoomRecent();
}
TEST_F(DiskCacheBackendTest, NewEvictionDoomRecent) {
SetNewEviction();
BackendDoomRecent();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomRecent) {
SetMemoryOnlyMode();
BackendDoomRecent();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesSinceSparse) {
SetMemoryOnlyMode();
base::Time start;
InitSparseCache(&start, NULL);
DoomEntriesSince(start);
EXPECT_EQ(1, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DoomEntriesSinceSparse) {
base::Time start;
InitSparseCache(&start, NULL);
DoomEntriesSince(start);
// NOTE: BackendImpl counts child entries in its GetEntryCount(), while
// MemBackendImpl does not. Thats why expected value differs here from
// MemoryOnlyDoomEntriesSinceSparse.
EXPECT_EQ(3, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAllSparse) {
SetMemoryOnlyMode();
InitSparseCache(NULL, NULL);
EXPECT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DoomAllSparse) {
InitSparseCache(NULL, NULL);
EXPECT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, cache_->GetEntryCount());
}
// This test is for https://crbug.com/827492.
TEST_F(DiskCacheBackendTest, InMemorySparseEvict) {
const int kMaxSize = 512;
SetMaxSize(kMaxSize);
SetMemoryOnlyMode();
InitCache();
scoped_refptr<net::IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(64);
CacheTestFillBuffer(buffer->data(), 64, false /* no_nulls */);
std::vector<disk_cache::ScopedEntryPtr> entries;
disk_cache::Entry* entry = nullptr;
// Create a bunch of entries
for (size_t i = 0; i < 14; i++) {
std::string name = "http://www." + std::to_string(i) + ".com/";
ASSERT_THAT(CreateEntry(name, &entry), IsOk());
entries.push_back(disk_cache::ScopedEntryPtr(entry));
}
// Create several sparse entries and fill with enough data to
// pass eviction threshold
ASSERT_EQ(64, WriteSparseData(entries[0].get(), 0, buffer.get(), 64));
ASSERT_EQ(net::ERR_FAILED,
WriteSparseData(entries[0].get(), 10000, buffer.get(), 4));
ASSERT_EQ(63, WriteSparseData(entries[1].get(), 0, buffer.get(), 63));
ASSERT_EQ(64, WriteSparseData(entries[2].get(), 0, buffer.get(), 64));
ASSERT_EQ(64, WriteSparseData(entries[3].get(), 0, buffer.get(), 64));
// Close all the entries, leaving a populated LRU list
// with all entries having refcount 0 (doom implies deletion)
entries.clear();
// Create a new entry, triggering buggy eviction
ASSERT_THAT(CreateEntry("http://www.14.com/", &entry), IsOk());
entry->Close();
}
void DiskCacheBackendTest::BackendDoomBetween() {
InitCache();
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("first", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle_start = Time::Now();
ASSERT_THAT(CreateEntry("second", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle_end = Time::Now();
ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
entry->Close();
ASSERT_THAT(OpenEntry("fourth", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time final = Time::Now();
ASSERT_EQ(4, cache_->GetEntryCount());
EXPECT_THAT(DoomEntriesBetween(middle_start, middle_end), IsOk());
ASSERT_EQ(2, cache_->GetEntryCount());
ASSERT_THAT(OpenEntry("fourth", &entry), IsOk());
entry->Close();
EXPECT_THAT(DoomEntriesBetween(middle_start, final), IsOk());
ASSERT_EQ(1, cache_->GetEntryCount());
ASSERT_THAT(OpenEntry("first", &entry), IsOk());
entry->Close();
}
TEST_F(DiskCacheBackendTest, DoomBetween) {
BackendDoomBetween();
}
TEST_F(DiskCacheBackendTest, NewEvictionDoomBetween) {
SetNewEviction();
BackendDoomBetween();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomBetween) {
SetMemoryOnlyMode();
BackendDoomBetween();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesBetweenSparse) {
SetMemoryOnlyMode();
base::Time start, end;
InitSparseCache(&start, &end);
DoomEntriesBetween(start, end);
EXPECT_EQ(3, cache_->GetEntryCount());
start = end;
end = base::Time::Now();
DoomEntriesBetween(start, end);
EXPECT_EQ(1, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DoomEntriesBetweenSparse) {
base::Time start, end;
InitSparseCache(&start, &end);
DoomEntriesBetween(start, end);
EXPECT_EQ(9, cache_->GetEntryCount());
start = end;
end = base::Time::Now();
DoomEntriesBetween(start, end);
EXPECT_EQ(3, cache_->GetEntryCount());
}
void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() {
InitCache();
// The cache is initially empty.
EXPECT_EQ(0, CalculateSizeOfAllEntries());
// Generate random entries and populate them with data of respective
// sizes 0, 1, ..., count - 1 bytes.
std::set<std::string> key_pool;
CreateSetOfRandomEntries(&key_pool);
int count = 0;
int total_size = 0;
for (std::string key : key_pool) {
std::string data(count, ' ');
scoped_refptr<net::StringIOBuffer> buffer =
base::MakeRefCounted<net::StringIOBuffer>(data);
// Alternate between writing to first two streams to test that we do not
// take only one stream into account.
disk_cache::Entry* entry;
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_EQ(count, WriteData(entry, count % 2, 0, buffer.get(), count, true));
entry->Close();
total_size += GetRoundedSize(count + GetEntryMetadataSize(key));
++count;
}
int result = CalculateSizeOfAllEntries();
EXPECT_EQ(total_size, result);
// Add another entry and test if the size is updated. Then remove it and test
// if the size is back to original value.
{
const int last_entry_size = 47;
std::string data(last_entry_size, ' ');
scoped_refptr<net::StringIOBuffer> buffer =
base::MakeRefCounted<net::StringIOBuffer>(data);
disk_cache::Entry* entry;
std::string key = GenerateKey(true);
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
ASSERT_EQ(last_entry_size,
WriteData(entry, 0, 0, buffer.get(), last_entry_size, true));
entry->Close();
int new_result = CalculateSizeOfAllEntries();
EXPECT_EQ(
result + GetRoundedSize(last_entry_size + GetEntryMetadataSize(key)),
new_result);
DoomEntry(key);
new_result = CalculateSizeOfAllEntries();
EXPECT_EQ(result, new_result);
}
// After dooming the entries, the size should be back to zero.
ASSERT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, CalculateSizeOfAllEntries());
}
TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) {
BackendCalculateSizeOfAllEntries();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfAllEntries) {
SetMemoryOnlyMode();
BackendCalculateSizeOfAllEntries();
}
TEST_F(DiskCacheBackendTest, SimpleCacheCalculateSizeOfAllEntries) {
// Use net::APP_CACHE to make size estimations deterministic via
// non-optimistic writes.
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendCalculateSizeOfAllEntries();
}
void DiskCacheBackendTest::BackendCalculateSizeOfEntriesBetween() {
InitCache();
EXPECT_EQ(0, CalculateSizeOfEntriesBetween(base::Time(), base::Time::Max()));
Time start = Time::Now();
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("first", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time middle = Time::Now();
AddDelay();
ASSERT_THAT(CreateEntry("second", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("third_entry", &entry), IsOk());
entry->Close();
FlushQueueForTest();
AddDelay();
Time end = Time::Now();
int size_1 = GetRoundedSize(GetEntryMetadataSize("first"));
int size_2 = GetRoundedSize(GetEntryMetadataSize("second"));
int size_3 = GetRoundedSize(GetEntryMetadataSize("third_entry"));
ASSERT_EQ(3, cache_->GetEntryCount());
ASSERT_EQ(CalculateSizeOfAllEntries(),
CalculateSizeOfEntriesBetween(base::Time(), base::Time::Max()));
int start_end = CalculateSizeOfEntriesBetween(start, end);
ASSERT_EQ(CalculateSizeOfAllEntries(), start_end);
ASSERT_EQ(size_1 + size_2 + size_3, start_end);
ASSERT_EQ(size_1, CalculateSizeOfEntriesBetween(start, middle));
ASSERT_EQ(size_2 + size_3, CalculateSizeOfEntriesBetween(middle, end));
// After dooming the entries, the size should be back to zero.
ASSERT_THAT(DoomAllEntries(), IsOk());
EXPECT_EQ(0, CalculateSizeOfEntriesBetween(base::Time(), base::Time::Max()));
}
TEST_F(DiskCacheBackendTest, CalculateSizeOfEntriesBetween) {
InitCache();
ASSERT_EQ(net::ERR_NOT_IMPLEMENTED,
CalculateSizeOfEntriesBetween(base::Time(), base::Time::Max()));
}
TEST_F(DiskCacheBackendTest, MemoryOnlyCalculateSizeOfEntriesBetween) {
SetMemoryOnlyMode();
BackendCalculateSizeOfEntriesBetween();
}
TEST_F(DiskCacheBackendTest, SimpleCacheCalculateSizeOfEntriesBetween) {
// Use net::APP_CACHE to make size estimations deterministic via
// non-optimistic writes.
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendCalculateSizeOfEntriesBetween();
}
void DiskCacheBackendTest::BackendTransaction(const std::string& name,
int num_entries,
bool load) {
success_ = false;
ASSERT_TRUE(CopyTestCache(name));
DisableFirstCleanup();
uint32_t mask;
if (load) {
mask = 0xf;
SetMaxSize(0x100000);
} else {
// Clear the settings from the previous run.
mask = 0;
SetMaxSize(0);
}
SetMask(mask);
InitCache();
ASSERT_EQ(num_entries + 1, cache_->GetEntryCount());
std::string key("the first key");
disk_cache::Entry* entry1;
ASSERT_NE(net::OK, OpenEntry(key, &entry1));
int actual = cache_->GetEntryCount();
if (num_entries != actual) {
ASSERT_TRUE(load);
// If there is a heavy load, inserting an entry will make another entry
// dirty (on the hash bucket) so two entries are removed.
ASSERT_EQ(num_entries - 1, actual);
}
cache_.reset();
cache_impl_ = NULL;
ASSERT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, MaxSize(), mask));
success_ = true;
}
void DiskCacheBackendTest::BackendRecoverInsert() {
// Tests with an empty cache.
BackendTransaction("insert_empty1", 0, false);
ASSERT_TRUE(success_) << "insert_empty1";
BackendTransaction("insert_empty2", 0, false);
ASSERT_TRUE(success_) << "insert_empty2";
BackendTransaction("insert_empty3", 0, false);
ASSERT_TRUE(success_) << "insert_empty3";
// Tests with one entry on the cache.
BackendTransaction("insert_one1", 1, false);
ASSERT_TRUE(success_) << "insert_one1";
BackendTransaction("insert_one2", 1, false);
ASSERT_TRUE(success_) << "insert_one2";
BackendTransaction("insert_one3", 1, false);
ASSERT_TRUE(success_) << "insert_one3";
// Tests with one hundred entries on the cache, tiny index.
BackendTransaction("insert_load1", 100, true);
ASSERT_TRUE(success_) << "insert_load1";
BackendTransaction("insert_load2", 100, true);
ASSERT_TRUE(success_) << "insert_load2";
}
TEST_F(DiskCacheBackendTest, RecoverInsert) {
BackendRecoverInsert();
}
TEST_F(DiskCacheBackendTest, NewEvictionRecoverInsert) {
SetNewEviction();
BackendRecoverInsert();
}
void DiskCacheBackendTest::BackendRecoverRemove() {
// Removing the only element.
BackendTransaction("remove_one1", 0, false);
ASSERT_TRUE(success_) << "remove_one1";
BackendTransaction("remove_one2", 0, false);
ASSERT_TRUE(success_) << "remove_one2";
BackendTransaction("remove_one3", 0, false);
ASSERT_TRUE(success_) << "remove_one3";
// Removing the head.
BackendTransaction("remove_head1", 1, false);
ASSERT_TRUE(success_) << "remove_head1";
BackendTransaction("remove_head2", 1, false);
ASSERT_TRUE(success_) << "remove_head2";
BackendTransaction("remove_head3", 1, false);
ASSERT_TRUE(success_) << "remove_head3";
// Removing the tail.
BackendTransaction("remove_tail1", 1, false);
ASSERT_TRUE(success_) << "remove_tail1";
BackendTransaction("remove_tail2", 1, false);
ASSERT_TRUE(success_) << "remove_tail2";
BackendTransaction("remove_tail3", 1, false);
ASSERT_TRUE(success_) << "remove_tail3";
// Removing with one hundred entries on the cache, tiny index.
BackendTransaction("remove_load1", 100, true);
ASSERT_TRUE(success_) << "remove_load1";
BackendTransaction("remove_load2", 100, true);
ASSERT_TRUE(success_) << "remove_load2";
BackendTransaction("remove_load3", 100, true);
ASSERT_TRUE(success_) << "remove_load3";
// This case cannot be reverted.
BackendTransaction("remove_one4", 0, false);
ASSERT_TRUE(success_) << "remove_one4";
BackendTransaction("remove_head4", 1, false);
ASSERT_TRUE(success_) << "remove_head4";
}
#if defined(OS_WIN)
// http://crbug.com/396392
#define MAYBE_RecoverRemove DISABLED_RecoverRemove
#else
#define MAYBE_RecoverRemove RecoverRemove
#endif
TEST_F(DiskCacheBackendTest, MAYBE_RecoverRemove) {
BackendRecoverRemove();
}
#if defined(OS_WIN)
// http://crbug.com/396392
#define MAYBE_NewEvictionRecoverRemove DISABLED_NewEvictionRecoverRemove
#else
#define MAYBE_NewEvictionRecoverRemove NewEvictionRecoverRemove
#endif
TEST_F(DiskCacheBackendTest, MAYBE_NewEvictionRecoverRemove) {
SetNewEviction();
BackendRecoverRemove();
}
void DiskCacheBackendTest::BackendRecoverWithEviction() {
success_ = false;
ASSERT_TRUE(CopyTestCache("insert_load1"));
DisableFirstCleanup();
SetMask(0xf);
SetMaxSize(0x1000);
// We should not crash here.
InitCache();
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, RecoverWithEviction) {
BackendRecoverWithEviction();
}
TEST_F(DiskCacheBackendTest, NewEvictionRecoverWithEviction) {
SetNewEviction();
BackendRecoverWithEviction();
}
// Tests that the |BackendImpl| fails to start with the wrong cache version.
TEST_F(DiskCacheTest, WrongVersion) {
ASSERT_TRUE(CopyTestCache("wrong_version"));
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(cache_path_, nullptr, nullptr,
nullptr));
int rv = cache->Init(cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsError(net::ERR_FAILED));
}
// Tests that the disk cache successfully joins the control group, dropping the
// existing cache in favour of a new empty cache.
// Disabled on android since this test requires cache creator to create
// blockfile caches.
#if !defined(OS_ANDROID)
TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
std::unique_ptr<disk_cache::BackendImpl> cache =
CreateExistingEntryCache(cache_path_);
ASSERT_TRUE(cache.get());
cache.reset();
// Instantiate the SimpleCacheTrial, forcing this run into the
// ExperimentControl group.
base::FieldTrialList field_trial_list(
std::make_unique<base::MockEntropyProvider>());
base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
"ExperimentControl");
net::TestCompletionCallback cb;
std::unique_ptr<disk_cache::Backend> base_cache;
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE, cache_path_, 0, true, NULL,
&base_cache, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(0, base_cache->GetEntryCount());
}
#endif
// Tests that the disk cache can restart in the control group preserving
// existing entries.
TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
// Instantiate the SimpleCacheTrial, forcing this run into the
// ExperimentControl group.
base::FieldTrialList field_trial_list(
std::make_unique<base::MockEntropyProvider>());
base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
"ExperimentControl");
std::unique_ptr<disk_cache::BackendImpl> cache =
CreateExistingEntryCache(cache_path_);
ASSERT_TRUE(cache.get());
net::TestCompletionCallback cb;
const int kRestartCount = 5;
for (int i = 0; i < kRestartCount; ++i) {
cache.reset(
new disk_cache::BackendImpl(cache_path_, nullptr, nullptr, nullptr));
int rv = cache->Init(cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(1, cache->GetEntryCount());
disk_cache::Entry* entry = NULL;
rv = cache->OpenEntry(kExistingEntryKey, net::HIGHEST, &entry,
cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_NE(nullptr, entry);
entry->Close();
}
}
// Tests that the disk cache can leave the control group preserving existing
// entries.
TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
{
// Instantiate the SimpleCacheTrial, forcing this run into the
// ExperimentControl group.
base::FieldTrialList field_trial_list(
std::make_unique<base::MockEntropyProvider>());
base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
"ExperimentControl");
std::unique_ptr<disk_cache::BackendImpl> cache =
CreateExistingEntryCache(cache_path_);
ASSERT_TRUE(cache.get());
}
// Instantiate the SimpleCacheTrial, forcing this run into the
// ExperimentNo group.
base::FieldTrialList field_trial_list(
std::make_unique<base::MockEntropyProvider>());
base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial", "ExperimentNo");
net::TestCompletionCallback cb;
const int kRestartCount = 5;
for (int i = 0; i < kRestartCount; ++i) {
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(cache_path_, nullptr, nullptr,
nullptr));
int rv = cache->Init(cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_EQ(1, cache->GetEntryCount());
disk_cache::Entry* entry = NULL;
rv = cache->OpenEntry(kExistingEntryKey, net::HIGHEST, &entry,
cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
EXPECT_NE(nullptr, entry);
entry->Close();
}
}
// Tests that the cache is properly restarted on recovery error.
// Disabled on android since this test requires cache creator to create
// blockfile caches.
#if !defined(OS_ANDROID)
TEST_F(DiskCacheBackendTest, DeleteOld) {
ASSERT_TRUE(CopyTestCache("wrong_version"));
SetNewEviction();
net::TestCompletionCallback cb;
bool prev = base::ThreadRestrictions::SetIOAllowed(false);
base::FilePath path(cache_path_);
int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE,
net::CACHE_BACKEND_BLOCKFILE, path, 0,
true, NULL, &cache_, cb.callback());
path.clear(); // Make sure path was captured by the previous call.
ASSERT_THAT(cb.GetResult(rv), IsOk());
base::ThreadRestrictions::SetIOAllowed(prev);
cache_.reset();
EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, /*max_size = */ 0,
mask_));
}
#endif
// We want to be able to deal with messed up entries on disk.
void DiskCacheBackendTest::BackendInvalidEntry2() {
ASSERT_TRUE(CopyTestCache("bad_entry"));
DisableFirstCleanup();
InitCache();
disk_cache::Entry *entry1, *entry2;
ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
entry1->Close();
// CheckCacheIntegrity will fail at this point.
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, InvalidEntry2) {
BackendInvalidEntry2();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry2) {
SetNewEviction();
BackendInvalidEntry2();
}
// Tests that we don't crash or hang when enumerating this cache.
void DiskCacheBackendTest::BackendInvalidEntry3() {
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
while (iter->OpenNextEntry(&entry) == net::OK) {
entry->Close();
}
}
TEST_F(DiskCacheBackendTest, InvalidEntry3) {
ASSERT_TRUE(CopyTestCache("dirty_entry3"));
BackendInvalidEntry3();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry3) {
ASSERT_TRUE(CopyTestCache("dirty_entry4"));
SetNewEviction();
BackendInvalidEntry3();
DisableIntegrityCheck();
}
// Test that we handle a dirty entry on the LRU list, already replaced with
// the same key, and with hash collisions.
TEST_F(DiskCacheBackendTest, InvalidEntry4) {
ASSERT_TRUE(CopyTestCache("dirty_entry3"));
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
TrimForTest(false);
}
// Test that we handle a dirty entry on the deleted list, already replaced with
// the same key, and with hash collisions.
TEST_F(DiskCacheBackendTest, InvalidEntry5) {
ASSERT_TRUE(CopyTestCache("dirty_entry4"));
SetNewEviction();
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
TrimDeletedListForTest(false);
}
TEST_F(DiskCacheBackendTest, InvalidEntry6) {
ASSERT_TRUE(CopyTestCache("dirty_entry5"));
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
// There is a dirty entry (but marked as clean) at the end, pointing to a
// deleted entry through the hash collision list. We should not re-insert the
// deleted entry into the index table.
TrimForTest(false);
// The cache should be clean (as detected by CheckCacheIntegrity).
}
// Tests that we don't hang when there is a loop on the hash collision list.
// The test cache could be a result of bug 69135.
TEST_F(DiskCacheBackendTest, BadNextEntry1) {
ASSERT_TRUE(CopyTestCache("list_loop2"));
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
// The second entry points at itselft, and the first entry is not accessible
// though the index, but it is at the head of the LRU.
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("The first key", &entry), IsOk());
entry->Close();
TrimForTest(false);
TrimForTest(false);
ASSERT_THAT(OpenEntry("The first key", &entry), IsOk());
entry->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
}
// Tests that we don't hang when there is a loop on the hash collision list.
// The test cache could be a result of bug 69135.
TEST_F(DiskCacheBackendTest, BadNextEntry2) {
ASSERT_TRUE(CopyTestCache("list_loop3"));
SetMask(0x1); // 2-entry table.
SetMaxSize(0x3000); // 12 kB.
DisableFirstCleanup();
InitCache();
// There is a wide loop of 5 entries.
disk_cache::Entry* entry;
ASSERT_NE(net::OK, OpenEntry("Not present key", &entry));
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry6) {
ASSERT_TRUE(CopyTestCache("bad_rankings3"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
// The second entry is dirty, but removing it should not corrupt the list.
disk_cache::Entry* entry;
ASSERT_NE(net::OK, OpenEntry("the second key", &entry));
ASSERT_THAT(OpenEntry("the first key", &entry), IsOk());
// This should not delete the cache.
entry->Doom();
FlushQueueForTest();
entry->Close();
ASSERT_THAT(OpenEntry("some other key", &entry), IsOk());
entry->Close();
}
// Tests handling of corrupt entries by keeping the rankings node around, with
// a fatal failure.
void DiskCacheBackendTest::BackendInvalidEntry7() {
const int kSize = 0x3000; // 12 kB.
SetMaxSize(kSize * 10);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->rankings()->Data()->next = 0;
entry_impl->rankings()->Store();
entry->Close();
FlushQueueForTest();
EXPECT_EQ(2, cache_->GetEntryCount());
// This should detect the bad entry.
EXPECT_NE(net::OK, OpenEntry(second, &entry));
EXPECT_EQ(1, cache_->GetEntryCount());
// We should delete the cache. The list still has a corrupt node.
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
FlushQueueForTest();
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, InvalidEntry7) {
BackendInvalidEntry7();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry7) {
SetNewEviction();
BackendInvalidEntry7();
}
// Tests handling of corrupt entries by keeping the rankings node around, with
// a non fatal failure.
void DiskCacheBackendTest::BackendInvalidEntry8() {
const int kSize = 0x3000; // 12 kB
SetMaxSize(kSize * 10);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->rankings()->Data()->contents = 0;
entry_impl->rankings()->Store();
entry->Close();
FlushQueueForTest();
EXPECT_EQ(2, cache_->GetEntryCount());
// This should detect the bad entry.
EXPECT_NE(net::OK, OpenEntry(second, &entry));
EXPECT_EQ(1, cache_->GetEntryCount());
// We should not delete the cache.
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
EXPECT_EQ(1, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, InvalidEntry8) {
BackendInvalidEntry8();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry8) {
SetNewEviction();
BackendInvalidEntry8();
}
// Tests handling of corrupt entries detected by enumerations. Note that these
// tests (xx9 to xx11) are basically just going though slightly different
// codepaths so they are tighlty coupled with the code, but that is better than
// not testing error handling code.
void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
const int kSize = 0x3000; // 12 kB.
SetMaxSize(kSize * 10);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
FlushQueueForTest();
EXPECT_EQ(2, cache_->GetEntryCount());
if (eviction) {
TrimForTest(false);
EXPECT_EQ(1, cache_->GetEntryCount());
TrimForTest(false);
EXPECT_EQ(1, cache_->GetEntryCount());
} else {
// We should detect the problem through the list, but we should not delete
// the entry, just fail the iteration.
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
// Now a full iteration will work, and return one entry.
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
// This should detect what's left of the bad entry.
EXPECT_NE(net::OK, OpenEntry(second, &entry));
EXPECT_EQ(2, cache_->GetEntryCount());
}
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, InvalidEntry9) {
BackendInvalidEntry9(false);
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry9) {
SetNewEviction();
BackendInvalidEntry9(false);
}
TEST_F(DiskCacheBackendTest, TrimInvalidEntry9) {
BackendInvalidEntry9(true);
}
TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry9) {
SetNewEviction();
BackendInvalidEntry9(true);
}
// Tests handling of corrupt entries detected by enumerations.
void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
const int kSize = 0x3000; // 12 kB.
SetMaxSize(kSize * 10);
SetNewEviction();
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(OpenEntry(first, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
EXPECT_EQ(3, cache_->GetEntryCount());
// We have:
// List 0: third -> second (bad).
// List 1: first.
if (eviction) {
// Detection order: second -> first -> third.
TrimForTest(false);
EXPECT_EQ(3, cache_->GetEntryCount());
TrimForTest(false);
EXPECT_EQ(2, cache_->GetEntryCount());
TrimForTest(false);
EXPECT_EQ(1, cache_->GetEntryCount());
} else {
// Detection order: third -> second -> first.
// We should detect the problem through the list, but we should not delete
// the entry.
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
EXPECT_EQ(first, entry->GetKey());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
}
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, InvalidEntry10) {
BackendInvalidEntry10(false);
}
TEST_F(DiskCacheBackendTest, TrimInvalidEntry10) {
BackendInvalidEntry10(true);
}
// Tests handling of corrupt entries detected by enumerations.
void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
const int kSize = 0x3000; // 12 kB.
SetMaxSize(kSize * 10);
SetNewEviction();
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(OpenEntry(first, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
entry->Close();
ASSERT_THAT(OpenEntry(second, &entry), IsOk());
EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
FlushQueueForTest();
EXPECT_EQ(3, cache_->GetEntryCount());
// We have:
// List 0: third.
// List 1: second (bad) -> first.
if (eviction) {
// Detection order: third -> first -> second.
TrimForTest(false);
EXPECT_EQ(2, cache_->GetEntryCount());
TrimForTest(false);
EXPECT_EQ(1, cache_->GetEntryCount());
TrimForTest(false);
EXPECT_EQ(1, cache_->GetEntryCount());
} else {
// Detection order: third -> second.
// We should detect the problem through the list, but we should not delete
// the entry, just fail the iteration.
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
// Now a full iteration will work, and return two entries.
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
}
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, InvalidEntry11) {
BackendInvalidEntry11(false);
}
TEST_F(DiskCacheBackendTest, TrimInvalidEntry11) {
BackendInvalidEntry11(true);
}
// Tests handling of corrupt entries in the middle of a long eviction run.
void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
const int kSize = 0x3000; // 12 kB
SetMaxSize(kSize * 10);
InitCache();
std::string first("some key");
std::string second("something else");
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry(first, &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry(second, &entry), IsOk());
// Corrupt this entry.
disk_cache::EntryImpl* entry_impl =
static_cast<disk_cache::EntryImpl*>(entry);
entry_impl->entry()->Data()->state = 0xbad;
entry_impl->entry()->Store();
entry->Close();
ASSERT_THAT(CreateEntry("third", &entry), IsOk());
entry->Close();
ASSERT_THAT(CreateEntry("fourth", &entry), IsOk());
TrimForTest(true);
EXPECT_EQ(1, cache_->GetEntryCount());
entry->Close();
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, TrimInvalidEntry12) {
BackendTrimInvalidEntry12();
}
TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry12) {
SetNewEviction();
BackendTrimInvalidEntry12();
}
// We want to be able to deal with messed up entries on disk.
void DiskCacheBackendTest::BackendInvalidRankings2() {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
disk_cache::Entry *entry1, *entry2;
EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
ASSERT_THAT(OpenEntry("some other key", &entry2), IsOk());
entry2->Close();
// CheckCacheIntegrity will fail at this point.
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, InvalidRankings2) {
BackendInvalidRankings2();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankings2) {
SetNewEviction();
BackendInvalidRankings2();
}
// If the LRU is corrupt, we delete the cache.
void DiskCacheBackendTest::BackendInvalidRankings() {
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
entry->Close();
EXPECT_EQ(2, cache_->GetEntryCount());
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
FlushQueueForTest(); // Allow the restart to finish.
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, InvalidRankingsSuccess) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
BackendInvalidRankings();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsSuccess) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
BackendInvalidRankings();
}
TEST_F(DiskCacheBackendTest, InvalidRankingsFailure) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendInvalidRankings();
}
TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsFailure) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendInvalidRankings();
}
// If the LRU is corrupt and we have open entries, we disable the cache.
void DiskCacheBackendTest::BackendDisable() {
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
EXPECT_EQ(0, cache_->GetEntryCount());
EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
entry1->Close();
FlushQueueForTest(); // Flushing the Close posts a task to restart the cache.
FlushQueueForTest(); // This one actually allows that task to complete.
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DisableSuccess) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
BackendDisable();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
BackendDisable();
}
TEST_F(DiskCacheBackendTest, DisableFailure) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendDisable();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendDisable();
}
// This is another type of corruption on the LRU; disable the cache.
void DiskCacheBackendTest::BackendDisable2() {
EXPECT_EQ(8, cache_->GetEntryCount());
disk_cache::Entry* entry;
std::unique_ptr<TestIterator> iter = CreateIterator();
int count = 0;
while (iter->OpenNextEntry(&entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
entry->Close();
count++;
ASSERT_LT(count, 9);
};
FlushQueueForTest();
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DisableSuccess2) {
ASSERT_TRUE(CopyTestCache("list_loop"));
DisableFirstCleanup();
InitCache();
BackendDisable2();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess2) {
ASSERT_TRUE(CopyTestCache("list_loop"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
BackendDisable2();
}
TEST_F(DiskCacheBackendTest, DisableFailure2) {
ASSERT_TRUE(CopyTestCache("list_loop"));
DisableFirstCleanup();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendDisable2();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure2) {
ASSERT_TRUE(CopyTestCache("list_loop"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
SetTestMode(); // Fail cache reinitialization.
BackendDisable2();
}
// If the index size changes when we disable the cache, we should not crash.
void DiskCacheBackendTest::BackendDisable3() {
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_EQ(2, cache_->GetEntryCount());
ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
entry1->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
FlushQueueForTest();
ASSERT_THAT(CreateEntry("Something new", &entry2), IsOk());
entry2->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DisableSuccess3) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
SetMaxSize(20 * 1024 * 1024);
InitCache();
BackendDisable3();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
SetMaxSize(20 * 1024 * 1024);
SetNewEviction();
InitCache();
BackendDisable3();
}
// If we disable the cache, already open entries should work as far as possible.
void DiskCacheBackendTest::BackendDisable4() {
disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
std::unique_ptr<TestIterator> iter = CreateIterator();
ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
char key2[2000];
char key3[20000];
CacheTestFillBuffer(key2, sizeof(key2), true);
CacheTestFillBuffer(key3, sizeof(key3), true);
key2[sizeof(key2) - 1] = '\0';
key3[sizeof(key3) - 1] = '\0';
ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
ASSERT_THAT(CreateEntry(key3, &entry3), IsOk());
const int kBufSize = 20000;
scoped_refptr<net::IOBuffer> buf =
base::MakeRefCounted<net::IOBuffer>(kBufSize);
memset(buf->data(), 0, kBufSize);
EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
// This line should disable the cache but not delete it.
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry4));
EXPECT_EQ(0, cache_->GetEntryCount());
EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));
EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));
EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));
EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));
std::string key = entry2->GetKey();
EXPECT_EQ(sizeof(key2) - 1, key.size());
key = entry3->GetKey();
EXPECT_EQ(sizeof(key3) - 1, key.size());
entry1->Close();
entry2->Close();
entry3->Close();
FlushQueueForTest(); // Flushing the Close posts a task to restart the cache.
FlushQueueForTest(); // This one actually allows that task to complete.
EXPECT_EQ(0, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DisableSuccess4) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
InitCache();
BackendDisable4();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
ASSERT_TRUE(CopyTestCache("bad_rankings"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
BackendDisable4();
}
// Tests the exposed API with a disabled cache.
void DiskCacheBackendTest::BackendDisabledAPI() {
cache_impl_->SetUnitTestMode(); // Simulate failure restarting the cache.
disk_cache::Entry *entry1, *entry2;
std::unique_ptr<TestIterator> iter = CreateIterator();
EXPECT_EQ(2, cache_->GetEntryCount());
ASSERT_THAT(iter->OpenNextEntry(&entry1), IsOk());
entry1->Close();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
FlushQueueForTest();
// The cache should be disabled.
EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
EXPECT_EQ(0, cache_->GetEntryCount());
EXPECT_NE(net::OK, OpenEntry("First", &entry2));
EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
EXPECT_NE(net::OK, DoomEntry("First"));
EXPECT_NE(net::OK, DoomAllEntries());
EXPECT_NE(net::OK, DoomEntriesBetween(Time(), Time::Now()));
EXPECT_NE(net::OK, DoomEntriesSince(Time()));
iter = CreateIterator();
EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
base::StringPairs stats;
cache_->GetStats(&stats);
EXPECT_TRUE(stats.empty());
cache_->OnExternalCacheHit("First");
}
TEST_F(DiskCacheBackendTest, DisabledAPI) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
InitCache();
BackendDisabledAPI();
}
TEST_F(DiskCacheBackendTest, NewEvictionDisabledAPI) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
SetNewEviction();
InitCache();
BackendDisabledAPI();
}
// Test that some eviction of some kind happens.
void DiskCacheBackendTest::BackendEviction() {
const int kMaxSize = 200 * 1024;
const int kMaxEntryCount = 20;
const int kWriteSize = kMaxSize / kMaxEntryCount;
const int kWriteEntryCount = kMaxEntryCount * 2;
static_assert(kWriteEntryCount * kWriteSize > kMaxSize,
"must write more than MaxSize");
SetMaxSize(kMaxSize);
InitSparseCache(nullptr, nullptr);
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kWriteSize);
CacheTestFillBuffer(buffer->data(), kWriteSize, false);
std::string key_prefix("prefix");
for (int i = 0; i < kWriteEntryCount; ++i) {
AddDelay();
disk_cache::Entry* entry = NULL;
ASSERT_THAT(CreateEntry(key_prefix + base::IntToString(i), &entry), IsOk());
disk_cache::ScopedEntryPtr entry_closer(entry);
EXPECT_EQ(kWriteSize,
WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
}
int size = CalculateSizeOfAllEntries();
EXPECT_GT(kMaxSize, size);
}
TEST_F(DiskCacheBackendTest, BackendEviction) {
BackendEviction();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyBackendEviction) {
SetMemoryOnlyMode();
BackendEviction();
}
// TODO(morlovich): Enable BackendEviction test for simple cache after
// performance problems are addressed. See crbug.com/588184 for more
// information.
// This overly specific looking test is a regression test aimed at
// crbug.com/589186.
TEST_F(DiskCacheBackendTest, MemoryOnlyUseAfterFree) {
SetMemoryOnlyMode();
const int kMaxSize = 200 * 1024;
const int kMaxEntryCount = 20;
const int kWriteSize = kMaxSize / kMaxEntryCount;
SetMaxSize(kMaxSize);
InitCache();
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kWriteSize);
CacheTestFillBuffer(buffer->data(), kWriteSize, false);
// Create an entry to be our sparse entry that gets written later.
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("first parent", &entry), IsOk());
disk_cache::ScopedEntryPtr first_parent(entry);
// Create a ton of entries, and keep them open, to put the cache well above
// its eviction threshhold.
const int kTooManyEntriesCount = kMaxEntryCount * 2;
std::list<disk_cache::ScopedEntryPtr> open_entries;
std::string key_prefix("prefix");
for (int i = 0; i < kTooManyEntriesCount; ++i) {
ASSERT_THAT(CreateEntry(key_prefix + base::IntToString(i), &entry), IsOk());
// Not checking the result because it will start to fail once the max size
// is reached.
WriteData(entry, 1, 0, buffer.get(), kWriteSize, false);
open_entries.push_back(disk_cache::ScopedEntryPtr(entry));
}
// Writing this sparse data should not crash. Ignoring the result because
// we're only concerned with not crashing in this particular test.
first_parent->WriteSparseData(32768, buffer.get(), 1024,
net::CompletionOnceCallback());
}
TEST_F(DiskCacheBackendTest, MemoryCapsWritesToMaxSize) {
// Verify that the memory backend won't grow beyond its max size if lots of
// open entries (each smaller than the max entry size) are trying to write
// beyond the max size.
SetMemoryOnlyMode();
const int kMaxSize = 100 * 1024; // 100KB cache
const int kNumEntries = 20; // 20 entries to write
const int kWriteSize = kMaxSize / 10; // Each entry writes 1/10th the max
SetMaxSize(kMaxSize);
InitCache();
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kWriteSize);
CacheTestFillBuffer(buffer->data(), kWriteSize, false);
// Create an entry to be the final entry that gets written later.
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("final", &entry), IsOk());
disk_cache::ScopedEntryPtr final_entry(entry);
// Create a ton of entries, write to the cache, and keep the entries open.
// They should start failing writes once the cache fills.
std::list<disk_cache::ScopedEntryPtr> open_entries;
std::string key_prefix("prefix");
for (int i = 0; i < kNumEntries; ++i) {
ASSERT_THAT(CreateEntry(key_prefix + base::IntToString(i), &entry), IsOk());
WriteData(entry, 1, 0, buffer.get(), kWriteSize, false);
open_entries.push_back(disk_cache::ScopedEntryPtr(entry));
}
EXPECT_GE(kMaxSize, CalculateSizeOfAllEntries());
// Any more writing at this point should cause an error.
EXPECT_THAT(
WriteData(final_entry.get(), 1, 0, buffer.get(), kWriteSize, false),
IsError(net::ERR_INSUFFICIENT_RESOURCES));
}
TEST_F(DiskCacheTest, Backend_UsageStatsTimer) {
MessageLoopHelper helper;
ASSERT_TRUE(CleanupCacheDir());
// Want to use our thread since we call SyncInit ourselves.
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(
cache_path_, nullptr, base::ThreadTaskRunnerHandle::Get(), nullptr));
ASSERT_TRUE(NULL != cache.get());
cache->SetUnitTestMode();
ASSERT_THAT(cache->SyncInit(), IsOk());
// Wait for a callback that never comes... about 2 secs :). The message loop
// has to run to allow invocation of the usage timer.
helper.WaitUntilCacheIoFinished(1);
}
TEST_F(DiskCacheBackendTest, TimerNotCreated) {
ASSERT_TRUE(CopyTestCache("wrong_version"));
// Want to use our thread since we call SyncInit ourselves.
std::unique_ptr<disk_cache::BackendImpl> cache(
std::make_unique<disk_cache::BackendImpl>(
cache_path_, nullptr, base::ThreadTaskRunnerHandle::Get(), nullptr));
ASSERT_TRUE(NULL != cache.get());
cache->SetUnitTestMode();
ASSERT_NE(net::OK, cache->SyncInit());
ASSERT_TRUE(NULL == cache->GetTimerForTest());
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, Backend_UsageStats) {
InitCache();
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("key", &entry), IsOk());
entry->Close();
FlushQueueForTest();
disk_cache::StatsItems stats;
cache_->GetStats(&stats);
EXPECT_FALSE(stats.empty());
disk_cache::StatsItems::value_type hits("Create hit", "0x1");
EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
cache_.reset();
// Now open the cache and verify that the stats are still there.
DisableFirstCleanup();
InitCache();
EXPECT_EQ(1, cache_->GetEntryCount());
stats.clear();
cache_->GetStats(&stats);
EXPECT_FALSE(stats.empty());
EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
}
void DiskCacheBackendTest::BackendDoomAll() {
InitCache();
disk_cache::Entry *entry1, *entry2;
ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
entry1->Close();
entry2->Close();
ASSERT_THAT(CreateEntry("third", &entry1), IsOk());
ASSERT_THAT(CreateEntry("fourth", &entry2), IsOk());
ASSERT_EQ(4, cache_->GetEntryCount());
EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
// We should stop posting tasks at some point (if we post any).
base::RunLoop().RunUntilIdle();
disk_cache::Entry *entry3, *entry4;
EXPECT_NE(net::OK, OpenEntry("third", &entry3));
ASSERT_THAT(CreateEntry("third", &entry3), IsOk());
ASSERT_THAT(CreateEntry("fourth", &entry4), IsOk());
EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
entry1->Close();
entry2->Close();
entry3->Doom(); // The entry should be already doomed, but this must work.
entry3->Close();
entry4->Close();
// Now try with all references released.
ASSERT_THAT(CreateEntry("third", &entry1), IsOk());
ASSERT_THAT(CreateEntry("fourth", &entry2), IsOk());
entry1->Close();
entry2->Close();
ASSERT_EQ(2, cache_->GetEntryCount());
EXPECT_THAT(DoomAllEntries(), IsOk());
ASSERT_EQ(0, cache_->GetEntryCount());
EXPECT_THAT(DoomAllEntries(), IsOk());
}
TEST_F(DiskCacheBackendTest, DoomAll) {
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, NewEvictionDoomAll) {
SetNewEviction();
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
SetMemoryOnlyMode();
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, AppCacheOnlyDoomAll) {
SetCacheType(net::APP_CACHE);
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, ShaderCacheOnlyDoomAll) {
SetCacheType(net::SHADER_CACHE);
BackendDoomAll();
}
// If the index size changes when we doom the cache, we should not crash.
void DiskCacheBackendTest::BackendDoomAll2() {
EXPECT_EQ(2, cache_->GetEntryCount());
EXPECT_THAT(DoomAllEntries(), IsOk());
disk_cache::Entry* entry;
ASSERT_THAT(CreateEntry("Something new", &entry), IsOk());
entry->Close();
EXPECT_EQ(1, cache_->GetEntryCount());
}
TEST_F(DiskCacheBackendTest, DoomAll2) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
SetMaxSize(20 * 1024 * 1024);
InitCache();
BackendDoomAll2();
}
TEST_F(DiskCacheBackendTest, NewEvictionDoomAll2) {
ASSERT_TRUE(CopyTestCache("bad_rankings2"));
DisableFirstCleanup();
SetMaxSize(20 * 1024 * 1024);
SetNewEviction();
InitCache();
BackendDoomAll2();
}
// We should be able to create the same entry on multiple simultaneous instances
// of the cache.
TEST_F(DiskCacheTest, MultipleInstances) {
base::ScopedTempDir store1, store2;
ASSERT_TRUE(store1.CreateUniqueTempDir());
ASSERT_TRUE(store2.CreateUniqueTempDir());
net::TestCompletionCallback cb;
const int kNumberOfCaches = 2;
std::unique_ptr<disk_cache::Backend> cache[kNumberOfCaches];
int rv = disk_cache::CreateCacheBackend(
net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, store1.GetPath(), 0, false,
nullptr, &cache[0], cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
rv = disk_cache::CreateCacheBackend(
net::MEDIA_CACHE, net::CACHE_BACKEND_DEFAULT, store2.GetPath(), 0, false,
nullptr, &cache[1], cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
ASSERT_TRUE(cache[0].get() != NULL && cache[1].get() != NULL);
std::string key("the first key");
disk_cache::Entry* entry;
for (int i = 0; i < kNumberOfCaches; i++) {
rv = cache[i]->CreateEntry(key, net::HIGHEST, &entry, cb.callback());
ASSERT_THAT(cb.GetResult(rv), IsOk());
entry->Close();
}
}
// Test the six regions of the curve that determines the max cache size.
TEST_F(DiskCacheTest, AutomaticMaxSize) {
using disk_cache::kDefaultCacheSize;
int64_t large_size = kDefaultCacheSize;
// Region 1: expected = available * 0.8
EXPECT_EQ((kDefaultCacheSize - 1) * 8 / 10,
disk_cache::PreferredCacheSize(large_size - 1));
EXPECT_EQ(kDefaultCacheSize * 8 / 10,
disk_cache::PreferredCacheSize(large_size));
EXPECT_EQ(kDefaultCacheSize - 1,
disk_cache::PreferredCacheSize(large_size * 10 / 8 - 1));
// Region 2: expected = default_size
EXPECT_EQ(kDefaultCacheSize,
disk_cache::PreferredCacheSize(large_size * 10 / 8));
EXPECT_EQ(kDefaultCacheSize,
disk_cache::PreferredCacheSize(large_size * 10 - 1));
// Region 3: expected = available * 0.1
EXPECT_EQ(kDefaultCacheSize, disk_cache::PreferredCacheSize(large_size * 10));
EXPECT_EQ((kDefaultCacheSize * 25 - 1) / 10,
disk_cache::PreferredCacheSize(large_size * 25 - 1));
// Region 4: expected = default_size * 2.5
EXPECT_EQ(kDefaultCacheSize * 25 / 10,
disk_cache::PreferredCacheSize(large_size * 25));
EXPECT_EQ(kDefaultCacheSize * 25 / 10,
disk_cache::PreferredCacheSize(large_size * 100 - 1));
EXPECT_EQ(kDefaultCacheSize * 25 / 10,
disk_cache::PreferredCacheSize(large_size * 100));
EXPECT_EQ(kDefaultCacheSize * 25 / 10,
disk_cache::PreferredCacheSize(large_size * 250 - 1));
// Region 5: expected = available * 0.1
int64_t largest_size = kDefaultCacheSize * 4;
EXPECT_EQ(kDefaultCacheSize * 25 / 10,
disk_cache::PreferredCacheSize(large_size * 250));
EXPECT_EQ(largest_size - 1,
disk_cache::PreferredCacheSize(largest_size * 100 - 1));
// Region 6: expected = largest possible size
EXPECT_EQ(largest_size, disk_cache::PreferredCacheSize(largest_size * 100));
EXPECT_EQ(largest_size, disk_cache::PreferredCacheSize(largest_size * 10000));
}
// Tests that we can "migrate" a running instance from one experiment group to
// another.
TEST_F(DiskCacheBackendTest, Histograms) {
InitCache();
disk_cache::BackendImpl* backend_ = cache_impl_; // Needed be the macro.
for (int i = 1; i < 3; i++) {
CACHE_UMA(HOURS, "FillupTime", i, 28);
}
}
// Make sure that we keep the total memory used by the internal buffers under
// control.
TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
InitCache();
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, true);
for (int i = 0; i < 10; i++) {
SCOPED_TRACE(i);
// Allocate 2MB for this entry.
EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));
EXPECT_EQ(kSize,
WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));
EXPECT_EQ(kSize,
WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));
// Delete one of the buffers and truncate the other.
EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 0, true));
// Delete the second buffer, writing 10 bytes to disk.
entry->Close();
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
}
entry->Close();
EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
}
// This test assumes at least 150MB of system memory.
TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
InitCache();
const int kOneMB = 1024 * 1024;
EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
cache_impl_->BufferDeleted(kOneMB);
EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
// Check the upper limit.
EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
for (int i = 0; i < 30; i++)
cache_impl_->IsAllocAllowed(0, kOneMB); // Ignore the result.
EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
}
// Tests that sharing of external files works and we are able to delete the
// files when we need to.
TEST_F(DiskCacheBackendTest, FileSharing) {
InitCache();
disk_cache::Addr address(0x80000001);
ASSERT_TRUE(cache_impl_->CreateExternalFile(&address));
base::FilePath name = cache_impl_->GetFileName(address);
scoped_refptr<disk_cache::File> file(new disk_cache::File(false));
file->Init(name);
#if defined(OS_WIN)
DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
DWORD access = GENERIC_READ | GENERIC_WRITE;
base::win::ScopedHandle file2(CreateFile(
name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
EXPECT_FALSE(file2.IsValid());
sharing |= FILE_SHARE_DELETE;
file2.Set(CreateFile(name.value().c_str(), access, sharing, NULL,
OPEN_EXISTING, 0, NULL));
EXPECT_TRUE(file2.IsValid());
#endif
EXPECT_TRUE(base::DeleteFile(name, false));
// We should be able to use the file.
const int kSize = 200;
char buffer1[kSize];
char buffer2[kSize];
memset(buffer1, 't', kSize);
memset(buffer2, 0, kSize);
EXPECT_TRUE(file->Write(buffer1, kSize, 0));
EXPECT_TRUE(file->Read(buffer2, kSize, 0));
EXPECT_EQ(0, memcmp(buffer1, buffer2, kSize));
EXPECT_TRUE(disk_cache::DeleteCacheFile(name));
}
TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
InitCache();
disk_cache::Entry* entry;
for (int i = 0; i < 2; ++i) {
std::string key = base::StringPrintf("key%d", i);
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
// Ping the oldest entry.
cache_->OnExternalCacheHit("key0");
TrimForTest(false);
// Make sure the older key remains.
EXPECT_EQ(1, cache_->GetEntryCount());
ASSERT_THAT(OpenEntry("key0", &entry), IsOk());
entry->Close();
}
TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
SetCacheType(net::SHADER_CACHE);
InitCache();
disk_cache::Entry* entry;
for (int i = 0; i < 2; ++i) {
std::string key = base::StringPrintf("key%d", i);
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
entry->Close();
}
// Ping the oldest entry.
cache_->OnExternalCacheHit("key0");
TrimForTest(false);
// Make sure the older key remains.
EXPECT_EQ(1, cache_->GetEntryCount());
ASSERT_THAT(OpenEntry("key0", &entry), IsOk());
entry->Close();
}
TEST_F(DiskCacheBackendTest, SimpleCacheShutdownWithPendingCreate) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendShutdownWithPendingCreate(false);
}
TEST_F(DiskCacheBackendTest, SimpleCacheShutdownWithPendingDoom) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendShutdownWithPendingDoom();
}
TEST_F(DiskCacheBackendTest, SimpleCacheShutdownWithPendingFileIO) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendShutdownWithPendingFileIO(false);
}
TEST_F(DiskCacheBackendTest, SimpleCacheBasics) {
SetSimpleCacheMode();
BackendBasics();
}
TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheBasics) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendBasics();
}
TEST_F(DiskCacheBackendTest, SimpleCacheKeying) {
SetSimpleCacheMode();
BackendKeying();
}
TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheKeying) {
SetSimpleCacheMode();
SetCacheType(net::APP_CACHE);
BackendKeying();
}
TEST_F(DiskCacheBackendTest, SimpleCacheLoad) {
SetMaxSize(0x100000);
SetSimpleCacheMode();
BackendLoad();
}
TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheLoad) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
SetMaxSize(0x100000);
BackendLoad();
}
TEST_F(DiskCacheBackendTest, SimpleDoomRecent) {
SetSimpleCacheMode();
BackendDoomRecent();
}
// crbug.com/330926, crbug.com/370677
TEST_F(DiskCacheBackendTest, DISABLED_SimpleDoomBetween) {
SetSimpleCacheMode();
BackendDoomBetween();
}
TEST_F(DiskCacheBackendTest, SimpleCacheDoomAll) {
SetSimpleCacheMode();
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheOnlyDoomAll) {
SetCacheType(net::APP_CACHE);
SetSimpleCacheMode();
BackendDoomAll();
}
TEST_F(DiskCacheBackendTest, SimpleCacheOpenMissingFile) {
SetSimpleCacheMode();
InitCache();
const char key[] = "the first key";
disk_cache::Entry* entry = NULL;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
ASSERT_TRUE(entry != NULL);
entry->Close();
entry = NULL;
// To make sure the file creation completed we need to call open again so that
// we block until it actually created the files.
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_TRUE(entry != NULL);
entry->Close();
entry = NULL;
// Delete one of the files in the entry.
base::FilePath to_delete_file = cache_path_.AppendASCII(
disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
EXPECT_TRUE(base::PathExists(to_delete_file));
EXPECT_TRUE(disk_cache::DeleteCacheFile(to_delete_file));
// Failing to open the entry should delete the rest of these files.
ASSERT_THAT(OpenEntry(key, &entry), IsError(net::ERR_FAILED));
// Confirm the rest of the files are gone.
for (int i = 1; i < disk_cache::kSimpleEntryNormalFileCount; ++i) {
base::FilePath should_be_gone_file(cache_path_.AppendASCII(
disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i)));
EXPECT_FALSE(base::PathExists(should_be_gone_file));
}
}
TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
SetSimpleCacheMode();
InitCache();
const char key[] = "the first key";
disk_cache::Entry* entry = NULL;
ASSERT_THAT(CreateEntry(key, &entry), IsOk());
disk_cache::Entry* null = NULL;
ASSERT_NE(null, entry);
entry->Close();
entry = NULL;
// To make sure the file creation completed we need to call open again so that
// we block until it actually created the files.
ASSERT_THAT(OpenEntry(key, &entry), IsOk());
ASSERT_NE(null, entry);
entry->Close();
entry = NULL;
// The entry is being closed on the Simple Cache worker pool
disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
base::RunLoop().RunUntilIdle();
// Write an invalid header for stream 0 and stream 1.
base::FilePath entry_file1_path = cache_path_.AppendASCII(
disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
disk_cache::SimpleFileHeader header;
header.initial_magic_number = UINT64_C(0xbadf00d);
EXPECT_EQ(static_cast<int>(sizeof(header)),
base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
sizeof(header)));
ASSERT_THAT(OpenEntry(key, &entry), IsError(net::ERR_FAILED));
}
// Tests that the Simple Cache Backend fails to initialize with non-matching
// file structure on disk.
TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
// Create a cache structure with the |BackendImpl|.
InitCache();
disk_cache::Entry* entry;
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer->data(), kSize, false);
ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
entry->Close();
cache_.reset();
// Check that the |SimpleBackendImpl| does not favor this structure.
disk_cache::SimpleBackendImpl* simple_cache =
new disk_cache::SimpleBackendImpl(cache_path_, nullptr, nullptr, 0,
net::DISK_CACHE, nullptr);
net::TestCompletionCallback cb;
int rv = simple_cache->Init(cb.callback());
EXPECT_NE(net::OK, cb.GetResult(rv));
delete simple_cache;
DisableIntegrityCheck();
}
// Tests that the |BackendImpl| refuses to initialize on top of the files
// generated by the Simple Cache Backend.
TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
// Create a cache structure with the |SimpleBackendImpl|.
SetSimpleCacheMode();
InitCache();
disk_cache::Entry* entry;
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer->data(), kSize, false);
ASSERT_THAT(CreateEntry("key", &entry), IsOk());
ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
entry->Close();
cache_.reset();
// Check that the |BackendImpl| does not favor this structure.
disk_cache::BackendImpl* cache =
new disk_cache::BackendImpl(cache_path_, nullptr, nullptr, nullptr);
cache->SetUnitTestMode();
net::TestCompletionCallback cb;
int rv = cache->Init(cb.callback());
EXPECT_NE(net::OK, cb.GetResult(rv));
delete cache;
DisableIntegrityCheck();
}
TEST_F(DiskCacheBackendTest, SimpleCacheFixEnumerators) {
SetSimpleCacheMode();
BackendFixEnumerators();
}
// Tests basic functionality of the SimpleBackend implementation of the
// enumeration API.
TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationBasics) {
SetSimpleCacheMode();
InitCache();
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
// Check that enumeration returns all entries.
std::set<std::string> keys_to_match(key_pool);
std::unique_ptr<TestIterator> iter = CreateIterator();
size_t count = 0;
ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
iter.reset();
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
// Check that opening entries does not affect enumeration.
keys_to_match = key_pool;
iter = CreateIterator();
count = 0;
disk_cache::Entry* entry_opened_before;
ASSERT_THAT(OpenEntry(*(key_pool.begin()), &entry_opened_before), IsOk());
ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size() / 2, iter.get(),
&keys_to_match, &count));
disk_cache::Entry* entry_opened_middle;
ASSERT_EQ(net::OK, OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
iter.reset();
entry_opened_before->Close();
entry_opened_middle->Close();
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
}
// Tests that the enumerations are not affected by dooming an entry in the
// middle.
TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationWhileDoomed) {
SetSimpleCacheMode();
InitCache();
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
// Check that enumeration returns all entries but the doomed one.
std::set<std::string> keys_to_match(key_pool);
std::unique_ptr<TestIterator> iter = CreateIterator();
size_t count = 0;
ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size() / 2, iter.get(),
&keys_to_match, &count));
std::string key_to_delete = *(keys_to_match.begin());
DoomEntry(key_to_delete);
keys_to_match.erase(key_to_delete);
key_pool.erase(key_to_delete);
ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
iter.reset();
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
}
// Tests that enumerations are not affected by corrupt files.
TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationCorruption) {
SetSimpleCacheMode();
InitCache();
// Create a corrupt entry.
const std::string key = "the key";
disk_cache::Entry* corrupted_entry;
ASSERT_THAT(CreateEntry(key, &corrupted_entry), IsOk());
ASSERT_TRUE(corrupted_entry);
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buffer->data(), kSize, false);
ASSERT_EQ(kSize,
WriteData(corrupted_entry, 0, 0, buffer.get(), kSize, false));
ASSERT_EQ(kSize, ReadData(corrupted_entry, 0, 0, buffer.get(), kSize));
corrupted_entry->Close();
// Let all I/O finish so it doesn't race with corrupting the file below.
RunUntilIdle();
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
EXPECT_TRUE(
disk_cache::simple_util::CreateCorruptFileForTests(key, cache_path_));
EXPECT_EQ(key_pool.size() + 1, static_cast<size_t>(cache_->GetEntryCount()));
// Check that enumeration returns all entries but the corrupt one.
std::set<std::string> keys_to_match(key_pool);
std::unique_ptr<TestIterator> iter = CreateIterator();
size_t count = 0;
ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
iter.reset();
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
}
// Tests that enumerations don't leak memory when the backend is destructed
// mid-enumeration.
TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationDestruction) {
SetSimpleCacheMode();
InitCache();
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
std::unique_ptr<TestIterator> iter = CreateIterator();
disk_cache::Entry* entry = NULL;
ASSERT_THAT(iter->OpenNextEntry(&entry), IsOk());
EXPECT_TRUE(entry);
disk_cache::ScopedEntryPtr entry_closer(entry);
cache_.reset();
// This test passes if we don't leak memory.
}
// Verify that tasks run in priority order when the experiment is enabled.
// Test has races, disabling until fixed: https://crbug.com/853283
TEST_F(DiskCacheBackendTest, DISABLED_SimpleCachePrioritizedEntryOrder) {
base::test::ScopedFeatureList scoped_feature_list;
scoped_feature_list.InitAndEnableFeature(
disk_cache::SimpleBackendImpl::kPrioritizedSimpleCacheTasks);
SetSimpleCacheMode();
InitCache();
// Set the SimpleCache's worker pool to a sequenced type for testing
// priority order.
disk_cache::SimpleBackendImpl* simple_cache =
static_cast<disk_cache::SimpleBackendImpl*>(cache_.get());
auto task_runner = base::CreateSequencedTaskRunnerWithTraits(
{base::TaskPriority::USER_VISIBLE, base::MayBlock()});
simple_cache->SetWorkerPoolForTesting(task_runner);
// Create three entries. Priority order is 3, 1, 2 because 3 has the highest
// request priority and 1 is created before 2.
disk_cache::Entry* entry1 = nullptr;
disk_cache::Entry* entry2 = nullptr;
disk_cache::Entry* entry3 = nullptr;
ASSERT_THAT(CreateEntryWithPriority("first", net::LOWEST, &entry1), IsOk());
ASSERT_THAT(CreateEntryWithPriority("second", net::LOWEST, &entry2), IsOk());
ASSERT_THAT(CreateEntryWithPriority("third", net::HIGHEST, &entry3), IsOk());
// Write some data to the entries.
const int kSize = 10;
scoped_refptr<net::IOBuffer> buf1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> buf3 =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buf1->data(), kSize, false);
CacheTestFillBuffer(buf2->data(), kSize, false);
CacheTestFillBuffer(buf3->data(), kSize, false);
// Write to stream 2 because it's the only stream that can't be read from
// synchronously.
EXPECT_EQ(kSize, WriteData(entry1, 2, 0, buf1.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(entry2, 2, 0, buf1.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(entry3, 2, 0, buf1.get(), kSize, true));
// Wait until the task_runner's queue is empty (WriteData might have
// optimistically returned synchronously but still had some tasks to run in
// the worker pool.
base::RunLoop run_loop;
task_runner->PostTaskAndReply(FROM_HERE, base::DoNothing(),
run_loop.QuitClosure());
run_loop.Run();
std::vector<int> finished_read_order;
auto finished_callback = [](std::vector<int>* finished_read_order,
int entry_number, base::OnceClosure quit_closure,
int rv) {
finished_read_order->push_back(entry_number);
if (quit_closure)
std::move(quit_closure).Run();
};
scoped_refptr<net::IOBuffer> read_buf1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> read_buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> read_buf3 =
base::MakeRefCounted<net::IOBuffer>(kSize);
// Read from the entries in order 2, 3, 1. They should be reprioritized to
// 3, 1, 2.
base::RunLoop read_run_loop;
entry2->ReadData(2, 0, read_buf2.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
2, read_run_loop.QuitClosure()));
entry3->ReadData(2, 0, read_buf3.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
3, base::Passed(base::OnceClosure())));
entry1->ReadData(2, 0, read_buf1.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
1, base::Passed(base::OnceClosure())));
EXPECT_EQ(0u, finished_read_order.size());
read_run_loop.Run();
EXPECT_EQ((std::vector<int>{3, 1, 2}), finished_read_order);
entry1->Close();
entry2->Close();
entry3->Close();
}
// Verify that tasks run in FIFO order when the prioritization experiment is
// disabled.
// TOOD(jkarlin): Delete this test if/when kPrioritizedSimpleCacheTasks is
// enabled by default.
TEST_F(DiskCacheBackendTest, SimpleCacheFIFOEntryOrder) {
base::test::ScopedFeatureList scoped_feature_list;
scoped_feature_list.InitAndDisableFeature(
disk_cache::SimpleBackendImpl::kPrioritizedSimpleCacheTasks);
SetSimpleCacheMode();
InitCache();
// Set the SimpleCache's worker pool to a sequenced type for testing
// priority order.
disk_cache::SimpleBackendImpl* simple_cache =
static_cast<disk_cache::SimpleBackendImpl*>(cache_.get());
auto task_runner = base::CreateSequencedTaskRunnerWithTraits(
{base::TaskPriority::USER_VISIBLE, base::MayBlock()});
simple_cache->SetWorkerPoolForTesting(task_runner);
// Create three entries. If their priority was honored, they'd run in order
// 3, 1, 2.
disk_cache::Entry* entry1 = nullptr;
disk_cache::Entry* entry2 = nullptr;
disk_cache::Entry* entry3 = nullptr;
ASSERT_THAT(CreateEntryWithPriority("first", net::LOWEST, &entry1), IsOk());
ASSERT_THAT(CreateEntryWithPriority("second", net::LOWEST, &entry2), IsOk());
ASSERT_THAT(CreateEntryWithPriority("third", net::HIGHEST, &entry3), IsOk());
// Write some data to the entries.
const int kSize = 10;
scoped_refptr<net::IOBuffer> buf1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> buf3 =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buf1->data(), kSize, false);
CacheTestFillBuffer(buf2->data(), kSize, false);
CacheTestFillBuffer(buf3->data(), kSize, false);
// Write to stream 2 because it's the only stream that can't be read from
// synchronously.
EXPECT_EQ(kSize, WriteData(entry1, 2, 0, buf1.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(entry2, 2, 0, buf1.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(entry3, 2, 0, buf1.get(), kSize, true));
// Wait until the task_runner's queue is empty (WriteData might have
// optimistically returned synchronously but still had some tasks to run in
// the worker pool.
base::RunLoop run_loop;
task_runner->PostTaskAndReply(FROM_HERE, base::DoNothing(),
run_loop.QuitClosure());
run_loop.Run();
std::vector<int> finished_read_order;
auto finished_callback = [](std::vector<int>* finished_read_order,
int entry_number, base::OnceClosure quit_closure,
int rv) {
finished_read_order->push_back(entry_number);
if (quit_closure)
std::move(quit_closure).Run();
};
scoped_refptr<net::IOBuffer> read_buf1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> read_buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
scoped_refptr<net::IOBuffer> read_buf3 =
base::MakeRefCounted<net::IOBuffer>(kSize);
// Read from the entries in order 2, 3, 1. They should complete in that
// order.
base::RunLoop read_run_loop;
entry2->ReadData(2, 0, read_buf2.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
2, base::Passed(base::OnceClosure())));
entry3->ReadData(2, 0, read_buf3.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
3, base::Passed(base::OnceClosure())));
entry1->ReadData(2, 0, read_buf1.get(), kSize,
base::BindRepeating(finished_callback, &finished_read_order,
1, read_run_loop.QuitClosure()));
EXPECT_EQ(0u, finished_read_order.size());
read_run_loop.Run();
EXPECT_EQ((std::vector<int>{2, 3, 1}), finished_read_order);
entry1->Close();
entry2->Close();
entry3->Close();
}
// Tests that enumerations include entries with long keys.
TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationLongKeys) {
SetSimpleCacheMode();
InitCache();
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
const size_t long_key_length =
disk_cache::SimpleSynchronousEntry::kInitialHeaderRead + 10;
std::string long_key(long_key_length, 'X');
key_pool.insert(long_key);
disk_cache::Entry* entry = NULL;
ASSERT_THAT(CreateEntry(long_key.c_str(), &entry), IsOk());
entry->Close();
std::unique_ptr<TestIterator> iter = CreateIterator();
size_t count = 0;
EXPECT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &key_pool, &count));
EXPECT_TRUE(key_pool.empty());
}
// Tests that a SimpleCache doesn't crash when files are deleted very quickly
// after closing.
// NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940
TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) {
SetSimpleCacheMode();
for (int i = 0; i < 100; ++i) {
InitCache();
cache_.reset();
EXPECT_TRUE(CleanupCacheDir());
}
}
TEST_F(DiskCacheBackendTest, SimpleCacheLateDoom) {
SetSimpleCacheMode();
InitCache();
disk_cache::Entry *entry1, *entry2;
ASSERT_THAT(CreateEntry("first", &entry1), IsOk());
ASSERT_THAT(CreateEntry("second", &entry2), IsOk());
entry1->Close();
// Ensure that the directory mtime is flushed to disk before serializing the
// index.
disk_cache::FlushCacheThreadForTesting();
#if defined(OS_POSIX)
base::File cache_dir(cache_path_,
base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_TRUE(cache_dir.Flush());
#endif // defined(OS_POSIX)
cache_.reset();
disk_cache::FlushCacheThreadForTesting();
// The index is now written. Dooming the last entry can't delete a file,
// because that would advance the cache directory mtime and invalidate the
// index.
entry2->Doom();
entry2->Close();
DisableFirstCleanup();
InitCache();
EXPECT_EQ(disk_cache::SimpleIndex::INITIALIZE_METHOD_LOADED,
simple_cache_impl_->index()->init_method());
}
TEST_F(DiskCacheBackendTest, SimpleCacheNegMaxSize) {
SetMaxSize(-1);
SetSimpleCacheMode();
InitCache();
// We don't know what it will pick, but it's limited to what
// disk_cache::PreferredCacheSize would return, scaled by the size experiment,
// which only goes as much as 2x. It definitely should not be MAX_UINT64.
EXPECT_NE(simple_cache_impl_->index()->max_size(),
std::numeric_limits<uint64_t>::max());
int max_default_size =
2 * disk_cache::PreferredCacheSize(std::numeric_limits<int32_t>::max());
ASSERT_GE(max_default_size, 0);
EXPECT_LT(simple_cache_impl_->index()->max_size(),
static_cast<unsigned>(max_default_size));
}
TEST_F(DiskCacheBackendTest, SimpleLastModified) {
// Simple cache used to incorrectly set LastModified on entries based on
// timestamp of the cache directory, and not the entries' file
// (https://crbug.com/714143). So this test arranges for a situation
// where this would occur by doing:
// 1) Write entry 1
// 2) Delay
// 3) Write entry 2. This sets directory time stamp to be different from
// timestamp of entry 1 (due to the delay)
// It then checks whether the entry 1 got the proper timestamp or not.
SetSimpleCacheMode();
InitCache();
std::string key1 = GenerateKey(true);
std::string key2 = GenerateKey(true);
disk_cache::Entry* entry1;
ASSERT_THAT(CreateEntry(key1, &entry1), IsOk());
// Make the Create complete --- SimpleCache can handle it optimistically,
// and if we let it go fully async then trying to flush the Close might just
// flush the Create.
disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
base::RunLoop().RunUntilIdle();
entry1->Close();
// Make the ::Close actually complete, since it is asynchronous.
disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
base::RunLoop().RunUntilIdle();
Time entry1_timestamp = Time::NowFromSystemTime();
// Don't want AddDelay since it sleep 1s(!) for SimpleCache, and we don't
// care about reduced precision in index here.
while (base::Time::NowFromSystemTime() <=
(entry1_timestamp + base::TimeDelta::FromMilliseconds(10))) {
base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
}
disk_cache::Entry* entry2;
ASSERT_THAT(CreateEntry(key2, &entry2), IsOk());
entry2->Close();
disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
base::RunLoop().RunUntilIdle();
disk_cache::Entry* reopen_entry1;
ASSERT_THAT(OpenEntry(key1, &reopen_entry1), IsOk());
// This shouldn't pick up entry2's write time incorrectly.
EXPECT_LE(reopen_entry1->GetLastModified(), entry1_timestamp);
reopen_entry1->Close();
}
TEST_F(DiskCacheBackendTest, SimpleFdLimit) {
base::HistogramTester histogram_tester;
SetSimpleCacheMode();
// Make things blocking so CreateEntry actually waits for file to be
// created.
SetCacheType(net::APP_CACHE);
InitCache();
disk_cache::Entry* entries[kLargeNumEntries];
std::string keys[kLargeNumEntries];
for (int i = 0; i < kLargeNumEntries; ++i) {
keys[i] = GenerateKey(true);
ASSERT_THAT(CreateEntry(keys[i], &entries[i]), IsOk());
}
// Note the fixture sets the file limit to 64.
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_CLOSE_FILE,
kLargeNumEntries - 64);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_REOPEN_FILE, 0);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_FAIL_REOPEN_FILE, 0);
const int kSize = 25000;
scoped_refptr<net::IOBuffer> buf1 =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buf1->data(), kSize, false);
scoped_refptr<net::IOBuffer> buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
CacheTestFillBuffer(buf2->data(), kSize, false);
// Doom an entry and create a new one with same name, to test that both
// re-open properly.
EXPECT_EQ(net::OK, DoomEntry(keys[0]));
disk_cache::Entry* alt_entry;
ASSERT_THAT(CreateEntry(keys[0], &alt_entry), IsOk());
// One more file closure here to accomodate for alt_entry.
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_CLOSE_FILE,
kLargeNumEntries - 64 + 1);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_REOPEN_FILE, 0);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_FAIL_REOPEN_FILE, 0);
// Do some writes in [1...kLargeNumEntries) range, both testing bring those in
// and kicking out [0] and [alt_entry]. These have to be to stream != 0 to
// actually need files.
for (int i = 1; i < kLargeNumEntries; ++i) {
EXPECT_EQ(kSize, WriteData(entries[i], 1, 0, buf1.get(), kSize, true));
scoped_refptr<net::IOBuffer> read_buf =
base::MakeRefCounted<net::IOBuffer>(kSize);
ASSERT_EQ(kSize, ReadData(entries[i], 1, 0, read_buf.get(), kSize));
EXPECT_EQ(0, memcmp(read_buf->data(), buf1->data(), kSize));
}
histogram_tester.ExpectBucketCount(
"SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_CLOSE_FILE,
kLargeNumEntries - 64 + 1 + kLargeNumEntries - 1);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_REOPEN_FILE,
kLargeNumEntries - 1);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_FAIL_REOPEN_FILE, 0);
EXPECT_EQ(kSize, WriteData(entries[0], 1, 0, buf1.get(), kSize, true));
EXPECT_EQ(kSize, WriteData(alt_entry, 1, 0, buf2.get(), kSize, true));
scoped_refptr<net::IOBuffer> read_buf =
base::MakeRefCounted<net::IOBuffer>(kSize);
ASSERT_EQ(kSize, ReadData(entries[0], 1, 0, read_buf.get(), kSize));
EXPECT_EQ(0, memcmp(read_buf->data(), buf1->data(), kSize));
scoped_refptr<net::IOBuffer> read_buf2 =
base::MakeRefCounted<net::IOBuffer>(kSize);
ASSERT_EQ(kSize, ReadData(alt_entry, 1, 0, read_buf2.get(), kSize));
EXPECT_EQ(0, memcmp(read_buf2->data(), buf2->data(), kSize));
// Two more things than last time --- entries[0] and |alt_entry|
histogram_tester.ExpectBucketCount(
"SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_CLOSE_FILE,
kLargeNumEntries - 64 + 1 + kLargeNumEntries - 1 + 2);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_REOPEN_FILE,
kLargeNumEntries + 1);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_FAIL_REOPEN_FILE, 0);
for (int i = 0; i < kLargeNumEntries; ++i) {
entries[i]->Close();
}
alt_entry->Close();
RunUntilIdle();
// Closes have to pull things in to write out the footer, but they also
// free up FDs, so we will only need to kick one more thing out.
histogram_tester.ExpectBucketCount(
"SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_CLOSE_FILE,
kLargeNumEntries - 64 + 1 + kLargeNumEntries - 1 + 2 + 1);
histogram_tester.ExpectBucketCount(
"SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_REOPEN_FILE,
kLargeNumEntries - 64 + 1 + kLargeNumEntries - 1 + 2 + 1);
histogram_tester.ExpectBucketCount("SimpleCache.FileDescriptorLimiterAction",
disk_cache::FD_LIMIT_FAIL_REOPEN_FILE, 0);
}
TEST_F(DiskCacheBackendTest, SparseEvict) {
const int kMaxSize = 512;
SetMaxSize(kMaxSize);
InitCache();
scoped_refptr<net::IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(64);
CacheTestFillBuffer(buffer->data(), 64, false);
disk_cache::Entry* entry0 = nullptr;
ASSERT_THAT(CreateEntry("http://www.0.com/", &entry0), IsOk());
disk_cache::Entry* entry1 = nullptr;
ASSERT_THAT(CreateEntry("http://www.1.com/", &entry1), IsOk());
disk_cache::Entry* entry2 = nullptr;
// This strange looking domain name affects cache trim order
// due to hashing
ASSERT_THAT(CreateEntry("http://www.15360.com/", &entry2), IsOk());
// Write sparse data to put us over the eviction threshold
ASSERT_EQ(64, WriteSparseData(entry0, 0, buffer.get(), 64));
ASSERT_EQ(1, WriteSparseData(entry0, 67108923, buffer.get(), 1));
ASSERT_EQ(1, WriteSparseData(entry1, 53, buffer.get(), 1));
ASSERT_EQ(1, WriteSparseData(entry2, 0, buffer.get(), 1));
// Closing these in a special order should not lead to buggy reentrant
// eviction.
entry1->Close();
entry2->Close();
entry0->Close();
}
TEST_F(DiskCacheBackendTest, InMemorySparseDoom) {
const int kMaxSize = 512;
SetMaxSize(kMaxSize);
SetMemoryOnlyMode();
InitCache();
scoped_refptr<net::IOBuffer> buffer = base::MakeRefCounted<net::IOBuffer>(64);
CacheTestFillBuffer(buffer->data(), 64, false);
disk_cache::Entry* entry = nullptr;
ASSERT_THAT(CreateEntry("http://www.0.com/", &entry), IsOk());
ASSERT_EQ(net::ERR_FAILED, WriteSparseData(entry, 4337, buffer.get(), 64));
entry->Close();
// Dooming all entries at this point should properly iterate over
// the parent and its children
DoomAllEntries();
}
TEST_F(DiskCacheBackendTest, BlockFileMaxSizeLimit) {
InitCache();
int64_t size = std::numeric_limits<int32_t>::max();
SetMaxSize(size, true /* should_succeed */);
size += 1;
SetMaxSize(size, false /* should_succeed */);
}
TEST_F(DiskCacheBackendTest, InMemoryMaxSizeLimit) {
SetMemoryOnlyMode();
InitCache();
int64_t size = std::numeric_limits<int32_t>::max();
SetMaxSize(size, true /* should_succeed */);
size += 1;
SetMaxSize(size, false /* should_succeed */);
}
TEST_F(DiskCacheBackendTest, SimpleMaxSizeLimit) {
SetSimpleCacheMode();
InitCache();
int64_t size = std::numeric_limits<int32_t>::max();
SetMaxSize(size, true /* should_succeed */);
size += 1;
SetMaxSize(size, true /* should_succeed */);
}