Update from https://crrev.com/306655

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 10 matching lines @@
 #include "net/disk_cache/simple/simple_index_file.h"
 #include "net/disk_cache/simple/simple_test_util.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace disk_cache {
 namespace {
 
 const base::Time kTestLastUsedTime =
     base::Time::UnixEpoch() + base::TimeDelta::FromDays(20);
-const int kTestEntrySize = 789;
+const uint64 kTestEntrySize = 789;
 
 }  // namespace
 
 
 class EntryMetadataTest  : public testing::Test {
  public:
   EntryMetadata NewEntryMetadataWithValues() {
     return EntryMetadata(kTestLastUsedTime, kTestEntrySize);
   }
 
@@ skipping 122 matching lines @@
   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;
   EXPECT_EQ(base::Time(), entry_metadata.GetLastUsedTime());
-  EXPECT_EQ(0, entry_metadata.GetEntrySize());
+  EXPECT_EQ(0U, entry_metadata.GetEntrySize());
 
   entry_metadata = NewEntryMetadataWithValues();
   CheckEntryMetadataValues(entry_metadata);
 
   const base::Time new_time = base::Time::Now();
   entry_metadata.SetLastUsedTime(new_time);
 
   EXPECT_LT(new_time - base::TimeDelta::FromSeconds(2),
             entry_metadata.GetLastUsedTime());
   EXPECT_GT(new_time + base::TimeDelta::FromSeconds(2),
@@ skipping 39 matching lines @@
     index()->MergeInitializingSet(result.Pass());
   }
   EXPECT_EQ(2U + 3U + 4U + 11U, index()->cache_size_);
 }
 
 // State of index changes as expected with an insert and a remove.
 TEST_F(SimpleIndexTest, BasicInsertRemove) {
   // Confirm blank state.
   EntryMetadata metadata;
   EXPECT_EQ(base::Time(), metadata.GetLastUsedTime());
-  EXPECT_EQ(0, metadata.GetEntrySize());
+  EXPECT_EQ(0U, metadata.GetEntrySize());
 
   // Confirm state after insert.
   index()->Insert(hashes_.at<1>());
   ASSERT_TRUE(GetEntryForTesting(hashes_.at<1>(), &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());
+  EXPECT_EQ(0U, metadata.GetEntrySize());
 
   // Confirm state after remove.
   metadata = EntryMetadata();
   index()->Remove(hashes_.at<1>());
   EXPECT_FALSE(GetEntryForTesting(hashes_.at<1>(), &metadata));
   EXPECT_EQ(base::Time(), metadata.GetLastUsedTime());
-  EXPECT_EQ(0, metadata.GetEntrySize());
+  EXPECT_EQ(0U, metadata.GetEntrySize());
 }
 
 TEST_F(SimpleIndexTest, Has) {
   // Confirm the base index has dispatched the request for index entries.
   EXPECT_TRUE(index_file_.get());
   EXPECT_EQ(1, index_file_->load_index_entries_calls());
 
   // Confirm "Has()" always returns true before the callback is called.
   const uint64 kHash1 = hashes_.at<1>();
   EXPECT_TRUE(index()->Has(kHash1));
@@ skipping 63 matching lines @@
   ReturnIndexFile();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(kHash1, &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(475, metadata.GetEntrySize());
+  EXPECT_EQ(475U, metadata.GetEntrySize());
 
   index()->UpdateEntrySize(kHash1, 600u);
   EXPECT_TRUE(GetEntryForTesting(kHash1, &metadata));
-  EXPECT_EQ(600, metadata.GetEntrySize());
+  EXPECT_EQ(600U, metadata.GetEntrySize());
   EXPECT_EQ(1, index()->GetEntryCount());
 }
 
 TEST_F(SimpleIndexTest, GetEntryCount) {
   EXPECT_EQ(0, index()->GetEntryCount());
   index()->Insert(hashes_.at<1>());
   EXPECT_EQ(1, index()->GetEntryCount());
   index()->Insert(hashes_.at<2>());
   EXPECT_EQ(2, index()->GetEntryCount());
   index()->Insert(hashes_.at<3>());
@@ skipping 28 matching lines @@
   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_EQ(10U, 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());
+  EXPECT_EQ(100U, 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);
@@ skipping 11 matching lines @@
   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());
+  EXPECT_EQ(0U, 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),
@@ skipping 12 matching lines @@
   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());
+  EXPECT_EQ(0U, 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),
@@ skipping 17 matching lines @@
                             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());
+  EXPECT_EQ(0U, metadata.GetEntrySize());
 
   EXPECT_FALSE(index()->Has(hashes_.at<3>()));
 
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<4>(), &metadata));
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
-  EXPECT_EQ(0, metadata.GetEntrySize());
+  EXPECT_EQ(0U, metadata.GetEntrySize());
 
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<5>(), &metadata));
 
   EXPECT_GT(
       now - base::TimeDelta::FromDays(6) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_LT(
       now - base::TimeDelta::FromDays(6) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
 
-  EXPECT_EQ(100000, metadata.GetEntrySize());
+  EXPECT_EQ(100000U, 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);
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 475);
@@ skipping 68 matching lines @@
   SimpleIndex::EntrySet entry_set;
   index_file_->GetAndResetDiskWriteEntrySet(&entry_set);
 
   uint64 hash_key = kHash1;
   base::Time now(base::Time::Now());
   ASSERT_EQ(1u, entry_set.size());
   EXPECT_EQ(hash_key, entry_set.begin()->first);
   const EntryMetadata& entry1(entry_set.begin()->second);
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
-  EXPECT_EQ(20, entry1.GetEntrySize());
+  EXPECT_EQ(20U, entry1.GetEntrySize());
 }
 
 TEST_F(SimpleIndexTest, DiskWritePostponed) {
   index()->SetMaxSize(1000);
   ReturnIndexFile();
 
   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
 
   index()->Insert(hashes_.at<1>());
   index()->UpdateEntrySize(hashes_.at<1>(), 20);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   base::TimeTicks expected_trigger(
       index()->write_to_disk_timer_.desired_run_time());
 
   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