Clang format slam.

net/disk_cache/simple/simple_index_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <functional>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 namespace disk_cache {
 namespace {
 
 const base::Time kTestLastUsedTime =
     base::Time::UnixEpoch() + base::TimeDelta::FromDays(20);
 const int kTestEntrySize = 789;
 
 }  // namespace
 
-
-class EntryMetadataTest  : public testing::Test {
+class EntryMetadataTest : public testing::Test {
  public:
   EntryMetadata NewEntryMetadataWithValues() {
     return EntryMetadata(kTestLastUsedTime, kTestEntrySize);
   }
 
   void CheckEntryMetadataValues(const EntryMetadata& entry_metadata) {
     EXPECT_LT(kTestLastUsedTime - base::TimeDelta::FromSeconds(2),
               entry_metadata.GetLastUsedTime());
     EXPECT_GT(kTestLastUsedTime + base::TimeDelta::FromSeconds(2),
               entry_metadata.GetLastUsedTime());
@@ skipping 37 matching lines @@
   int disk_writes() const { return disk_writes_; }
 
  private:
   base::Closure load_callback_;
   SimpleIndexLoadResult* load_result_;
   int load_index_entries_calls_;
   int disk_writes_;
   SimpleIndex::EntrySet disk_write_entry_set_;
 };
 
-class SimpleIndexTest  : public testing::Test, public SimpleIndexDelegate {
+class SimpleIndexTest : public testing::Test, public SimpleIndexDelegate {
  protected:
   SimpleIndexTest()
-      : hashes_(base::Bind(&HashesInitializer)),
-        doom_entries_calls_(0) {}
+      : hashes_(base::Bind(&HashesInitializer)), doom_entries_calls_(0) {}
 
   static uint64 HashesInitializer(size_t hash_index) {
     return disk_cache::simple_util::GetEntryHashKey(
         base::StringPrintf("key%d", static_cast<int>(hash_index)));
   }
 
   virtual void SetUp() OVERRIDE {
     scoped_ptr<MockSimpleIndexFile> index_file(new MockSimpleIndexFile());
     index_file_ = index_file->AsWeakPtr();
-    index_.reset(new SimpleIndex(NULL, this, net::DISK_CACHE,
-                                 index_file.PassAs<SimpleIndexFile>()));
+    index_.reset(new SimpleIndex(
+        NULL, this, net::DISK_CACHE, index_file.PassAs<SimpleIndexFile>()));
 
     index_->Initialize(base::Time());
   }
 
   void WaitForTimeChange() {
     const base::Time initial_time = base::Time::Now();
     do {
       base::PlatformThread::YieldCurrentThread();
-    } while (base::Time::Now() -
-             initial_time < base::TimeDelta::FromSeconds(1));
+    } while (base::Time::Now() - initial_time <
+             base::TimeDelta::FromSeconds(1));
   }
 
   // From SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
                            const net::CompletionCallback& callback) OVERRIDE {
-    std::for_each(entry_hashes->begin(), entry_hashes->end(),
-                  std::bind1st(std::mem_fun(&SimpleIndex::Remove),
-                               index_.get()));
+    std::for_each(
+        entry_hashes->begin(),
+        entry_hashes->end(),
+        std::bind1st(std::mem_fun(&SimpleIndex::Remove), index_.get()));
     last_doom_entry_hashes_ = *entry_hashes;
     ++doom_entries_calls_;
   }
 
   // Redirect to allow single "friend" declaration in base class.
   bool GetEntryForTesting(uint64 key, EntryMetadata* metadata) {
     SimpleIndex::EntrySet::iterator it = index_->entries_set_.find(key);
     if (index_->entries_set_.end() == it)
       return false;
     *metadata = it->second;
     return true;
   }
 
   void InsertIntoIndexFileReturn(uint64 hash_key,
                                  base::Time last_used_time,
                                  int entry_size) {
-    index_file_->load_result()->entries.insert(std::make_pair(
-        hash_key, EntryMetadata(last_used_time, entry_size)));
+    index_file_->load_result()->entries.insert(
+        std::make_pair(hash_key, EntryMetadata(last_used_time, entry_size)));
   }
 
   void ReturnIndexFile() {
     index_file_->load_result()->did_load = true;
     index_file_->load_callback().Run();
   }
 
   // Non-const for timer manipulation.
   SimpleIndex* index() { return index_.get(); }
   const MockSimpleIndexFile* index_file() const { return index_file_.get(); }
 
   const std::vector<uint64>& last_doom_entry_hashes() const {
     return last_doom_entry_hashes_;
   }
   int doom_entries_calls() const { return doom_entries_calls_; }
 
-
   const simple_util::ImmutableArray<uint64, 16> hashes_;
   scoped_ptr<SimpleIndex> index_;
   base::WeakPtr<MockSimpleIndexFile> index_file_;
 
   std::vector<uint64> last_doom_entry_hashes_;
   int doom_entries_calls_;
 };
 
 TEST_F(EntryMetadataTest, Basics) {
   EntryMetadata entry_metadata;
@@ skipping 186 matching lines @@
   index()->Remove(hashes_.at<1>());
   EXPECT_EQ(1, index()->GetEntryCount());
   index()->Remove(hashes_.at<4>());
   EXPECT_EQ(0, index()->GetEntryCount());
 }
 
 // Confirm that we get the results we expect from a simple init.
 TEST_F(SimpleIndexTest, BasicInit) {
   base::Time now(base::Time::Now());
 
-  InsertIntoIndexFileReturn(hashes_.at<1>(),
-                            now - base::TimeDelta::FromDays(2),
-                            10u);
-  InsertIntoIndexFileReturn(hashes_.at<2>(),
-                            now - base::TimeDelta::FromDays(3),
-                            100u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<1>(), now - base::TimeDelta::FromDays(2), 10u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<2>(), now - base::TimeDelta::FromDays(3), 100u);
 
   ReturnIndexFile();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<1>(), &metadata));
   EXPECT_LT(
       now - base::TimeDelta::FromDays(2) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_GT(
       now - base::TimeDelta::FromDays(2) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_EQ(10, metadata.GetEntrySize());
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<2>(), &metadata));
   EXPECT_LT(
       now - base::TimeDelta::FromDays(3) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_GT(
       now - base::TimeDelta::FromDays(3) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_EQ(100, metadata.GetEntrySize());
 }
 
 // Remove something that's going to come in from the loaded index.
 TEST_F(SimpleIndexTest, RemoveBeforeInit) {
   const uint64 kHash1 = hashes_.at<1>();
   index()->Remove(kHash1);
 
-  InsertIntoIndexFileReturn(kHash1,
-                            base::Time::Now() - base::TimeDelta::FromDays(2),
-                            10u);
+  InsertIntoIndexFileReturn(
+      kHash1, base::Time::Now() - base::TimeDelta::FromDays(2), 10u);
   ReturnIndexFile();
 
   EXPECT_FALSE(index()->Has(kHash1));
 }
 
 // Insert something that's going to come in from the loaded index; correct
 // result?
 TEST_F(SimpleIndexTest, InsertBeforeInit) {
   const uint64 kHash1 = hashes_.at<1>();
   index()->Insert(kHash1);
 
-  InsertIntoIndexFileReturn(kHash1,
-                            base::Time::Now() - base::TimeDelta::FromDays(2),
-                            10u);
+  InsertIntoIndexFileReturn(
+      kHash1, base::Time::Now() - base::TimeDelta::FromDays(2), 10u);
   ReturnIndexFile();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(kHash1, &metadata));
   base::Time now(base::Time::Now());
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_EQ(0, metadata.GetEntrySize());
 }
 
 // Insert and Remove something that's going to come in from the loaded index.
 TEST_F(SimpleIndexTest, InsertRemoveBeforeInit) {
   const uint64 kHash1 = hashes_.at<1>();
   index()->Insert(kHash1);
   index()->Remove(kHash1);
 
-  InsertIntoIndexFileReturn(kHash1,
-                            base::Time::Now() - base::TimeDelta::FromDays(2),
-                            10u);
+  InsertIntoIndexFileReturn(
+      kHash1, base::Time::Now() - base::TimeDelta::FromDays(2), 10u);
   ReturnIndexFile();
 
   EXPECT_FALSE(index()->Has(kHash1));
 }
 
 // Insert and Remove something that's going to come in from the loaded index.
 TEST_F(SimpleIndexTest, RemoveInsertBeforeInit) {
   const uint64 kHash1 = hashes_.at<1>();
   index()->Remove(kHash1);
   index()->Insert(kHash1);
 
-  InsertIntoIndexFileReturn(kHash1,
-                            base::Time::Now() - base::TimeDelta::FromDays(2),
-                            10u);
+  InsertIntoIndexFileReturn(
+      kHash1, base::Time::Now() - base::TimeDelta::FromDays(2), 10u);
   ReturnIndexFile();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(kHash1, &metadata));
   base::Time now(base::Time::Now());
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_EQ(0, metadata.GetEntrySize());
 }
 
 // Do all above tests at once + a non-conflict to test for cross-key
 // interactions.
 TEST_F(SimpleIndexTest, AllInitConflicts) {
   base::Time now(base::Time::Now());
 
   index()->Remove(hashes_.at<1>());
-  InsertIntoIndexFileReturn(hashes_.at<1>(),
-                            now - base::TimeDelta::FromDays(2),
-                            10u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<1>(), now - base::TimeDelta::FromDays(2), 10u);
   index()->Insert(hashes_.at<2>());
-  InsertIntoIndexFileReturn(hashes_.at<2>(),
-                            now - base::TimeDelta::FromDays(3),
-                            100u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<2>(), now - base::TimeDelta::FromDays(3), 100u);
   index()->Insert(hashes_.at<3>());
   index()->Remove(hashes_.at<3>());
-  InsertIntoIndexFileReturn(hashes_.at<3>(),
-                            now - base::TimeDelta::FromDays(4),
-                            1000u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<3>(), now - base::TimeDelta::FromDays(4), 1000u);
   index()->Remove(hashes_.at<4>());
   index()->Insert(hashes_.at<4>());
-  InsertIntoIndexFileReturn(hashes_.at<4>(),
-                            now - base::TimeDelta::FromDays(5),
-                            10000u);
-  InsertIntoIndexFileReturn(hashes_.at<5>(),
-                            now - base::TimeDelta::FromDays(6),
-                            100000u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<4>(), now - base::TimeDelta::FromDays(5), 10000u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<5>(), now - base::TimeDelta::FromDays(6), 100000u);
 
   ReturnIndexFile();
 
   EXPECT_FALSE(index()->Has(hashes_.at<1>()));
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<2>(), &metadata));
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_EQ(0, metadata.GetEntrySize());
@@ skipping 13 matching lines @@
   EXPECT_LT(
       now - base::TimeDelta::FromDays(6) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
 
   EXPECT_EQ(100000, metadata.GetEntrySize());
 }
 
 TEST_F(SimpleIndexTest, BasicEviction) {
   base::Time now(base::Time::Now());
   index()->SetMaxSize(1000);
-  InsertIntoIndexFileReturn(hashes_.at<1>(),
-                            now - base::TimeDelta::FromDays(2),
-                            475u);
+  InsertIntoIndexFileReturn(
+      hashes_.at<1>(), now - base::TimeDelta::FromDays(2), 475u);
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 475);
   ReturnIndexFile();
 
   WaitForTimeChange();
 
   index()->Insert(hashes_.at<3>());
   // Confirm index is as expected: No eviction, everything there.
   EXPECT_EQ(3, index()->GetEntryCount());
   EXPECT_EQ(0, doom_entries_calls());
@@ skipping 85 matching lines @@
   WaitForTimeChange();
   EXPECT_EQ(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 40);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   EXPECT_LT(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->write_to_disk_timer_.Stop();
 }
 
 }  // namespace disk_cache