Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(201)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/disk_cache/entry_unittest.cc

Issue 15203004: Disk cache: Reference CL for the implementation of file format version 3. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: IndexTable review Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/disk_cache/entry_impl.cc ('k') | net/disk_cache/errors.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/disk_cache/entry_unittest.cc
===================================================================
--- net/disk_cache/entry_unittest.cc (revision 199883)
+++ net/disk_cache/entry_unittest.cc (working copy)
@@ -35,6 +35,7 @@
protected:
void InternalSyncIO();
void InternalAsyncIO();
+ void InternalConcurrentIO();
void ExternalSyncIO();
void ExternalAsyncIO();
void ReleaseBuffer();
@@ -53,14 +54,19 @@
void DoomNormalEntry();
void DoomEntryNextToOpenEntry();
void DoomedEntry();
+ void MissingData();
void BasicSparseIO();
void HugeSparseIO();
- void GetAvailableRange();
+ void SparseGetAvailableRange();
void CouldBeSparse();
void UpdateSparseEntry();
void DoomSparseEntry();
+ void DoomSparseEntry2();
void PartialSparseEntry();
void SimpleCacheMakeBadChecksumEntry(const char* key);
+ void CleanupSparseEntry();
+ void CancelSparseIO();
+ void ReadyForSparseIONoCancel();
};
// This part of the test runs on the background thread.
@@ -68,14 +74,14 @@
const int kSize1 = 10;
scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
CacheTestFillBuffer(buffer1->data(), kSize1, false);
- EXPECT_EQ(0, entry->ReadData(
- 0, 0, buffer1, kSize1, net::CompletionCallback()));
+ EXPECT_EQ(0, entry->ReadData(0, 0, buffer1.get(), kSize1,
+ net::CompletionCallback()));
base::strlcpy(buffer1->data(), "the data", kSize1);
- EXPECT_EQ(10, entry->WriteData(
- 0, 0, buffer1, kSize1, net::CompletionCallback(), false));
+ EXPECT_EQ(10, entry->WriteData(0, 0, buffer1.get(), kSize1,
+ net::CompletionCallback(), false));
memset(buffer1->data(), 0, kSize1);
- EXPECT_EQ(10, entry->ReadData(
- 0, 0, buffer1, kSize1, net::CompletionCallback()));
+ EXPECT_EQ(10, entry->ReadData(0, 0, buffer1.get(), kSize1,
+ net::CompletionCallback()));
EXPECT_STREQ("the data", buffer1->data());
const int kSize2 = 5000;
@@ -85,33 +91,33 @@
memset(buffer3->data(), 0, kSize3);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
- EXPECT_EQ(5000, entry->WriteData(
- 1, 1500, buffer2, kSize2, net::CompletionCallback(), false));
+ EXPECT_EQ(5000, entry->WriteData(1, 1500, buffer2.get(), kSize2,
+ net::CompletionCallback(), false));
memset(buffer2->data(), 0, kSize2);
- EXPECT_EQ(4989, entry->ReadData(
- 1, 1511, buffer2, kSize2, net::CompletionCallback()));
+ EXPECT_EQ(4989, entry->ReadData(1, 1511, buffer2.get(), kSize2,
+ net::CompletionCallback()));
EXPECT_STREQ("big data goes here", buffer2->data());
- EXPECT_EQ(5000, entry->ReadData(
- 1, 0, buffer2, kSize2, net::CompletionCallback()));
+ EXPECT_EQ(5000, entry->ReadData(1, 0, buffer2.get(), kSize2,
+ net::CompletionCallback()));
EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
- EXPECT_EQ(1500, entry->ReadData(
- 1, 5000, buffer2, kSize2, net::CompletionCallback()));
+ EXPECT_EQ(1500, entry->ReadData(1, 5000, buffer2.get(), kSize2,
+ net::CompletionCallback()));
- EXPECT_EQ(0, entry->ReadData(
- 1, 6500, buffer2, kSize2, net::CompletionCallback()));
- EXPECT_EQ(6500, entry->ReadData(
- 1, 0, buffer3, kSize3, net::CompletionCallback()));
- EXPECT_EQ(8192, entry->WriteData(
- 1, 0, buffer3, 8192, net::CompletionCallback(), false));
- EXPECT_EQ(8192, entry->ReadData(
- 1, 0, buffer3, kSize3, net::CompletionCallback()));
+ EXPECT_EQ(0, entry->ReadData(1, 6500, buffer2.get(), kSize2,
+ net::CompletionCallback()));
+ EXPECT_EQ(6500, entry->ReadData(1, 0, buffer3.get(), kSize3,
+ net::CompletionCallback()));
+ EXPECT_EQ(8192, entry->WriteData(1, 0, buffer3.get(), 8192,
+ net::CompletionCallback(), false));
+ EXPECT_EQ(8192, entry->ReadData(1, 0, buffer3.get(), kSize3,
+ net::CompletionCallback()));
EXPECT_EQ(8192, entry->GetDataSize(1));
// We need to delete the memory buffer on this thread.
- EXPECT_EQ(0, entry->WriteData(
- 0, 0, NULL, 0, net::CompletionCallback(), true));
- EXPECT_EQ(0, entry->WriteData(
- 1, 0, NULL, 0, net::CompletionCallback(), true));
+ EXPECT_EQ(0,
+ entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+ EXPECT_EQ(0,
+ entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
}
// We need to support synchronous IO even though it is not a supported operation
@@ -163,19 +169,14 @@
MessageLoopHelper helper;
// Let's verify that each IO goes to the right callback object.
- CallbackTest callback1(&helper, false);
- CallbackTest callback2(&helper, false);
- CallbackTest callback3(&helper, false);
- CallbackTest callback4(&helper, false);
- CallbackTest callback5(&helper, false);
- CallbackTest callback6(&helper, false);
- CallbackTest callback7(&helper, false);
- CallbackTest callback8(&helper, false);
- CallbackTest callback9(&helper, false);
- CallbackTest callback10(&helper, false);
- CallbackTest callback11(&helper, false);
- CallbackTest callback12(&helper, false);
- CallbackTest callback13(&helper, false);
+ CallbackTest cb1(&helper, false);
+ CallbackTest cb2(&helper, false);
+ CallbackTest cb3(&helper, false);
+ CallbackTest cb4(&helper, false);
+ CallbackTest cb5(&helper, false);
+ CallbackTest cb6(&helper, false);
+ CallbackTest cb7(&helper, false);
+ CallbackTest cb8(&helper, false);
const int kSize1 = 10;
const int kSize2 = 5000;
@@ -187,101 +188,66 @@
CacheTestFillBuffer(buffer2->data(), kSize2, false);
CacheTestFillBuffer(buffer3->data(), kSize3, false);
- EXPECT_EQ(0, entry->ReadData(
- 0, 15 * 1024, buffer1, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
- base::strlcpy(buffer1->data(), "the data", kSize1);
+ int ret = entry->ReadData(0, 15 * 1024, buffer1.get(), kSize1,
+ cb1.callback());
int expected = 0;
- int ret = entry->WriteData(
- 0, 0, buffer1, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), false);
- EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
+ EXPECT_TRUE(0 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
- memset(buffer2->data(), 0, kSize2);
- ret = entry->ReadData(
- 0, 0, buffer2, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback3)));
+ base::strlcpy(buffer1->data(), "the data", kSize1);
+ ret = entry->WriteData(0, 0, buffer1.get(), kSize1, cb2.callback(), false);
EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+
+ memset(buffer2->data(), 0, kSize2);
+ EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2.get(), kSize1));
EXPECT_STREQ("the data", buffer2->data());
base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
- ret = entry->WriteData(
- 1, 1500, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback4)), true);
- EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
+ EXPECT_EQ(5000, WriteData(entry, 1, 1500, buffer2.get(), kSize2, true));
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
memset(buffer3->data(), 0, kSize3);
- ret = entry->ReadData(
- 1, 1511, buffer3, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
- EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
-
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+ EXPECT_EQ(4989, ReadData(entry, 1, 1511, buffer3.get(), kSize2));
EXPECT_STREQ("big data goes here", buffer3->data());
- ret = entry->ReadData(
- 1, 0, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
- EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
+ ret = ReadData(entry, 1, 0, buffer2.get(), kSize2);
+ EXPECT_TRUE(ret == 1500 || ret == 5000);
memset(buffer3->data(), 0, kSize3);
+ EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
- EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500));
- ret = entry->ReadData(
- 1, 5000, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback7)));
+ ret = entry->ReadData(1, 5000, buffer2.get(), kSize2, cb3.callback());
EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- ret = entry->ReadData(
- 1, 0, buffer3, kSize3,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback9)));
+ ret = entry->ReadData(1, 0, buffer3.get(), kSize3, cb4.callback());
EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- ret = entry->WriteData(
- 1, 0, buffer3, 8192,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback10)), true);
+ ret = entry->WriteData(1, 0, buffer3.get(), 8192, cb5.callback(), true);
EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
- ret = entry->ReadData(
- 1, 0, buffer3, kSize3,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback11)));
+ ret = entry->ReadData(1, 0, buffer3.get(), kSize3, cb6.callback());
EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
EXPECT_EQ(8192, entry->GetDataSize(1));
- ret = entry->ReadData(
- 0, 0, buffer1, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback12)));
+ ret = entry->ReadData(0, 0, buffer1.get(), kSize1, cb7.callback());
EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- ret = entry->ReadData(
- 1, 0, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback13)));
+ ret = entry->ReadData(1, 0, buffer2.get(), kSize2, cb8.callback());
EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
@@ -301,6 +267,12 @@
InternalAsyncIO();
}
+TEST_F(DiskCacheEntryTest, V3InternalAsyncIO) {
+ UseVersion3();
+ InitCache();
+ InternalAsyncIO();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) {
SetMemoryOnlyMode();
InitCache();
@@ -316,39 +288,38 @@
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
base::strlcpy(buffer1->data(), "the data", kSize1);
- EXPECT_EQ(17000, entry->WriteData(
- 0, 0, buffer1, kSize1, net::CompletionCallback(), false));
+ EXPECT_EQ(17000, entry->WriteData(0, 0, buffer1.get(), kSize1,
+ net::CompletionCallback(), false));
memset(buffer1->data(), 0, kSize1);
- EXPECT_EQ(17000, entry->ReadData(
- 0, 0, buffer1, kSize1, net::CompletionCallback()));
+ EXPECT_EQ(17000, entry->ReadData(0, 0, buffer1.get(), kSize1,
+ net::CompletionCallback()));
EXPECT_STREQ("the data", buffer1->data());
base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
- EXPECT_EQ(25000, entry->WriteData(
- 1, 10000, buffer2, kSize2, net::CompletionCallback(), false));
+ EXPECT_EQ(25000, entry->WriteData(1, 10000, buffer2.get(), kSize2,
+ net::CompletionCallback(), false));
memset(buffer2->data(), 0, kSize2);
- EXPECT_EQ(24989, entry->ReadData(
- 1, 10011, buffer2, kSize2, net::CompletionCallback()));
+ EXPECT_EQ(24989, entry->ReadData(1, 10011, buffer2.get(), kSize2,
+ net::CompletionCallback()));
EXPECT_STREQ("big data goes here", buffer2->data());
- EXPECT_EQ(25000, entry->ReadData(
- 1, 0, buffer2, kSize2, net::CompletionCallback()));
- EXPECT_EQ(0, memcmp(buffer2->data(), buffer2->data(), 10000));
- EXPECT_EQ(5000, entry->ReadData(
- 1, 30000, buffer2, kSize2, net::CompletionCallback()));
+ EXPECT_EQ(25000, entry->ReadData(1, 0, buffer2.get(), kSize2,
+ net::CompletionCallback()));
+ EXPECT_EQ(5000, entry->ReadData(1, 30000, buffer2.get(), kSize2,
+ net::CompletionCallback()));
- EXPECT_EQ(0, entry->ReadData(
- 1, 35000, buffer2, kSize2, net::CompletionCallback()));
- EXPECT_EQ(17000, entry->ReadData(
- 1, 0, buffer1, kSize1, net::CompletionCallback()));
- EXPECT_EQ(17000, entry->WriteData(
- 1, 20000, buffer1, kSize1, net::CompletionCallback(), false));
+ EXPECT_EQ(0, entry->ReadData(1, 35000, buffer2.get(), kSize2,
+ net::CompletionCallback()));
+ EXPECT_EQ(17000, entry->ReadData(1, 0, buffer1.get(), kSize1,
+ net::CompletionCallback()));
+ EXPECT_EQ(17000, entry->WriteData(1, 20000, buffer1.get(), kSize1,
+ net::CompletionCallback(), false));
EXPECT_EQ(37000, entry->GetDataSize(1));
// We need to delete the memory buffer on this thread.
- EXPECT_EQ(0, entry->WriteData(
- 0, 0, NULL, 0, net::CompletionCallback(), true));
- EXPECT_EQ(0, entry->WriteData(
- 1, 0, NULL, 0, net::CompletionCallback(), true));
+ EXPECT_EQ(0,
+ entry->WriteData(0, 0, NULL, 0, net::CompletionCallback(), true));
+ EXPECT_EQ(0,
+ entry->WriteData(1, 0, NULL, 0, net::CompletionCallback(), true));
}
void DiskCacheEntryTest::ExternalSyncIO() {
@@ -371,9 +342,15 @@
ExternalSyncIO();
}
+TEST_F(DiskCacheEntryTest, V3ExternalSyncIO) {
+ UseVersion3();
+ InitCache();
+ ExternalSyncIO();
+}
+
TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
ExternalSyncIO();
}
@@ -391,15 +368,10 @@
MessageLoopHelper helper;
// Let's verify that each IO goes to the right callback object.
- CallbackTest callback1(&helper, false);
- CallbackTest callback2(&helper, false);
- CallbackTest callback3(&helper, false);
- CallbackTest callback4(&helper, false);
- CallbackTest callback5(&helper, false);
- CallbackTest callback6(&helper, false);
- CallbackTest callback7(&helper, false);
- CallbackTest callback8(&helper, false);
- CallbackTest callback9(&helper, false);
+ CallbackTest cb1(&helper, false);
+ CallbackTest cb2(&helper, false);
+ CallbackTest cb3(&helper, false);
+ CallbackTest cb4(&helper, false);
const int kSize1 = 17000;
const int kSize2 = 25000;
@@ -410,76 +382,39 @@
CacheTestFillBuffer(buffer1->data(), kSize1, false);
CacheTestFillBuffer(buffer2->data(), kSize2, false);
CacheTestFillBuffer(buffer3->data(), kSize3, false);
+
base::strlcpy(buffer1->data(), "the data", kSize1);
- int ret = entry->WriteData(
- 0, 0, buffer1, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback1)), false);
- EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
+ EXPECT_EQ(17000, WriteData(entry, 0, 0, buffer1.get(), kSize1, false));
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-
memset(buffer2->data(), 0, kSize1);
- ret = entry->ReadData(
- 0, 0, buffer2, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback2)));
- EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
-
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+ EXPECT_EQ(17000, ReadData(entry, 0, 0, buffer2.get(), kSize1));
EXPECT_STREQ("the data", buffer2->data());
base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
- ret = entry->WriteData(
- 1, 10000, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback3)), false);
- EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
+ EXPECT_EQ(25000, WriteData(entry, 1, 10000, buffer2.get(), kSize2, false));
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
-
memset(buffer3->data(), 0, kSize3);
- ret = entry->ReadData(
- 1, 10011, buffer3, kSize3,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback4)));
- EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
-
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+ EXPECT_EQ(24989, ReadData(entry, 1, 10011, buffer3.get(), kSize3));
EXPECT_STREQ("big data goes here", buffer3->data());
- ret = entry->ReadData(
- 1, 0, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback5)));
- EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret);
- if (net::ERR_IO_PENDING == ret)
- expected++;
- EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+ EXPECT_EQ(25000, ReadData(entry, 1, 0, buffer2.get(), kSize2));
memset(buffer3->data(), 0, kSize3);
EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000));
- ret = entry->ReadData(
- 1, 30000, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback6)));
+
+ int ret = entry->ReadData(1, 30000, buffer2.get(), kSize2, cb1.callback());
EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- EXPECT_EQ(0, entry->ReadData(
- 1, 35000, buffer2, kSize2,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback7))));
- ret = entry->ReadData(
- 1, 0, buffer1, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback8)));
+ EXPECT_EQ(0,
+ entry->ReadData(1, 35000, buffer2.get(), kSize2, cb2.callback()));
+ ret = entry->ReadData(1, 0, buffer1.get(), kSize1, cb3.callback());
EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
- ret = entry->WriteData(
- 1, 20000, buffer3, kSize1,
- base::Bind(&CallbackTest::Run, base::Unretained(&callback9)), false);
+
+ ret = entry->WriteData(1, 20000, buffer3.get(), kSize1, cb4.callback(),
+ false);
EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret);
if (net::ERR_IO_PENDING == ret)
expected++;
@@ -500,12 +435,25 @@
ExternalAsyncIO();
}
+TEST_F(DiskCacheEntryTest, V3ExternalAsyncIO) {
+ UseVersion3();
+ InitCache();
+ ExternalAsyncIO();
+}
+
TEST_F(DiskCacheEntryTest, ExternalAsyncIONoBuffer) {
InitCache();
cache_impl_->SetFlags(disk_cache::kNoBuffering);
ExternalAsyncIO();
}
+TEST_F(DiskCacheEntryTest, V3ExternalAsyncIONoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ ExternalAsyncIO();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) {
SetMemoryOnlyMode();
InitCache();
@@ -523,17 +471,25 @@
CacheTestFillBuffer(buffer->data(), kBufferSize, false);
net::ReleaseBufferCompletionCallback cb(buffer);
- int rv = entry->WriteData(0, 0, buffer, kBufferSize, cb.callback(), false);
+ int rv = entry->WriteData(0, 0, buffer.get(), kBufferSize, cb.callback(),
+ false);
EXPECT_EQ(kBufferSize, cb.GetResult(rv));
entry->Close();
}
TEST_F(DiskCacheEntryTest, ReleaseBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
ReleaseBuffer();
}
+TEST_F(DiskCacheEntryTest, V3ReleaseBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ ReleaseBuffer();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) {
SetMemoryOnlyMode();
InitCache();
@@ -554,15 +510,15 @@
}
scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize));
for (int i = 0; i < kNumStreams; i++) {
- EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, reference_buffers[i],
+ EXPECT_EQ(kBufferSize, WriteData(entry, i, 0, reference_buffers[i].get(),
kBufferSize, false));
memset(buffer1->data(), 0, kBufferSize);
- EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1, kBufferSize));
+ EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize));
EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer1->data(),
kBufferSize));
}
EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
- ReadData(entry, kNumStreams, 0, buffer1, kBufferSize));
+ ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize));
entry->Close();
// Open the entry and read it in chunks, including a read past the end.
@@ -574,13 +530,14 @@
scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize));
for (int i = 0; i < kNumStreams; i++) {
memset(buffer2->data(), 0, kReadBufferSize);
- EXPECT_EQ(kReadBufferSize, ReadData(entry, i, 0, buffer2, kReadBufferSize));
+ EXPECT_EQ(kReadBufferSize,
+ ReadData(entry, i, 0, buffer2.get(), kReadBufferSize));
EXPECT_EQ(0, memcmp(reference_buffers[i]->data(), buffer2->data(),
kReadBufferSize));
memset(buffer2->data(), 0, kReadBufferSize);
EXPECT_EQ(kFinalReadSize, ReadData(entry, i, kReadBufferSize,
- buffer2, kReadBufferSize));
+ buffer2.get(), kReadBufferSize));
EXPECT_EQ(0, memcmp(reference_buffers[i]->data() + kReadBufferSize,
buffer2->data(), kFinalReadSize));
}
@@ -593,6 +550,12 @@
StreamAccess();
}
+TEST_F(DiskCacheEntryTest, V3StreamAccess) {
+ UseVersion3();
+ InitCache();
+ StreamAccess();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) {
SetMemoryOnlyMode();
InitCache();
@@ -605,6 +568,7 @@
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
EXPECT_EQ(key, entry->GetKey()) << "short key";
entry->Close();
+ WaitForEntryToClose(key);
int seed = static_cast<int>(Time::Now().ToInternalValue());
srand(seed);
@@ -617,6 +581,7 @@
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key";
entry->Close();
+ WaitForEntryToClose(key);
key_buffer[1000] = 'p';
key_buffer[3000] = '\0';
@@ -624,6 +589,7 @@
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
EXPECT_TRUE(key == entry->GetKey()) << "medium size key";
entry->Close();
+ WaitForEntryToClose(key);
CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true);
key_buffer[19999] = '\0';
@@ -632,6 +598,7 @@
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
EXPECT_TRUE(key == entry->GetKey()) << "long key";
entry->Close();
+ WaitForEntryToClose(key);
CacheTestFillBuffer(key_buffer, 0x4000, true);
key_buffer[0x4000] = '\0';
@@ -647,6 +614,12 @@
GetKey();
}
+TEST_F(DiskCacheEntryTest, V3GetKey) {
+ UseVersion3();
+ InitCache();
+ GetKey();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) {
SetMemoryOnlyMode();
InitCache();
@@ -678,7 +651,7 @@
EXPECT_TRUE(t3 > t2);
const int kSize = 200;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
- EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
if (type_ == net::APP_CACHE) {
EXPECT_TRUE(entry->GetLastUsed() < t2);
EXPECT_TRUE(entry->GetLastModified() < t2);
@@ -697,6 +670,12 @@
GetTimes();
}
+TEST_F(DiskCacheEntryTest, V3GetTimes) {
+ UseVersion3();
+ InitCache();
+ GetTimes();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) {
SetMemoryOnlyMode();
InitCache();
@@ -727,53 +706,57 @@
memset(buffer2->data(), 0, kSize);
base::strlcpy(buffer1->data(), "the data", kSize);
- EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
- EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2, 10));
+ EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false));
+ EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2.get(), 10));
EXPECT_STREQ("the data", buffer2->data());
EXPECT_EQ(10, entry->GetDataSize(0));
- EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+ EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
EXPECT_EQ(2000, entry->GetDataSize(0));
- EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+ EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
- EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+ EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
+ EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
entry->Close();
memset(buffer2->data(), 0, kSize);
std::string key2("Second key");
ASSERT_EQ(net::OK, CreateEntry(key2, &entry));
- EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1, 10, false));
+ EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false));
EXPECT_EQ(10, entry->GetDataSize(0));
entry->Close();
+ WaitForEntryToClose(key2);
// Go from an internal address to a bigger block size.
ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
- EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
+ EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
EXPECT_EQ(2000, entry->GetDataSize(0));
- EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+ EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000));
entry->Close();
+ WaitForEntryToClose(key2);
memset(buffer2->data(), 0, kSize);
// Go from an internal address to an external one.
ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
- EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, kSize, false));
+ EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, kSize));
+ EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize));
entry->Close();
+ WaitForEntryToClose(key2);
// Double check the size from disk.
ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
EXPECT_EQ(20000, entry->GetDataSize(0));
// Now extend the entry without actual data.
- EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1, 0, false));
+ EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1.get(), 0, false));
entry->Close();
+ WaitForEntryToClose(key2);
// And check again from disk.
ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
@@ -786,6 +769,12 @@
GrowData();
}
+TEST_F(DiskCacheEntryTest, V3GrowData) {
+ UseVersion3();
+ InitCache();
+ GrowData();
+}
+
TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) {
InitCache();
cache_impl_->SetFlags(disk_cache::kNoBuffering);
@@ -812,47 +801,48 @@
memset(buffer2->data(), 0, kSize2);
// Simple truncation:
- EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1, 200, false));
+ EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1.get(), 200, false));
EXPECT_EQ(200, entry->GetDataSize(0));
- EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, false));
+ EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, false));
EXPECT_EQ(200, entry->GetDataSize(0));
- EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1, 100, true));
+ EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, true));
EXPECT_EQ(100, entry->GetDataSize(0));
- EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1, 0, true));
+ EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1.get(), 0, true));
EXPECT_EQ(50, entry->GetDataSize(0));
- EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
+ EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
EXPECT_EQ(0, entry->GetDataSize(0));
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
// Go to an external file.
- EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
+ EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2, 20000));
+ EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), 20000));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000));
memset(buffer2->data(), 0, kSize2);
// External file truncation
- EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, false));
+ EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, false));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1, 18000, true));
+ EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, true));
EXPECT_EQ(18000, entry->GetDataSize(0));
- EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1, 0, true));
+ EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1.get(), 0, true));
EXPECT_EQ(17500, entry->GetDataSize(0));
// And back to an internal block.
- EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
+ EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true));
EXPECT_EQ(1600, entry->GetDataSize(0));
- EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2, 600));
+ EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2.get(), 600));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600));
- EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2, 1000));
+ EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2.get(), 1000));
EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) <<
"Preserves previous data";
// Go from external file to zero length.
- EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1, 20000, true));
+ EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1, 0, true));
+ EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true));
EXPECT_EQ(0, entry->GetDataSize(0));
entry->Close();
@@ -863,12 +853,25 @@
TruncateData();
}
+TEST_F(DiskCacheEntryTest, V3TruncateData) {
+ UseVersion3();
+ InitCache();
+ TruncateData();
+}
+
TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
TruncateData();
}
+TEST_F(DiskCacheEntryTest, V3TruncateDataNoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ TruncateData();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) {
SetMemoryOnlyMode();
InitCache();
@@ -899,15 +902,15 @@
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer.get(), kSize));
EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer.get(), kSize));
EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer.get(), kSize));
EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize));
entry->Close();
@@ -918,12 +921,25 @@
ZeroLengthIO();
}
+TEST_F(DiskCacheEntryTest, V3ZeroLengthIO) {
+ UseVersion3();
+ InitCache();
+ ZeroLengthIO();
+}
+
TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
ZeroLengthIO();
}
+TEST_F(DiskCacheEntryTest, V3ZeroLengthIONoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ ZeroLengthIO();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) {
SetMemoryOnlyMode();
InitCache();
@@ -943,66 +959,69 @@
CacheTestFillBuffer(buffer1->data(), kSize, true);
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
entry->Close();
+ WaitForEntryToClose(key);
// Write a little more and read what we wrote before.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1, kSize, false));
- EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
// Now go to an external file.
- EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false));
entry->Close();
+ WaitForEntryToClose(key);
// Write something else and verify old data.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
// Extend the file some more.
- EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false));
entry->Close();
+ WaitForEntryToClose(key);
// And now make sure that we can deal with data in both places (ram/disk).
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false));
// We should not overwrite the data at 18000 with this.
- EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
- EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2, kSize));
+ EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2, kSize));
+ EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100));
// Extend the file again and read before without closing the entry.
- EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, false));
- EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize));
entry->Close();
@@ -1013,12 +1032,25 @@
Buffering();
}
+TEST_F(DiskCacheEntryTest, V3Buffering) {
+ UseVersion3();
+ InitCache();
+ Buffering();
+}
+
TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
Buffering();
}
+TEST_F(DiskCacheEntryTest, V3BufferingNoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ Buffering();
+}
+
// Checks that entries are zero length when created.
void DiskCacheEntryTest::SizeAtCreate() {
const char key[] = "the first key";
@@ -1036,6 +1068,12 @@
SizeAtCreate();
}
+TEST_F(DiskCacheEntryTest, V3SizeAtCreate) {
+ UseVersion3();
+ InitCache();
+ SizeAtCreate();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) {
SetMemoryOnlyMode();
InitCache();
@@ -1056,67 +1094,73 @@
CacheTestFillBuffer(buffer1->data(), kSize, true);
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1, kSize, true));
- EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1, kSize, true));
- EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, true));
entry->Close();
+ WaitForEntryToClose(key);
// Extend the file and read between the old size and the new write.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(23000 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true));
EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize));
// Read at the end of the old file size.
- EXPECT_EQ(kSize, ReadData(entry, 1, 23000 + kSize - 35, buffer2, kSize));
+ EXPECT_EQ(kSize,
+ ReadData(entry, 1, 23000 + kSize - 35, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35));
// Read slightly before the last write.
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
// Extend the entry a little more.
- EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1.get(), kSize, true));
EXPECT_EQ(26000 + kSize, entry->GetDataSize(1));
CacheTestFillBuffer(buffer2->data(), kSize, true);
- EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
// And now reduce the size.
- EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true));
EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2, kSize));
+ EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28));
// Reduce the size with a buffer that is not extending the size.
- EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1.get(), kSize, false));
EXPECT_EQ(25000 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1.get(), kSize, true));
EXPECT_EQ(24500 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2, kSize));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
// And now reduce the size below the old size.
- EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, true));
EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
- EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2, kSize));
+
+ // Repeat the last write to make results consistent across backends.
+ EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false));
+
+ EXPECT_EQ(100, ReadData(entry, 1, 18900, buffer2.get(), kSize));
EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100));
- EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100));
// Verify that the actual file is truncated.
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(19000 + kSize, entry->GetDataSize(1));
// Extend the newly opened file with a zero length write, expect zero fill.
- EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1, 0, false));
- EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1, kSize));
+ EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1.get(), 0, false));
+ EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1.get(), kSize));
EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize));
entry->Close();
@@ -1127,12 +1171,25 @@
SizeChanges();
}
+TEST_F(DiskCacheEntryTest, V3SizeChanges) {
+ UseVersion3();
+ InitCache();
+ SizeChanges();
+}
+
TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
SizeChanges();
}
+TEST_F(DiskCacheEntryTest, V3SizeChangesNoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ SizeChanges();
+}
+
// 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) {
@@ -1148,9 +1205,10 @@
CacheTestFillBuffer(buffer->data(), size, false);
for (int i = 0; i < 15; i++) {
- EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
- EXPECT_EQ(size, WriteData(entry, 0, 0, buffer, size, false));
+ EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
+ EXPECT_EQ(size, WriteData(entry, 0, 0, buffer.get(), size, false));
entry->Close();
+ WaitForEntryToClose(key2);
ASSERT_EQ(net::OK, OpenEntry(key2, &entry));
}
@@ -1165,6 +1223,13 @@
ReuseEntry(20 * 1024);
}
+TEST_F(DiskCacheEntryTest, V3ReuseExternalEntry) {
+ UseVersion3();
+ SetMaxSize(200 * 1024);
+ InitCache();
+ ReuseEntry(20 * 1024);
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) {
SetMemoryOnlyMode();
SetMaxSize(200 * 1024);
@@ -1178,6 +1243,13 @@
ReuseEntry(10 * 1024);
}
+TEST_F(DiskCacheEntryTest, V3ReuseInternalEntry) {
+ UseVersion3();
+ SetMaxSize(100 * 1024);
+ InitCache();
+ ReuseEntry(10 * 1024);
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) {
SetMemoryOnlyMode();
SetMaxSize(100 * 1024);
@@ -1202,49 +1274,51 @@
memset(buffer2->data(), 0, kSize2);
// Simple data grow:
- EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1, 200, false));
+ EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1.get(), 200, false));
EXPECT_EQ(600, entry->GetDataSize(0));
- EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3, 100));
+ EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3.get(), 100));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
// The entry is now on disk. Load it and extend it.
- EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1, 200, false));
+ EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1.get(), 200, false));
EXPECT_EQ(1000, entry->GetDataSize(0));
- EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3, 100));
+ EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3.get(), 100));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
// This time using truncate.
- EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1, 200, true));
+ EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1.get(), 200, true));
EXPECT_EQ(2000, entry->GetDataSize(0));
- EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3, 100));
+ EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3.get(), 100));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100));
// Go to an external file.
- EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1, 200, false));
+ EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1.get(), 200, false));
EXPECT_EQ(20000, entry->GetDataSize(0));
- EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3, 4000));
+ EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3.get(), 4000));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000));
// And back to an internal block.
- EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1, 600, true));
+ EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true));
EXPECT_EQ(1600, entry->GetDataSize(0));
- EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3, 600));
+ EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3.get(), 600));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600));
// Extend it again.
- EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1, 600, false));
+ EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1.get(), 600, false));
EXPECT_EQ(2600, entry->GetDataSize(0));
- EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3, 200));
+ EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3.get(), 200));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
// And again (with truncation flag).
- EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1, 600, true));
+ EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1.get(), 600, true));
EXPECT_EQ(3600, entry->GetDataSize(0));
- EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3, 200));
+ EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3.get(), 200));
EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200));
entry->Close();
@@ -1255,12 +1329,25 @@
InvalidData();
}
+TEST_F(DiskCacheEntryTest, V3InvalidData) {
+ UseVersion3();
+ InitCache();
+ InvalidData();
+}
+
TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) {
InitCache();
- cache_impl_->SetFlags(disk_cache::kNoBuffering);
+ SetNoBuffering();
InvalidData();
}
+TEST_F(DiskCacheEntryTest, V3InvalidDataNoBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ InvalidData();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) {
SetMemoryOnlyMode();
InitCache();
@@ -1273,13 +1360,13 @@
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
- const int kSize = 200;
+ const int kSize = 20000;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
net::TestCompletionCallback cb;
EXPECT_EQ(net::ERR_IO_PENDING,
- entry->WriteData(0, 0, buffer, kSize, cb.callback(), false));
+ entry->WriteData(0, 0, buffer.get(), kSize, cb.callback(), false));
// Release our reference to the buffer.
buffer = NULL;
@@ -1290,7 +1377,7 @@
CacheTestFillBuffer(buffer->data(), kSize, false);
EXPECT_EQ(net::ERR_IO_PENDING,
- entry->ReadData(0, 0, buffer, kSize, cb.callback()));
+ entry->ReadData(0, 0, buffer.get(), kSize, cb.callback()));
buffer = NULL;
EXPECT_EQ(kSize, cb.WaitForResult());
@@ -1302,6 +1389,13 @@
ReadWriteDestroyBuffer();
}
+TEST_F(DiskCacheEntryTest, V3ReadWriteDestroyBuffer) {
+ UseVersion3();
+ InitCache();
+ SetNoBuffering();
+ ReadWriteDestroyBuffer();
+}
+
void DiskCacheEntryTest::DoomNormalEntry() {
std::string key("the first key");
disk_cache::Entry* entry;
@@ -1316,8 +1410,8 @@
key = buffer->data();
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
- EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer, kSize, false));
- EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer, kSize, false));
+ EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false));
+ EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false));
entry->Doom();
entry->Close();
@@ -1330,6 +1424,12 @@
DoomNormalEntry();
}
+TEST_F(DiskCacheEntryTest, V3DoomEntry) {
+ UseVersion3();
+ InitCache();
+ DoomNormalEntry();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) {
SetMemoryOnlyMode();
InitCache();
@@ -1366,6 +1466,12 @@
DoomEntryNextToOpenEntry();
}
+TEST_F(DiskCacheEntryTest, V3DoomEntryNextToOpenEntry) {
+ UseVersion3();
+ InitCache();
+ DoomEntryNextToOpenEntry();
+}
+
TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) {
SetNewEviction();
InitCache();
@@ -1397,8 +1503,8 @@
CacheTestFillBuffer(buffer1->data(), kSize1, false);
memset(buffer2->data(), 0, kSize2);
- EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1, 2000, false));
- EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2, 2000));
+ EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false));
+ EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000));
EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1));
EXPECT_EQ(key, entry->GetKey());
EXPECT_TRUE(initial < entry->GetLastModified());
@@ -1412,14 +1518,19 @@
DoomedEntry();
}
+TEST_F(DiskCacheEntryTest, V3DoomedEntry) {
+ UseVersion3();
+ InitCache();
+ DoomedEntry();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
SetMemoryOnlyMode();
InitCache();
DoomedEntry();
}
-// Tests that we discard entries if the data is missing.
-TEST_F(DiskCacheEntryTest, MissingData) {
+void DiskCacheEntryTest::MissingData() {
InitCache();
std::string key("the first key");
@@ -1430,23 +1541,37 @@
const int kSize = 20000;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
CacheTestFillBuffer(buffer->data(), kSize, false);
- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, false));
entry->Close();
FlushQueueForTest();
disk_cache::Addr address(0x80000001);
- base::FilePath name = cache_impl_->GetFileName(address);
+ if (cache_impl_v3_)
+ address.set_value(0x80040000);
+
+ std::string tmp = base::StringPrintf("f_%06x", address.FileNumber());
+ base::FilePath name = cache_path_.AppendASCII(tmp);
EXPECT_TRUE(file_util::Delete(name, false));
// Attempt to read the data.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
- EXPECT_EQ(net::ERR_FILE_NOT_FOUND, ReadData(entry, 0, 0, buffer, kSize));
+ EXPECT_EQ(net::ERR_FILE_NOT_FOUND,
+ ReadData(entry, 1, 0, buffer.get(), kSize));
entry->Close();
// The entry should be gone.
ASSERT_NE(net::OK, OpenEntry(key, &entry));
}
+TEST_F(DiskCacheEntryTest, MissingData) {
+ MissingData();
+}
+
+TEST_F(DiskCacheEntryTest, V3MissingData) {
+ UseVersion3();
+ MissingData();
+}
+
// Test that child entries in a memory cache backend are not visible from
// enumerations.
TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
@@ -1537,6 +1662,8 @@
VerifySparseIO(entry, 0x800000000LL, buf_1, kSize, buf_2);
entry->Close();
+ AddDelayForTest(40); // We need to close multiple entries.
+ WaitForEntryToClose(key);
// Check everything again.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
@@ -1551,6 +1678,12 @@
BasicSparseIO();
}
+TEST_F(DiskCacheEntryTest, V3BasicSparseIO) {
+ UseVersion3();
+ InitCache();
+ BasicSparseIO();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) {
SetMemoryOnlyMode();
InitCache();
@@ -1571,6 +1704,7 @@
// Write at offset 0x20F0000 (33 MB - 64 KB).
VerifySparseIO(entry, 0x20F0000, buf_1, kSize, buf_2);
entry->Close();
+ WaitForEntryToClose(key);
// Check it again.
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
@@ -1583,13 +1717,19 @@
HugeSparseIO();
}
+TEST_F(DiskCacheEntryTest, V3HugeSparseIO) {
+ UseVersion3();
+ InitCache();
+ HugeSparseIO();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) {
SetMemoryOnlyMode();
InitCache();
HugeSparseIO();
}
-void DiskCacheEntryTest::GetAvailableRange() {
+void DiskCacheEntryTest::SparseGetAvailableRange() {
std::string key("the first key");
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
@@ -1605,39 +1745,44 @@
// We stop at the first empty block.
int64 start;
net::TestCompletionCallback cb;
- int rv = entry->GetAvailableRange(
- 0x20F0000, kSize * 2, &start, cb.callback());
+ int rv = entry->GetAvailableRange(0x20F0000, kSize * 2, &start,
+ cb.callback());
EXPECT_EQ(kSize, cb.GetResult(rv));
EXPECT_EQ(0x20F0000, start);
start = 0;
- rv = entry->GetAvailableRange(0, kSize, &start, cb.callback());
- EXPECT_EQ(0, cb.GetResult(rv));
- rv = entry->GetAvailableRange(
- 0x20F0000 - kSize, kSize, &start, cb.callback());
- EXPECT_EQ(0, cb.GetResult(rv));
- rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
- EXPECT_EQ(kSize, cb.GetResult(rv));
+ EXPECT_EQ(0, GetAvailableRange(entry, 0, kSize, &start));
+ EXPECT_EQ(0, GetAvailableRange(entry, 0x20F0000 - kSize, kSize, &start));
+ //rv = entry->GetAvailableRange(0x20F0000 - kSize, kSize, &start,
+ // cb.callback());
+ //EXPECT_EQ(0, cb.GetResult(rv));
+ //rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback());
+ //EXPECT_EQ(kSize, cb.GetResult(rv));
+ EXPECT_EQ(kSize, GetAvailableRange(entry, 0, 0x2100000, &start));
EXPECT_EQ(0x20F0000, start);
// We should be able to Read based on the results of GetAvailableRange.
start = -1;
- rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
- EXPECT_EQ(0, cb.GetResult(rv));
- rv = entry->ReadSparseData(start, buf, kSize, cb.callback());
- EXPECT_EQ(0, cb.GetResult(rv));
+ EXPECT_EQ(0, GetAvailableRange(entry, 0x2100000, kSize, &start));
+ //rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback());
+ //EXPECT_EQ(0, cb.GetResult(rv));
+ EXPECT_EQ(0, ReadSparseData(entry, start, buf, kSize));
+ //rv = entry->ReadSparseData(start, buf, kSize, cb.callback());
+ //EXPECT_EQ(0, cb.GetResult(rv));
start = 0;
- rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
- EXPECT_EQ(0x2000, cb.GetResult(rv));
+ EXPECT_EQ(0x2000, GetAvailableRange(entry, 0x20F2000, kSize, &start));
+ //rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback());
+ //EXPECT_EQ(0x2000, cb.GetResult(rv));
EXPECT_EQ(0x20F2000, start);
EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf, kSize));
// Make sure that we respect the |len| argument.
start = 0;
- rv = entry->GetAvailableRange(
- 0x20F0001 - kSize, kSize, &start, cb.callback());
- EXPECT_EQ(1, cb.GetResult(rv));
+ EXPECT_EQ(1, GetAvailableRange(entry, 0x20F0001 - kSize, kSize, &start));
+ //rv = entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start,
+ // cb.callback());
+ //EXPECT_EQ(1, cb.GetResult(rv));
EXPECT_EQ(0x20F0000, start);
entry->Close();
@@ -1645,13 +1790,19 @@
TEST_F(DiskCacheEntryTest, GetAvailableRange) {
InitCache();
- GetAvailableRange();
+ SparseGetAvailableRange();
}
+TEST_F(DiskCacheEntryTest, V3GetAvailableRange) {
+ UseVersion3();
+ InitCache();
+ SparseGetAvailableRange();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) {
SetMemoryOnlyMode();
InitCache();
- GetAvailableRange();
+ SparseGetAvailableRange();
}
void DiskCacheEntryTest::CouldBeSparse() {
@@ -1668,22 +1819,25 @@
EXPECT_TRUE(entry->CouldBeSparse());
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
EXPECT_TRUE(entry->CouldBeSparse());
entry->Close();
+ WaitForEntryToClose(key);
// Now verify a regular entry.
key.assign("another key");
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
EXPECT_FALSE(entry->CouldBeSparse());
- EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf, kSize, false));
- EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf, kSize, false));
- EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false));
EXPECT_FALSE(entry->CouldBeSparse());
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
EXPECT_FALSE(entry->CouldBeSparse());
@@ -1695,6 +1849,12 @@
CouldBeSparse();
}
+TEST_F(DiskCacheEntryTest, V3CouldBeSparse) {
+ UseVersion3();
+ InitCache();
+ CouldBeSparse();
+}
+
TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) {
SetMemoryOnlyMode();
InitCache();
@@ -1745,16 +1905,16 @@
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
// Writes in the middle of an entry.
- EXPECT_EQ(1024, entry->WriteSparseData(
- 0, buf, 1024, net::CompletionCallback()));
- EXPECT_EQ(1024, entry->WriteSparseData(
- 5120, buf, 1024, net::CompletionCallback()));
- EXPECT_EQ(1024, entry->WriteSparseData(
- 10000, buf, 1024, net::CompletionCallback()));
+ EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024,
+ net::CompletionCallback()));
+ EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024,
+ net::CompletionCallback()));
+ EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024,
+ net::CompletionCallback()));
// Writes in the middle of an entry and spans 2 child entries.
- EXPECT_EQ(8192, entry->WriteSparseData(
- 50000, buf, 8192, net::CompletionCallback()));
+ EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192,
+ net::CompletionCallback()));
int64 start;
net::TestCompletionCallback cb;
@@ -1830,6 +1990,13 @@
UpdateSparseEntry();
}
+TEST_F(DiskCacheEntryTest, V3UpdateSparseEntry) {
+ UseVersion3();
+ SetCacheType(net::MEDIA_CACHE);
+ InitCache();
+ UpdateSparseEntry();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
SetMemoryOnlyMode();
SetCacheType(net::MEDIA_CACHE);
@@ -1871,6 +2038,8 @@
entry1->Doom();
entry1->Close();
entry2->Close();
+ WaitForEntryToClose(key1);
+ WaitForEntryToClose(key2);
// Doom the second entry after it's fully saved.
EXPECT_EQ(net::OK, DoomEntry(key2));
@@ -1878,7 +2047,7 @@
// Make sure we do all needed work. This may fail for entry2 if between Close
// and DoomEntry the system decides to remove all traces of the file from the
// system cache so we don't see that there is pending IO.
- MessageLoop::current()->RunUntilIdle();
+ WaitForEntryToClose(key2);
if (memory_only_) {
EXPECT_EQ(0, cache_->GetEntryCount());
@@ -1888,7 +2057,7 @@
// (it's always async on Posix so it is easy to miss). Unfortunately we
// don't have any signal to watch for so we can only wait.
base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
- MessageLoop::current()->RunUntilIdle();
+ FlushQueueForTest();
}
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -1900,6 +2069,13 @@
DoomSparseEntry();
}
+TEST_F(DiskCacheEntryTest, V3DoomSparseEntry) {
+ UseVersion3();
+ UseCurrentThread();
+ InitCache();
+ DoomSparseEntry();
+}
+
TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
SetMemoryOnlyMode();
InitCache();
@@ -1928,8 +2104,9 @@
// 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::DoomSparseEntry2() {
UseCurrentThread();
+ ForceRandomCacheDir();
InitCache();
std::string key("the key");
disk_cache::Entry* entry;
@@ -1949,15 +2126,28 @@
EXPECT_EQ(9, cache_->GetEntryCount());
entry->Close();
+ WaitForEntryToClose(key);
+
SparseTestCompletionCallback cb(cache_);
int rv = cache_->DoomEntry(key, cb.callback());
EXPECT_EQ(net::ERR_IO_PENDING, rv);
EXPECT_EQ(net::OK, cb.WaitForResult());
- // TearDown will attempt to delete the cache_.
+ // TearDown will attempt to delete the cache.
cache_ = NULL;
+ cache_impl_ = NULL;
+ cache_impl_v3_ = NULL;
}
+TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
+ DoomSparseEntry2();
+}
+
+TEST_F(DiskCacheEntryTest, V3DoomSparseEntry2) {
+ UseVersion3();
+ DoomSparseEntry2();
+}
+
void DiskCacheEntryTest::PartialSparseEntry() {
std::string key("the first key");
disk_cache::Entry* entry;
@@ -1977,6 +2167,7 @@
EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1, kSize));
EXPECT_EQ(kSmallSize, WriteSparseData(entry, 1080321, buf1, kSmallSize));
entry->Close();
+ WaitForEntryToClose(key);
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize));
@@ -2047,6 +2238,12 @@
PartialSparseEntry();
}
+TEST_F(DiskCacheEntryTest, V3PartialSparseEntry) {
+ UseVersion3();
+ InitCache();
+ PartialSparseEntry();
+}
+
TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) {
SetMemoryOnlyMode();
InitCache();
@@ -2054,8 +2251,9 @@
}
// Tests that corrupt sparse children are removed automatically.
-TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
+void DiskCacheEntryTest::CleanupSparseEntry() {
InitCache();
+ SetNoBuffering();
std::string key("the first key");
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
@@ -2066,8 +2264,11 @@
const int k1Meg = 1024 * 1024;
EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1, kSize));
+ AddDelayForTest(70);
EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1, kSize));
+ AddDelayForTest(70);
EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1, kSize));
+ AddDelayForTest(70);
entry->Close();
EXPECT_EQ(4, cache_->GetEntryCount());
@@ -2084,7 +2285,7 @@
for (int i = 0; i < 2; i++) {
ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry));
// Overwrite the header's magic and signature.
- EXPECT_EQ(12, WriteData(entry, 2, 0, buf1, 12, false));
+ EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false));
entry->Close();
}
@@ -2104,9 +2305,18 @@
EXPECT_EQ(3, cache_->GetEntryCount());
}
-TEST_F(DiskCacheEntryTest, CancelSparseIO) {
- UseCurrentThread();
+TEST_F(DiskCacheEntryTest, CleanupSparseEntry) {
+ CleanupSparseEntry();
+}
+
+TEST_F(DiskCacheEntryTest, V3CleanupSparseEntry) {
+ UseVersion3();
+ CleanupSparseEntry();
+}
+
+void DiskCacheEntryTest::CancelSparseIO() {
InitCache();
+ SetNoBuffering();
std::string key("the first key");
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
@@ -2117,8 +2327,8 @@
// This will open and write two "real" entries.
net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5;
- int rv = entry->WriteSparseData(
- 1024 * 1024 - 4096, buf, kSize, cb1.callback());
+ int rv = entry->WriteSparseData(1024 * 1024 - kSize / 2, buf, kSize,
+ cb1.callback());
EXPECT_EQ(net::ERR_IO_PENDING, rv);
int64 offset = 0;
@@ -2149,7 +2359,7 @@
// Now see if we receive all notifications. Note that we should not be able
// to write everything (unless the timing of the system is really weird).
rv = cb1.WaitForResult();
- EXPECT_TRUE(rv == 4096 || rv == kSize);
+ EXPECT_TRUE(rv == kSize / 2 || rv == kSize);
EXPECT_EQ(net::OK, cb2.WaitForResult());
EXPECT_EQ(net::OK, cb3.WaitForResult());
EXPECT_EQ(net::OK, cb4.WaitForResult());
@@ -2159,6 +2369,48 @@
entry->Close();
}
+TEST_F(DiskCacheEntryTest, CancelSparseIO) {
+ UseCurrentThread();
+ CancelSparseIO();
+}
+
+TEST_F(DiskCacheEntryTest, V3CancelSparseIO) {
+ UseVersion3();
+ CancelSparseIO();
+}
+
+// Tests a squence of Close + Open + ReadyForSparseIO + ReadSparseData.
+void DiskCacheEntryTest::ReadyForSparseIONoCancel() {
+ InitCache();
+ SetNoBuffering();
+ std::string key("the key");
+ disk_cache::Entry* entry;
+ ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+
+ const int kSize = 4 * 1024;
+ scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
+ CacheTestFillBuffer(buf1->data(), kSize, false);
+ EXPECT_EQ(kSize, WriteSparseData(entry, 1024 * 1024 - kSize, buf1, kSize));
+
+ entry->Close();
+ WaitForEntryToClose(key);
+ ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ net::TestCompletionCallback cb;
+ EXPECT_EQ(net::OK, cb.GetResult(entry->ReadyForSparseIO(cb.callback())));
+ EXPECT_EQ(kSize, ReadSparseData(entry, 1024 * 1024 - kSize, buf1, kSize));
+ entry->Close();
+}
+
+TEST_F(DiskCacheEntryTest, ReadyForSparseIONoCancel) {
+ UseVersion3();
+ ReadyForSparseIONoCancel();
+}
+
+TEST_F(DiskCacheEntryTest, V3ReadyForSparseIONoCancel) {
+ UseVersion3();
+ ReadyForSparseIONoCancel();
+}
+
// 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) {
@@ -2185,8 +2437,9 @@
DisableIntegrityCheck();
}
-// The simple cache backend isn't intended to work on Windows, which has very
-// different file system guarantees from Linux.
+// The Simple Cache backend requires a few guarantees from the filesystem like
+// atomic renaming of recently open files. Those guarantees are not provided in
+// general on Windows.
#if defined(OS_POSIX)
TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO) {
« no previous file with comments | « net/disk_cache/entry_impl.cc ('k') | net/disk_cache/errors.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698