Port some unit tests from chrome/browser/

chrome/browser/history/history_querying_unittest.cc

 // Copyright (c) 2006-2008 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/file_util.h"
 #include "base/path_service.h"
 #include "chrome/browser/history/history.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 78 matching lines @@
     file_util::CreateDirectory(history_dir_);
 
     history_ = new HistoryService;
     if (!history_->Init(FilePath::FromWStringHack(history_dir_), NULL)) {
       history_ = NULL;  // Tests should notice this NULL ptr & fail.
       return;
     }
 
     // Fill the test data.
     Time now = Time::Now().LocalMidnight();
-    for (int i = 0; i < arraysize(test_entries); i++) {
+    for (size_t i = 0; i < arraysize(test_entries); i++) {
       test_entries[i].time =
           now - (test_entries[i].days_ago * TimeDelta::FromDays(1));
 
       // We need the ID scope and page ID so that the visit tracker can find it.
       const void* id_scope = reinterpret_cast<void*>(1);
       int32 page_id = i;
       GURL url(test_entries[i].url);
 
       history_->AddPage(url, test_entries[i].time, id_scope, page_id, GURL(),
                         PageTransition::LINK, HistoryService::RedirectList());
@@ skipping 11 matching lines @@
     }
     file_util::Delete(history_dir_, true);
   }
 
   void QueryHistoryComplete(HistoryService::Handle, QueryResults* results) {
     results->Swap(&last_query_results_);
     MessageLoop::current()->Quit();  // Will return out to QueryHistory.
   }
 
   MessageLoop message_loop_;
-  
+
   std::wstring history_dir_;
 
   CancelableRequestConsumer consumer_;
 
   // The QueryHistoryComplete callback will put the results here so QueryHistory
   // can return them.
   QueryResults last_query_results_;
 
   DISALLOW_EVIL_CONSTRUCTORS(HistoryQueryTest);
 };
 
 TEST_F(HistoryQueryTest, Basic) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // First query for all of them to make sure they are there and in
   // chronological order, most recent first.
   QueryHistory(std::wstring(), options, &results);
-  ASSERT_EQ(5, results.size());
+  ASSERT_EQ(5U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 4));
   EXPECT_TRUE(NthResultIs(results, 1, 2));
   EXPECT_TRUE(NthResultIs(results, 2, 3));
   EXPECT_TRUE(NthResultIs(results, 3, 1));
   EXPECT_TRUE(NthResultIs(results, 4, 0));
 
   // Next query a time range. The beginning should be inclusive, the ending
   // should be exclusive.
   options.begin_time = test_entries[3].time;
   options.end_time = test_entries[2].time;
   QueryHistory(std::wstring(), options, &results);
-  EXPECT_EQ(1, results.size());
+  EXPECT_EQ(1U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 3));
 }
 
 // Tests max_count feature for basic (non-Full Text Search) queries.
 TEST_F(HistoryQueryTest, BasicCount) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // Query all time but with a limit on the number of entries. We should
   // get the N most recent entries.
   options.max_count = 2;
   QueryHistory(std::wstring(), options, &results);
-  EXPECT_EQ(2, results.size());
+  EXPECT_EQ(2U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 4));
   EXPECT_TRUE(NthResultIs(results, 1, 2));
 }
 
 // Tests duplicate collapsing and not in non-Full Text Search situations.
 TEST_F(HistoryQueryTest, BasicDupes) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // We did the query for no collapsing in the "Basic" test above, so here we
   // only test collapsing.
   options.most_recent_visit_only = true;
   QueryHistory(std::wstring(), options, &results);
-  EXPECT_EQ(4, results.size());
+  EXPECT_EQ(4U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 4));
   EXPECT_TRUE(NthResultIs(results, 1, 2));
   EXPECT_TRUE(NthResultIs(results, 2, 3));
   EXPECT_TRUE(NthResultIs(results, 3, 1));
 }
 
 // This does most of the same tests above, but searches for a FTS string that
 // will match the pages in question. This will trigger a different code path.
 TEST_F(HistoryQueryTest, FTS) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // Query all of them to make sure they are there and in order. Note that
   // this query will return the starred item twice since we requested all
   // starred entries and no de-duping.
   QueryHistory(std::wstring(L"some"), options, &results);
-  EXPECT_EQ(3, results.size());
+  EXPECT_EQ(3U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 2));
   EXPECT_TRUE(NthResultIs(results, 1, 3));
   EXPECT_TRUE(NthResultIs(results, 2, 1));
 
   // Do a query that should only match one of them.
   QueryHistory(std::wstring(L"PAGETWO"), options, &results);
-  EXPECT_EQ(1, results.size());
+  EXPECT_EQ(1U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 3));
 
   // Next query a time range. The beginning should be inclusive, the ending
   // should be exclusive.
   options.begin_time = test_entries[1].time;
   options.end_time = test_entries[3].time;
   QueryHistory(std::wstring(L"some"), options, &results);
-  EXPECT_EQ(1, results.size());
+  EXPECT_EQ(1U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 1));
 }
 
 // Searches titles.
 TEST_F(HistoryQueryTest, FTSTitle) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // Query all time but with a limit on the number of entries. We should
   // get the N most recent entries.
   QueryHistory(std::wstring(L"title"), options, &results);
-  EXPECT_EQ(3, results.size());
+  EXPECT_EQ(3U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 2));
   EXPECT_TRUE(NthResultIs(results, 1, 3));
   EXPECT_TRUE(NthResultIs(results, 2, 1));
 }
 
 // Tests prefix searching for Full Text Search queries.
 TEST_F(HistoryQueryTest, FTSPrefix) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // Query with a prefix search.  Should return matches for "PAGETWO" and
   // "PAGETHREE".
   QueryHistory(std::wstring(L"PAGET"), options, &results);
-  EXPECT_EQ(2, results.size());
+  EXPECT_EQ(2U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 2));
   EXPECT_TRUE(NthResultIs(results, 1, 3));
 }
 
 // Tests max_count feature for Full Text Search queries.
 TEST_F(HistoryQueryTest, FTSCount) {
   ASSERT_TRUE(history_.get());
 
   QueryOptions options;
   QueryResults results;
 
   // Query all time but with a limit on the number of entries. We should
   // get the N most recent entries.
   options.max_count = 2;
   QueryHistory(std::wstring(L"some"), options, &results);
-  EXPECT_EQ(2, results.size());
+  EXPECT_EQ(2U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 2));
   EXPECT_TRUE(NthResultIs(results, 1, 3));
 
   // Now query a subset of the pages and limit by N items. "FOO" should match
   // the 2nd & 3rd pages, but we should only get the 3rd one because of the one
   // page max restriction.
   options.max_count = 1;
   QueryHistory(std::wstring(L"FOO"), options, &results);
-  EXPECT_EQ(1, results.size());
+  EXPECT_EQ(1U, results.size());
   EXPECT_TRUE(NthResultIs(results, 0, 3));
 }
 
 // Tests that FTS queries can find URLs when they exist only in the archived
 // database. This also tests that imported URLs can be found, since we use
 // AddPageWithDetails just like the importer.
 TEST_F(HistoryQueryTest, FTSArchived) {
   ASSERT_TRUE(history_.get());
 
   std::vector<URLRow> urls_to_add;
@@ skipping 10 matching lines @@
 
   history_->AddPagesWithDetails(urls_to_add);
 
   QueryOptions options;
   QueryResults results;
 
   // Query all time. The title we get should be the one in the full text
   // database and not the most current title (since otherwise highlighting in
   // the title might be wrong).
   QueryHistory(std::wstring(L"archived"), options, &results);
-  ASSERT_EQ(1, results.size());
+  ASSERT_EQ(1U, results.size());
   EXPECT_TRUE(row1.url() == results[0].url());
   EXPECT_TRUE(row1.title() == results[0].title());
 }
 
 /* TODO(brettw) re-enable this. It is commented out because the current history
    code prohibits adding more than one indexed page with the same URL. When we
    have tiered history, there could be a dupe in the archived history which
    won't get picked up by the deletor and it can happen again. When this is the
    case, we should fix this test to duplicate that situation.
 
@@ skipping 12 matching lines @@
 
   // Now with collapsing.
   options.most_recent_visit_only = true;
   QueryHistory(std::wstring(L"Other"), options, &results);
   EXPECT_EQ(1, results.urls().size());
   EXPECT_TRUE(NthResultIs(results, 0, 4));
 }
 */
 
 }  // namespace history