Clang format slam.

net/disk_cache/blockfile/index_table_v3_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/disk_cache/blockfile/addr.h"
 #include "net/disk_cache/blockfile/disk_format_v3.h"
 #include "net/disk_cache/blockfile/index_table_v3.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 90 matching lines @@
 }
 
 void TestCacheTables::GetInitData(IndexTableInitData* result) {
   result->index_bitmap =
       reinterpret_cast<disk_cache::IndexBitmap*>(main_bitmap_.get());
 
   result->main_table = main_table_.get();
   result->extra_table = extra_table_.get();
 
   result->backup_header.reset(new disk_cache::IndexHeaderV3);
-  memcpy(result->backup_header.get(), result->index_bitmap,
+  memcpy(result->backup_header.get(),
+         result->index_bitmap,
          sizeof(result->index_bitmap->header));
 
   result->backup_bitmap.reset(new uint32[num_bitmap_bytes_ / sizeof(uint32)]);
-  memcpy(result->backup_bitmap.get(), result->index_bitmap->bitmap,
+  memcpy(result->backup_bitmap.get(),
+         result->index_bitmap->bitmap,
          num_bitmap_bytes_);
 }
 
 void TestCacheTables::CopyFrom(const TestCacheTables& other) {
   disk_cache::IndexBitmap* this_bitmap =
-    reinterpret_cast<disk_cache::IndexBitmap*>(main_bitmap_.get());
+      reinterpret_cast<disk_cache::IndexBitmap*>(main_bitmap_.get());
   disk_cache::IndexBitmap* other_bitmap =
-    reinterpret_cast<disk_cache::IndexBitmap*>(other.main_bitmap_.get());
+      reinterpret_cast<disk_cache::IndexBitmap*>(other.main_bitmap_.get());
 
   DCHECK_GE(this_bitmap->header.table_len, other_bitmap->header.table_len);
   DCHECK_GE(num_bitmap_bytes_, other.num_bitmap_bytes_);
 
   memcpy(this_bitmap->bitmap, other_bitmap->bitmap, other.num_bitmap_bytes_);
 
   int main_table_buckets = (other_bitmap->header.table_len * 2 / 3) / 4;
   int extra_table_buckets = (other_bitmap->header.table_len * 1 / 3) / 4;
-  memcpy(main_table_.get(), other.main_table_.get(),
+  memcpy(main_table_.get(),
+         other.main_table_.get(),
          main_table_buckets * sizeof(disk_cache::IndexBucket));
-  memcpy(extra_table_.get(), other.extra_table_.get(),
+  memcpy(extra_table_.get(),
+         other.extra_table_.get(),
          extra_table_buckets * sizeof(disk_cache::IndexBucket));
 
   this_bitmap->header.num_entries = other_bitmap->header.num_entries;
   this_bitmap->header.used_cells = other_bitmap->header.used_cells;
   this_bitmap->header.max_bucket = other_bitmap->header.max_bucket;
   this_bitmap->header.create_time = other_bitmap->header.create_time;
   this_bitmap->header.base_time = other_bitmap->header.base_time;
   this_bitmap->header.flags = other_bitmap->header.flags;
   start_time_ = other.start_time_;
 }
 
 }  // namespace
 
 TEST(DiskCacheIndexTable, EntryCell) {
   uint32 hash = 0x55aa6699;
   disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, 0x4531);
   bool small_table = true;
   int cell_num = 88;
   int reuse = 6;
   int timestamp = 123456;
   disk_cache::EntryState state = disk_cache::ENTRY_MODIFIED;
   disk_cache::EntryGroup group = disk_cache::ENTRY_HIGH_USE;
 
   for (int i = 0; i < 4; i++) {
     SCOPED_TRACE(i);
-    EntryCell entry = EntryCell::GetEntryCellForTest(cell_num, hash, addr, NULL,
-                                                     small_table);
+    EntryCell entry =
+        EntryCell::GetEntryCellForTest(cell_num, hash, addr, NULL, small_table);
     EXPECT_EQ(disk_cache::ENTRY_NO_USE, entry.GetGroup());
     EXPECT_EQ(disk_cache::ENTRY_NEW, entry.GetState());
 
     entry.SetGroup(group);
     entry.SetState(state);
     entry.SetReuse(reuse);
     entry.SetTimestamp(timestamp);
 
     EXPECT_TRUE(entry.IsValid());
     EXPECT_EQ(hash, entry.hash());
     EXPECT_EQ(cell_num, entry.cell_num());
     EXPECT_EQ(addr.value(), entry.GetAddress().value());
 
     EXPECT_EQ(group, entry.GetGroup());
     EXPECT_EQ(state, entry.GetState());
     EXPECT_EQ(reuse, entry.GetReuse());
     EXPECT_EQ(timestamp, entry.GetTimestamp());
 
     // Store the data and read it again.
     IndexCell cell;
     entry.SerializaForTest(&cell);
 
-    EntryCell entry2 = EntryCell::GetEntryCellForTest(cell_num, hash, addr,
-                                                      &cell, small_table);
+    EntryCell entry2 = EntryCell::GetEntryCellForTest(
+        cell_num, hash, addr, &cell, small_table);
 
     EXPECT_EQ(addr.value(), entry2.GetAddress().value());
 
     EXPECT_EQ(group, entry2.GetGroup());
     EXPECT_EQ(state, entry2.GetState());
     EXPECT_EQ(reuse, entry2.GetReuse());
     EXPECT_EQ(timestamp, entry2.GetTimestamp());
 
     small_table = !small_table;
     if (i == 1) {
       hash = ~hash;
       cell_num *= 5;
       state = disk_cache::ENTRY_USED;
       group = disk_cache::ENTRY_EVICTED;
       addr = disk_cache::Addr(disk_cache::BLOCK_EVICTED, 1, 6, 0x18a5);
-      reuse = 15;  // 4 bits
+      reuse = 15;           // 4 bits
       timestamp = 0xfffff;  // 20 bits.
     }
   }
 }
 
 // Goes over some significant values for a cell's sum.
 TEST(DiskCacheIndexTable, EntryCellSum) {
   IndexCell source;
   source.Clear();
   EXPECT_EQ(0, GetChecksum(source));
@@ skipping 61 matching lines @@
 
   // Write some entries.
   disk_cache::CellList entries;
   for (int i = 0; i < 250; i++) {
     SCOPED_TRACE(i);
     uint32 hash = i * i * 1111 + i * 11;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
-    disk_cache::CellInfo info = { hash, addr };
+    disk_cache::CellInfo info = {hash, addr};
     entries.push_back(info);
   }
 
   // Read them back.
   for (size_t i = 0; i < entries.size(); i++) {
     SCOPED_TRACE(i);
     uint32 hash = entries[i].hash;
     disk_cache::Addr addr = entries[i].address;
 
     disk_cache::EntrySet found_entries = index.LookupEntries(hash);
@@ skipping 40 matching lines @@
   index.Init(&init_data);
 
   disk_cache::CellList entries;
   uint32 hash = 0x55aa55bb;
   for (int i = 0; i < 6; i++) {
     SCOPED_TRACE(i);
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
-    disk_cache::CellInfo info = { hash, addr };
+    disk_cache::CellInfo info = {hash, addr};
     entries.push_back(info);
   }
 
   disk_cache::EntrySet found_entries = index.LookupEntries(hash);
   EXPECT_EQ(0, found_entries.evicted_count);
   ASSERT_EQ(6u, found_entries.cells.size());
 
   for (size_t i = 0; i < found_entries.cells.size(); i++) {
     SCOPED_TRACE(i);
     EXPECT_EQ(entries[i].address, found_entries.cells[i].GetAddress());
@@ skipping 120 matching lines @@
   for (int i = 0; i < 44; i++) {
     SCOPED_TRACE(i);
     uint32 hash = i;  // The entries will be ordered on the table.
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 13 + 1);
     if (i < 10 || i == 40)
       addr = disk_cache::Addr(disk_cache::BLOCK_EVICTED, 1, 6, i * 13 + 1);
 
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
-    disk_cache::CellInfo info = { hash, addr };
+    disk_cache::CellInfo info = {hash, addr};
     entries.push_back(info);
 
     if (i < 10 || i == 40) {
       // Do nothing. These are ENTRY_EVICTED by default.
     } else if (i < 20 || i == 41) {
       entry.SetGroup(disk_cache::ENTRY_HIGH_USE);
       index.Save(&entry);
     } else if (i < 30 || i == 42) {
       entry.SetGroup(disk_cache::ENTRY_LOW_USE);
       index.Save(&entry);
@@ skipping 94 matching lines @@
     index.Init(&init_data);
 
     // Write some entries.
     for (int i = 0; i < 250; i++, entry_id++) {
       SCOPED_TRACE(entry_id);
       uint32 hash = entry_id * i * 321 + entry_id * 13;
       disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, entry_id * 17 + 1);
       EntryCell entry = index.CreateEntryCell(hash, addr);
       EXPECT_TRUE(entry.IsValid());
 
-      disk_cache::CellInfo info = { hash, addr };
+      disk_cache::CellInfo info = {hash, addr};
       entries.push_back(info);
     }
     size *= 2;
   }
 
   // Access all the entries.
   for (size_t i = 0; i < entries.size(); i++) {
     SCOPED_TRACE(i);
     disk_cache::EntrySet found_entries = index.LookupEntries(entries[i].hash);
     ASSERT_EQ(1u, found_entries.cells.size());
@@ skipping 13 matching lines @@
   index.Init(&init_data);
 
   // Write some entries.
   for (int i = 0; i < 8; i++) {
     SCOPED_TRACE(i);
     uint32 hash = i * 256;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 7 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
-    disk_cache::CellInfo info = { hash, addr };
+    disk_cache::CellInfo info = {hash, addr};
     entries.push_back(info);
   }
 
   // Double the size.
   scoped_ptr<TestCacheTables> old_cache(cache.Pass());
   cache.reset(new TestCacheTables(size * 2));
   cache.get()->CopyFrom(*old_cache.get());
 
   cache.get()->GetInitData(&init_data);
   index.Init(&init_data);
 
   // Write more entries, starting with the upper half of the table.
   for (int i = 9; i < 11; i++) {
     SCOPED_TRACE(i);
     uint32 hash = i * 256;
     disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, i * 7 + 1);
     EntryCell entry = index.CreateEntryCell(hash, addr);
     EXPECT_TRUE(entry.IsValid());
 
-    disk_cache::CellInfo info = { hash, addr };
+    disk_cache::CellInfo info = {hash, addr};
     entries.push_back(info);
   }
 
   // Access all the entries.
   for (size_t i = 0; i < entries.size(); i++) {
     SCOPED_TRACE(i);
     disk_cache::EntrySet found_entries = index.LookupEntries(entries[i].hash);
     ASSERT_EQ(1u, found_entries.cells.size());
     EXPECT_TRUE(found_entries.cells[0].IsValid());
   }
@@ skipping 32 matching lines @@
 
   uint32 hash = 0;
   disk_cache::Addr addr(disk_cache::BLOCK_ENTRIES, 1, 5, 6);
   EntryCell entry = index.CreateEntryCell(hash, addr);
   EXPECT_TRUE(entry.IsValid());
 
   index.OnBackupTimer();
   int expected = (1024 + 512) / 8 + sizeof(disk_cache::IndexHeaderV3);
   EXPECT_EQ(expected, backend.buffer_len());
 }