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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/disk_cache/entry_unittest.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 months 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
« net/base/mime_util_unittest.cc ('K') | « net/disk_cache/disk_cache_test_util.cc ('k') | net/disk_cache/memory/mem_backend_impl.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
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index 359f7250845df4609a4872fe3473a8d2093185a1..62b8da87fdbb5a990452915d6bde74a0cbda136b 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -126,10 +126,10 @@ void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
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
@@ -146,7 +146,6 @@ void DiskCacheEntryTest::InternalSyncIO() {
base::Unretained(this),
entry));
-
entry->Doom();
entry->Close();
FlushQueueForTest();
@@ -413,10 +412,10 @@ void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) {
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() {
@@ -1136,7 +1135,7 @@ TEST_F(DiskCacheEntryTest, BufferingNoBuffer) {
// Checks that entries are zero length when created.
void DiskCacheEntryTest::SizeAtCreate() {
- const char key[] = "the first key";
+ const char key[] = "the first key";
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
@@ -1632,8 +1631,11 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
}
// Writes |buf_1| to offset and reads it back as |buf_2|.
-void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
- net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) {
+void VerifySparseIO(disk_cache::Entry* entry,
+ int64 offset,
+ net::IOBuffer* buf_1,
+ int size,
+ net::IOBuffer* buf_2) {
net::TestCompletionCallback cb;
memset(buf_2->data(), 0, size);
@@ -1651,7 +1653,9 @@ void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
// 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 offset, char* buffer,
+void VerifyContentSparseIO(disk_cache::Entry* entry,
+ int64 offset,
+ char* buffer,
int size) {
net::TestCompletionCallback cb;
@@ -1750,16 +1754,16 @@ void DiskCacheEntryTest::GetAvailableRange() {
// 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());
+ 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));
@@ -1780,8 +1784,8 @@ void DiskCacheEntryTest::GetAvailableRange() {
// Make sure that we respect the |len| argument.
start = 0;
- rv = entry->GetAvailableRange(
- 0x20F0001 - kSize, kSize, &start, cb.callback());
+ rv =
+ entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start, cb.callback());
EXPECT_EQ(1, cb.GetResult(rv));
EXPECT_EQ(0x20F0000, start);
@@ -1862,7 +1866,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) {
// This loop writes back to back starting from offset 0 and 9000.
for (int i = 0; i < kSize; i += 1024) {
scoped_refptr<net::WrappedIOBuffer> buf_3(
- new net::WrappedIOBuffer(buf_1->data() + i));
+ new net::WrappedIOBuffer(buf_1->data() + i));
VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get());
VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get());
}
@@ -1989,7 +1993,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) {
void DiskCacheEntryTest::DoomSparseEntry() {
std::string key1("the first key");
std::string key2("the second key");
- disk_cache::Entry *entry1, *entry2;
+ disk_cache::Entry* entry1, *entry2;
ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
@@ -2056,11 +2060,10 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) {
// The way a CompletionCallback 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 {
+class SparseTestCompletionCallback : public net::TestCompletionCallback {
public:
explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache)
- : cache_(cache.Pass()) {
- }
+ : cache_(cache.Pass()) {}
private:
virtual void SetResult(int result) OVERRIDE {
@@ -2567,7 +2570,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
entry->Doom(); // Should not crash.
}
-bool TruncatePath(const base::FilePath& file_path, int64 length) {
+bool TruncatePath(const base::FilePath& file_path, int64 length) {
base::File file(file_path, base::File::FLAG_WRITE | base::File::FLAG_OPEN);
if (!file.IsValid())
return false;
@@ -2746,9 +2749,10 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
disk_cache::Entry* entry = NULL;
// Create is optimistic, must return OK.
ASSERT_EQ(net::OK,
- cache_->CreateEntry(key, &entry,
- base::Bind(&CallbackTest::Run,
- base::Unretained(&callback1))));
+ cache_->CreateEntry(
+ key,
+ &entry,
+ base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
EXPECT_NE(null, entry);
ScopedEntryPtr entry_closer(entry);
@@ -2804,8 +2808,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) {
// Check that we are not leaking.
EXPECT_NE(entry, null);
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}
TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) {
@@ -2822,17 +2825,19 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) {
disk_cache::Entry* entry = NULL;
ASSERT_EQ(net::OK,
- cache_->CreateEntry(key, &entry,
- base::Bind(&CallbackTest::Run,
- base::Unretained(&callback1))));
+ cache_->CreateEntry(
+ key,
+ &entry,
+ base::Bind(&CallbackTest::Run, base::Unretained(&callback1))));
EXPECT_NE(null, entry);
ScopedEntryPtr entry_closer(entry);
disk_cache::Entry* entry2 = NULL;
ASSERT_EQ(net::ERR_IO_PENDING,
- cache_->OpenEntry(key, &entry2,
- base::Bind(&CallbackTest::Run,
- base::Unretained(&callback2))));
+ cache_->OpenEntry(
+ key,
+ &entry2,
+ base::Bind(&CallbackTest::Run, base::Unretained(&callback2))));
ASSERT_TRUE(helper.WaitUntilCacheIoFinished(1));
EXPECT_NE(null, entry2);
@@ -2842,8 +2847,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) {
entry->Close();
// Check that we are not leaking.
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}
TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) {
@@ -2871,8 +2875,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) {
EXPECT_EQ(entry, entry2);
// Check that we are not leaking.
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
}
TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
@@ -2936,8 +2939,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) {
EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
// Check that we are not leaking.
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
entry2->Close();
}
@@ -2971,8 +2973,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5) {
EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
// Check that we are not leaking.
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
}
TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) {
@@ -3143,8 +3144,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheDoomDoom) {
disk_cache::SimpleEntryImpl* simple_entry1 =
static_cast<disk_cache::SimpleEntryImpl*>(entry1);
net::TestCompletionCallback cb;
- EXPECT_EQ(net::OK,
- cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
+ EXPECT_EQ(net::OK, cb.GetResult(simple_entry1->DoomEntry(cb.callback())));
disk_cache::Entry* entry3 = NULL;
ASSERT_EQ(net::OK, OpenEntry(key, &entry3));
@@ -3191,16 +3191,15 @@ TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen) {
disk_cache::Entry* entry = NULL;
disk_cache::Entry* entry2 = NULL;
- EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
- key, cache_path_));
+ EXPECT_TRUE(
+ disk_cache::simple_util::CreateCorruptFileForTests(key, cache_path_));
EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback()));
ASSERT_TRUE(entry);
ScopedEntryPtr entry_closer(entry);
ASSERT_NE(net::OK, OpenEntry(key, &entry2));
// Check that we are not leaking.
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
DisableIntegrityCheck();
}
@@ -3249,8 +3248,8 @@ TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) {
// Generally there is no guarantee that at this point the backround eviction
// is finished. We are testing the positive case, i.e. when the eviction
// never reaches this entry, should be non-flaky.
- ASSERT_EQ(net::OK, OpenEntry(key2 + base::StringPrintf("%d", entry_no),
- &entry))
+ ASSERT_EQ(net::OK,
+ OpenEntry(key2 + base::StringPrintf("%d", entry_no), &entry))
<< "Should not have evicted fresh entry " << entry_no;
entry->Close();
}
@@ -3259,7 +3258,7 @@ 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) {
+TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate) {
SetSimpleCacheMode();
InitCache();
@@ -3297,8 +3296,8 @@ TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate) {
++expected;
// Truncate the entry to the length of that read.
- scoped_refptr<net::IOBuffer>
- truncate_buffer(new net::IOBuffer(kReadBufferSize));
+ scoped_refptr<net::IOBuffer> truncate_buffer(
+ new net::IOBuffer(kReadBufferSize));
CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
CallbackTest truncate_callback(&helper, false);
EXPECT_EQ(net::ERR_IO_PENDING,
@@ -3498,8 +3497,7 @@ TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) {
// Check that we are not leaking.
EXPECT_NE(entry, null);
- EXPECT_TRUE(
- static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
+ EXPECT_TRUE(static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
entry->Close();
entry = NULL;
}
@@ -3600,7 +3598,8 @@ TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges) {
int eof_offset = entry_stat.GetEOFOffsetInFile(key, 0);
disk_cache::SimpleFileEOF eof_record;
ASSERT_EQ(static_cast<int>(sizeof(eof_record)),
- entry_file0.Read(eof_offset, reinterpret_cast<char*>(&eof_record),
+ entry_file0.Read(eof_offset,
+ reinterpret_cast<char*>(&eof_record),
sizeof(eof_record)));
EXPECT_EQ(disk_cache::kSimpleFinalMagicNumber, eof_record.final_magic_number);
EXPECT_TRUE((eof_record.flags & disk_cache::SimpleFileEOF::FLAG_HAS_CRC32) ==
« net/base/mime_util_unittest.cc ('K') | « net/disk_cache/disk_cache_test_util.cc ('k') | net/disk_cache/memory/mem_backend_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698