downloads.query: parse numerical query properties as double, not int.

chrome/browser/download/download_query_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/download/download_query.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 20 matching lines @@
 using base::Value;
 using content::DownloadItem;
 typedef DownloadQuery::DownloadVector DownloadVector;
 
 namespace {
 
 static const int kSomeKnownTime = 1355864160;
 static const char kSomeKnownTime8601[] = "2012-12-18T20:56:0";
 static const char k8601Suffix[] = ".000Z";
 
+static const int64_t kEightGB = 1LL << 33;
+static const int64_t kSixteenGB = 1LL << 34;
+static const double kEightGBDouble = 8.0 * (1LL << 30);
+static const double kNineGBDouble = 9.0 * (1LL << 30);
+
 bool IdNotEqual(uint32_t not_id, const DownloadItem& item) {
   return item.GetId() != not_id;
 }
 
 bool AlwaysReturn(bool result, const DownloadItem& item) {
   return result;
 }
 
 }  // anonymous namespace
 
@@ skipping 51 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DownloadQueryTest);
 };
 
 template<> void DownloadQueryTest::AddFilter(
     DownloadQuery::FilterType name, bool cpp_value) {
   std::unique_ptr<base::Value> value(new base::FundamentalValue(cpp_value));
   CHECK(query_.AddFilter(name, *value.get()));
 }
 
-template<> void DownloadQueryTest::AddFilter(
-    DownloadQuery::FilterType name, int cpp_value) {
+template <>
+void DownloadQueryTest::AddFilter(DownloadQuery::FilterType name,
+                                  double cpp_value) {
   std::unique_ptr<base::Value> value(new base::FundamentalValue(cpp_value));
   CHECK(query_.AddFilter(name, *value.get()));
 }
 
 template<> void DownloadQueryTest::AddFilter(
     DownloadQuery::FilterType name, const char* cpp_value) {
   CHECK(query_.AddFilter(name, base::StringValue(cpp_value)));
 }
 
 template<> void DownloadQueryTest::AddFilter(
@@ skipping 198 matching lines @@
 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterCallback) {
   CreateMocks(2);
   CHECK(query()->AddFilter(base::Bind(&IdNotEqual, 1)));
   ExpectStandardFilterResults();
 }
 
 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterBytesReceived) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(1));
-  AddFilter(DownloadQuery::FILTER_BYTES_RECEIVED, 0);
+  AddFilter(DownloadQuery::FILTER_BYTES_RECEIVED, 0.0);
   ExpectStandardFilterResults();
 }
 
 TEST_F(DownloadQueryTest, DownloadQueryTest_SortBytesReceived) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(1));
   query()->AddSorter(DownloadQuery::SORT_BYTES_RECEIVED,
                      DownloadQuery::DESCENDING);
   ExpectSortInverted();
@@ skipping 152 matching lines @@
 TEST_F(DownloadQueryTest, DownloadQueryTest_SortEndTime) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetEndTime()).WillRepeatedly(Return(
       base::Time::FromTimeT(kSomeKnownTime + 2)));
   EXPECT_CALL(mock(1), GetEndTime()).WillRepeatedly(Return(
       base::Time::FromTimeT(kSomeKnownTime + 4)));
   query()->AddSorter(DownloadQuery::SORT_END_TIME, DownloadQuery::DESCENDING);
   ExpectSortInverted();
 }
 
-TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater) {
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater1) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(1));
-  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1);
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1.0);
   ExpectStandardFilterResults();
 }
 
-TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess) {
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater2) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(1));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1.2);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater3) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(kSixteenGB));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(kEightGB));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, kNineGBDouble);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater4) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(kSixteenGB));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(kEightGB));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, kEightGBDouble + 1.0);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess1) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
-  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4);
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4.0);
   ExpectStandardFilterResults();
 }
 
-TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytes) {
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess2) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(1));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(2));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 1.2);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess3) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(kEightGB));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(kSixteenGB));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, kEightGBDouble + 1.0);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess4) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(kEightGB));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(kSixteenGB));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, kNineGBDouble);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytes1) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
-  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2);
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2.0);
   ExpectStandardFilterResults();
 }
 
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytes2) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(1));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(2));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 1.0);
+  ExpectStandardFilterResults();
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytes3) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(kEightGB));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(kSixteenGB));
+  AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, kEightGBDouble);
+  ExpectStandardFilterResults();
+}
+
 TEST_F(DownloadQueryTest, DownloadQueryTest_SortTotalBytes) {
   CreateMocks(2);
   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
   query()->AddSorter(DownloadQuery::SORT_TOTAL_BYTES,
                      DownloadQuery::DESCENDING);
   ExpectSortInverted();
 }
 
 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterState) {
@@ skipping 71 matching lines @@
   base::Time start = base::Time::Now();
   Search();
   base::Time end = base::Time::Now();
   double nanos = (end - start).InMillisecondsF() * 1000.0 * 1000.0;
   double nanos_per_item = nanos / static_cast<double>(kNumItems);
   double nanos_per_item_per_filter = nanos_per_item
     / static_cast<double>(kNumFilters);
   std::cout << "Search took " << nanos_per_item_per_filter
             << " nanoseconds per item per filter.\n";
 }