entry_unittest.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include <utility>

#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/field_trial_param_associator.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/threading/platform_thread.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "net/base/completion_once_callback.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/base/request_priority.h"
#include "net/base/test_completion_callback.h"
#include "net/disk_cache/blockfile/backend_impl.h"
#include "net/disk_cache/blockfile/entry_impl.h"
#include "net/disk_cache/cache_util.h"
#include "net/disk_cache/disk_cache_test_base.h"
#include "net/disk_cache/disk_cache_test_util.h"
#include "net/disk_cache/memory/mem_entry_impl.h"
#include "net/disk_cache/simple/simple_backend_impl.h"
#include "net/disk_cache/simple/simple_entry_format.h"
#include "net/disk_cache/simple/simple_entry_impl.h"
#include "net/disk_cache/simple/simple_histogram_enums.h"
#include "net/disk_cache/simple/simple_synchronous_entry.h"
#include "net/disk_cache/simple/simple_test_util.h"
#include "net/disk_cache/simple/simple_util.h"
#include "net/test/gtest_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

IsError;
IsOk;

Time;
EntryResult;
EntryResultCallback;
RangeResult;
ScopedEntryPtr;

// Tests that can run with different types of caches.
class DiskCacheEntryTest : public DiskCacheTestWithCache { … };

// This part of the test runs on the background thread.
void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) { … }

// We need to support synchronous IO even though it is not a supported operation
// from the point of view of the disk cache's public interface, because we use
// it internally, not just by a few tests, but as part of the implementation
// (see sparse_control.cc, for example).
void DiskCacheEntryTest::InternalSyncIO() { … }

TEST_F(DiskCacheEntryTest, InternalSyncIO) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) { … }

void DiskCacheEntryTest::InternalAsyncIO() { … }

TEST_F(DiskCacheEntryTest, InternalAsyncIO) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) { … }

// This part of the test runs on the background thread.
void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) { … }

void DiskCacheEntryTest::ExternalSyncIO() { … }

TEST_F(DiskCacheEntryTest, ExternalSyncIO) { … }

TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) { … }

void DiskCacheEntryTest::ExternalAsyncIO() { … }

TEST_F(DiskCacheEntryTest, ExternalAsyncIO) { … }

// TODO(http://crbug.com/497101): This test is flaky.
#if BUILDFLAG(IS_IOS)
#define MAYBE_ExternalAsyncIONoBuffer …
#else
#define MAYBE_ExternalAsyncIONoBuffer …
#endif
TEST_F(DiskCacheEntryTest, MAYBE_ExternalAsyncIONoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) { … }

// Tests that IOBuffers are not referenced after IO completes.
void DiskCacheEntryTest::ReleaseBuffer(int stream_index) { … }

TEST_F(DiskCacheEntryTest, ReleaseBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) { … }

void DiskCacheEntryTest::StreamAccess() { … }

TEST_F(DiskCacheEntryTest, StreamAccess) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) { … }

void DiskCacheEntryTest::GetKey() { … }

TEST_F(DiskCacheEntryTest, GetKey) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) { … }

void DiskCacheEntryTest::GetTimes(int stream_index) { … }

TEST_F(DiskCacheEntryTest, GetTimes) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) { … }

TEST_F(DiskCacheEntryTest, AppCacheGetTimes) { … }

TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes) { … }

void DiskCacheEntryTest::GrowData(int stream_index) { … }

TEST_F(DiskCacheEntryTest, GrowData) { … }

TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) { … }

void DiskCacheEntryTest::TruncateData(int stream_index) { … }

TEST_F(DiskCacheEntryTest, TruncateData) { … }

TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) { … }

void DiskCacheEntryTest::ZeroLengthIO(int stream_index) { … }

TEST_F(DiskCacheEntryTest, ZeroLengthIO) { … }

TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) { … }

// Tests that we handle the content correctly when buffering, a feature of the
// standard cache that permits fast responses to certain reads.
void DiskCacheEntryTest::Buffering() { … }

TEST_F(DiskCacheEntryTest, Buffering) { … }

TEST_F(DiskCacheEntryTest, BufferingNoBuffer) { … }

// Checks that entries are zero length when created.
void DiskCacheEntryTest::SizeAtCreate() { … }

TEST_F(DiskCacheEntryTest, SizeAtCreate) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) { … }

// Some extra tests to make sure that buffering works properly when changing
// the entry size.
void DiskCacheEntryTest::SizeChanges(int stream_index) { … }

TEST_F(DiskCacheEntryTest, SizeChanges) { … }

TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) { … }

// Write more than the total cache capacity but to a single entry. |size| is the
// amount of bytes to write each time.
void DiskCacheEntryTest::ReuseEntry(int size, int stream_index) { … }

TEST_F(DiskCacheEntryTest, ReuseExternalEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) { … }

TEST_F(DiskCacheEntryTest, ReuseInternalEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) { … }

// Reading somewhere that was not written should return zeros.
void DiskCacheEntryTest::InvalidData(int stream_index) { … }

TEST_F(DiskCacheEntryTest, InvalidData) { … }

TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) { … }

// Tests that the cache preserves the buffer of an IO operation.
void DiskCacheEntryTest::ReadWriteDestroyBuffer(int stream_index) { … }

TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) { … }

void DiskCacheEntryTest::DoomNormalEntry() { … }

TEST_F(DiskCacheEntryTest, DoomEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) { … }

// Tests dooming an entry that's linked to an open entry.
void DiskCacheEntryTest::DoomEntryNextToOpenEntry() { … }

TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) { … }

TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) { … }

TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) { … }

// Verify that basic operations work as expected with doomed entries.
void DiskCacheEntryTest::DoomedEntry(int stream_index) { … }

TEST_F(DiskCacheEntryTest, DoomedEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { … }

// Tests that we discard entries if the data is missing.
TEST_F(DiskCacheEntryTest, MissingData) { … }

// Test that child entries in a memory cache backend are not visible from
// enumerations.
TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) { … }

// Writes |buf_1| to offset and reads it back as |buf_2|.
void VerifySparseIO(disk_cache::Entry* entry,
                    int64_t offset,
                    net::IOBuffer* buf_1,
                    int size,
                    net::IOBuffer* buf_2) { … }

// Reads |size| bytes from |entry| at |offset| and verifies that they are the
// same as the content of the provided |buffer|.
void VerifyContentSparseIO(disk_cache::Entry* entry,
                           int64_t offset,
                           char* buffer,
                           int size) { … }

void DiskCacheEntryTest::BasicSparseIO() { … }

TEST_F(DiskCacheEntryTest, BasicSparseIO) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) { … }

void DiskCacheEntryTest::HugeSparseIO() { … }

TEST_F(DiskCacheEntryTest, HugeSparseIO) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) { … }

void DiskCacheEntryTest::GetAvailableRangeTest() { … }

TEST_F(DiskCacheEntryTest, GetAvailableRange) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) { … }

TEST_F(DiskCacheEntryTest, GetAvailableRangeBlockFileDiscontinuous) { … }

// Tests that non-sequential writes that are not aligned with the minimum sparse
// data granularity (1024 bytes) do in fact result in dropped data.
TEST_F(DiskCacheEntryTest, SparseWriteDropped) { … }

// Tests that small sequential writes are not dropped.
TEST_F(DiskCacheEntryTest, SparseSquentialWriteNotDropped) { … }

void DiskCacheEntryTest::CouldBeSparse() { … }

TEST_F(DiskCacheEntryTest, CouldBeSparse) { … }

TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { … }

void DiskCacheEntryTest::UpdateSparseEntry() { … }

TEST_F(DiskCacheEntryTest, UpdateSparseEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) { … }

void DiskCacheEntryTest::DoomSparseEntry() { … }

TEST_F(DiskCacheEntryTest, DoomSparseEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) { … }

// A TestCompletionCallback wrapper that deletes the cache from within the
// callback.  The way TestCompletionCallback works means that all tasks (even
// new ones) are executed by the message loop before returning to the caller so
// the only way to simulate a race is to execute what we want on the callback.
class SparseTestCompletionCallback: public net::TestCompletionCallback { … };

// Tests that we don't crash when the backend is deleted while we are working
// deleting the sub-entries of a sparse entry.
TEST_F(DiskCacheEntryTest, DoomSparseEntry2) { … }

void DiskCacheEntryTest::PartialSparseEntry() { … }

TEST_F(DiskCacheEntryTest, PartialSparseEntry) { … }

TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) { … }

void DiskCacheEntryTest::SparseInvalidArg() { … }

TEST_F(DiskCacheEntryTest, SparseInvalidArg) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlySparseInvalidArg) { … }

TEST_F(DiskCacheEntryTest, SimpleSparseInvalidArg) { … }

void DiskCacheEntryTest::SparseClipEnd(int64_t max_index,
                                       bool expect_unsupported) { … }

TEST_F(DiskCacheEntryTest, SparseClipEnd) { … }

TEST_F(DiskCacheEntryTest, SparseClipEnd2) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlySparseClipEnd) { … }

TEST_F(DiskCacheEntryTest, SimpleSparseClipEnd) { … }

// Tests that corrupt sparse children are removed automatically.
TEST_F(DiskCacheEntryTest, CleanupSparseEntry) { … }

TEST_F(DiskCacheEntryTest, CancelSparseIO) { … }

// Tests that we perform sanity checks on an entry's key. Note that there are
// other tests that exercise sanity checks by using saved corrupt files.
TEST_F(DiskCacheEntryTest, KeySanityCheck) { … }

TEST_F(DiskCacheEntryTest, KeySanityCheck2) { … }

TEST_F(DiskCacheEntryTest, KeySanityCheck3) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheGetKey) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheGrowData) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheTruncateData) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheZeroLengthIO) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheSizeAtCreate) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReuseExternalEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReuseInternalEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheGiantEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheSizeChanges) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheInvalidData) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReadWriteDestroyBuffer) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntryNextToOpenEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry) { … }

// Creates an entry with corrupted last byte in stream 0.
// Requires SimpleCacheMode.
bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
                                                         int data_size) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) { … }

// Tests that an entry that has had an IO error occur can still be Doomed().
TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheCreateAfterDiskLayerDoom) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheQueuedOpenOnDoomedEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomErrorRace) { … }

bool TruncatePath(const base::FilePath& file_path, int64_t length) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsDontBlock) { … }

TEST_F(DiskCacheEntryTest,
       SimpleCacheNonOptimisticOperationsBasicsWithoutWaiting) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) { … }

// Confirm that IO buffers are not referenced by the Simple Cache after a write
// completes.
TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticWriteReleases) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheCreateDoomRace) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateRace) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateOptimistic) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateOptimisticMassDoom) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomOpenOptimistic) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomDoom) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateDoom) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomCloseCreateCloseOpen) { … }

// Checks that an optimistic Create would fail later on a racing Open.
TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen) { … }

// Tests that old entries are evicted while new entries remain in the index.
// This test relies on non-mandatory properties of the simple Cache Backend:
// LRU eviction, specific values of high-watermark and low-watermark etc.
// When changing the eviction algorithm, the test will have to be re-engineered.
TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) { … }

// Tests that if a read and a following in-flight truncate are both in progress
// simultaniously that they both can occur successfully. See
// http://crbug.com/239223
TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate)  { … }

// Tests that if a write and a read dependant on it are both in flight
// simultaneiously that they both can complete successfully without erroneous
// early returns. See http://crbug.com/239223
TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheOpenCreateRaceWithNoIndex) { … }

// Checking one more scenario of overlapped reading of a bad entry.
// Differs from the |SimpleCacheMultipleReadersCheckCRC| only by the order of
// last two reads.
TEST_F(DiskCacheEntryTest, SimpleCacheMultipleReadersCheckCRC2) { … }

// Test if we can sequentially read each subset of the data until all the data
// is read, then the CRC is calculated correctly and the reads are successful.
TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) { … }

// Test if we can write the data not in sequence and read correctly. In
// this case the CRC will not be present.
TEST_F(DiskCacheEntryTest, SimpleCacheNonSequentialWrite) { … }

// Test that changing stream1 size does not affect stream0 (stream0 and stream1
// are stored in the same file in Simple Cache).
TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges) { … }

// Test that writing within the range for which the crc has already been
// computed will properly invalidate the computed crc.
TEST_F(DiskCacheEntryTest, SimpleCacheCRCRewrite) { … }

bool DiskCacheEntryTest::SimpleCacheThirdStreamFileExists(const char* key) { … }

void DiskCacheEntryTest::SyncDoomEntry(const char* key) { … }

void DiskCacheEntryTest::CreateEntryWithHeaderBodyAndSideData(
    const std::string& key,
    int data_size) { … }

void DiskCacheEntryTest::TruncateFileFromEnd(int file_index,
                                             const std::string& key,
                                             int data_size,
                                             int truncate_size) { … }

void DiskCacheEntryTest::UseAfterBackendDestruction() { … }

void DiskCacheEntryTest::CloseSparseAfterBackendDestruction() { … }

// Check that a newly-created entry with no third-stream writes omits the
// third stream file.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream1) { … }

// Check that a newly-created entry with only a single zero-offset, zero-length
// write omits the third stream file.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream2) { … }

// Check that we can read back data written to the third stream.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3) { … }

// Check that we remove the third stream file upon opening an entry and finding
// the third stream empty.  (This is the upgrade path for entries written
// before the third stream was optional.)
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream4) { … }

// Check that we don't accidentally create the third stream file once the entry
// has been doomed.
TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5) { … }

// There could be a race between Doom and an optimistic write.
TEST_F(DiskCacheEntryTest, SimpleCacheDoomOptimisticWritesRace) { … }

// Tests for a regression in crbug.com/317138 , in which deleting an already
// doomed entry was removing the active entry from the index.
TEST_F(DiskCacheEntryTest, SimpleCachePreserveActiveEntries) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheBasicSparseIO) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheHugeSparseIO) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheGetAvailableRange) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheUpdateSparseEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoomSparseEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCachePartialSparseEntry) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheTruncateLargeSparseFile) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheNoBodyEOF) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheNoSideDataEOF) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReadWithoutKeySHA256) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheDoubleOpenWithoutKeySHA256) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReadCorruptKeySHA256) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheReadCorruptLength) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheCreateRecoverFromRmdir) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheSparseErrorHandling) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheCreateCollision) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheConvertToSparseStream2LeftOver) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheLazyStream2CreateFailure) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheChecksumpScrewUp) { … }

TEST_F(DiskCacheEntryTest, SimpleUseAfterBackendDestruction) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyUseAfterBackendDestruction) { … }

TEST_F(DiskCacheEntryTest, SimpleCloseSparseAfterBackendDestruction) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyCloseSparseAfterBackendDestruction) { … }

void DiskCacheEntryTest::LastUsedTimePersists() { … }

TEST_F(DiskCacheEntryTest, LastUsedTimePersists) { … }

TEST_F(DiskCacheEntryTest, SimpleLastUsedTimePersists) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyLastUsedTimePersists) { … }

void DiskCacheEntryTest::TruncateBackwards() { … }

TEST_F(DiskCacheEntryTest, TruncateBackwards) { … }

TEST_F(DiskCacheEntryTest, SimpleTruncateBackwards) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateBackwards) { … }

void DiskCacheEntryTest::ZeroWriteBackwards() { … }

TEST_F(DiskCacheEntryTest, ZeroWriteBackwards) { … }

TEST_F(DiskCacheEntryTest, SimpleZeroWriteBackwards) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlyZeroWriteBackwards) { … }

void DiskCacheEntryTest::SparseOffset64Bit() { … }

TEST_F(DiskCacheEntryTest, SparseOffset64Bit) { … }

TEST_F(DiskCacheEntryTest, SimpleSparseOffset64Bit) { … }

TEST_F(DiskCacheEntryTest, MemoryOnlySparseOffset64Bit) { … }

TEST_F(DiskCacheEntryTest, SimpleCacheCloseResurrection) { … }

TEST_F(DiskCacheEntryTest, BlockFileSparsePendingAfterDtor) { … }

class DiskCacheSimplePrefetchTest : public DiskCacheEntryTest { … };

TEST_F(DiskCacheSimplePrefetchTest, NoPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, YesPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, YesPrefetchNoRead) { … }

// This makes sure we detect checksum error on entry that's small enough to be
// prefetched. This is like DiskCacheEntryTest.BadChecksum, but we make sure
// to configure prefetch explicitly.
TEST_F(DiskCacheSimplePrefetchTest, BadChecksumSmall) { … }

TEST_F(DiskCacheSimplePrefetchTest, ChecksumNoPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, NoChecksumNoPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, ChecksumPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, NoChecksumPrefetch) { … }

TEST_F(DiskCacheSimplePrefetchTest, PrefetchReadsSync) { … }

TEST_F(DiskCacheSimplePrefetchTest, NoFullNoSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, NoFullSmallSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, NoFullLargeSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, SmallFullNoSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, LargeFullNoSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, SmallFullSmallSpeculative) { … }

TEST_F(DiskCacheSimplePrefetchTest, LargeFullSmallSpeculative) { … }

class DiskCacheSimpleAppCachePrefetchTest : public DiskCacheSimplePrefetchTest { … };

TEST_F(DiskCacheSimpleAppCachePrefetchTest, NoFullNoSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, NoFullSmallSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, NoFullLargeSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, SmallFullNoSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, LargeFullNoSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, SmallFullSmallSpeculative) { … }

TEST_F(DiskCacheSimpleAppCachePrefetchTest, LargeFullSmallSpeculative) { … }
chromium/net/disk_cache/entry_unittest.cc
