DownloadQuery filters and sorts DownloadItems.

content/browser/download/download_query_unittest.cc

Index: content/browser/download/download_query_unittest.cc
diff --git a/content/browser/download/download_query_unittest.cc b/content/browser/download/download_query_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ed5f9d15b144b13542f9429d9ba4a22b145a2d46
--- /dev/null
+++ b/content/browser/download/download_query_unittest.cc
@@ -0,0 +1,394 @@
+// Copyright (c) 2011 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 <string>
+
+#include "base/bind.h"
+#include "base/file_path.h"
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "base/time.h"
+#include "base/values.h"
+#include "content/browser/download/download_query.h"
+#include "content/browser/download/mock_download_item.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::_;
+using base::Time;
+using base::Value;
+typedef DownloadQuery::DownloadVector DownloadVector;
+
+namespace {
+
+bool IdNotEqual(int not_id, const DownloadItem& item) {
+  return item.GetId() != not_id;
+}
+
+bool AlwaysReturn(bool result, const DownloadItem& item) {
+  return result;
+}
+
+}  // anonymous namespace
+
+class DownloadQueryTest : public testing::Test {
+ public:
+  DownloadQueryTest() {}
+
+  virtual ~DownloadQueryTest() {}
+
+  virtual void TearDown() {
+    STLDeleteElements(&mocks_);
+  }
+
+  void CreateMocks(int count) {
+    for (int i = 0; i < count; ++i) {
+      mocks_.push_back(new MockDownloadItem());
+    }
+  }
+
+  MockDownloadItem& mock(int index) { return *mocks_[index]; }
+
+  DownloadQuery* query() { return &query_; }
+
+  template<typename ValueType> void AddFilter(
+      DownloadQuery::FilterType name, ValueType value);
+
+  void Search() {
+    query_.Search(mocks_.begin(), mocks_.end(), &results_);
+  }
+
+  DownloadVector* results() { return &results_; }
+
+ private:
+  std::vector<MockDownloadItem*> mocks_;
+  DownloadQuery query_;
+  DownloadVector results_;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadQueryTest);
+};
+
+template<> void DownloadQueryTest::AddFilter(
+    DownloadQuery::FilterType name, bool value) {
+  CHECK(query_.AddFilter(name, Value::CreateBooleanValue(value)));
+}
+
+template<> void DownloadQueryTest::AddFilter(
+    DownloadQuery::FilterType name, int value) {
+  CHECK(query_.AddFilter(name, Value::CreateIntegerValue(value)));
+}
+
+template<> void DownloadQueryTest::AddFilter(
+    DownloadQuery::FilterType name, const char* value) {
+  CHECK(query_.AddFilter(name, Value::CreateStringValue(value)));
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryEmptyNoItems) {
+  Search();
+  EXPECT_EQ(0U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryEmptySomeItems) {
+  CreateMocks(3);
+  Search();
+  EXPECT_EQ(3U, results()->size());
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryInvalidFilters) {
+  EXPECT_FALSE(query()->AddFilter(
+      DownloadQuery::FILTER_BYTES_RECEIVED, NULL));
+  EXPECT_FALSE(query()->AddFilter(
+      static_cast<DownloadQuery::FilterType>(kint32max),
+      Value::CreateIntegerValue(0)));
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryLimit) {
+  CreateMocks(2);
+  query()->Limit(1);
+  Search();
+  EXPECT_EQ(1U, results()->size());
+}
+
+#define SWITCH2(_index, _col1, _ret1, _default) \

[Randy Smith (Not in Mondays), 2011/12/12 18:17:54]

nit: A sentence or two of comment documentation?

[benjhayden, 2011/12/12 19:52:10]

Done.

+  ((_index == (_col1)) ? _ret1 : _default)
+#define SWITCH3(_index, _col1, _ret1, _col2, _ret2, _default) \
+  SWITCH2(_index, _col1, _ret1, SWITCH2(_index, _col2, _ret2, _default))
+#define SWITCH4(_index, _col1, _ret1, _col2, _ret2, _col3, _ret3, _default) \
+  SWITCH3(_index, _col1, _ret1, _col2, _ret2, \
+      SWITCH2(_index, _col3, _ret3, _default))
+
+TEST_F(DownloadQueryTest, DownloadQueryAllFilters) {
+  // Set up mocks such that only mock(0) matches all filters, and every other
+  // mock fails a different filter (or two for GREATER/LESS filters).
+  static const size_t kNumItems = 19;
+  CreateMocks(kNumItems);
+  FilePath refail_filename("z");
+  FilePath fail_filename("fail");
+  FilePath match_filename("match");
+  GURL refail_url("http://z.com/");
+  GURL fail_url("http://example.com/fail");
+  GURL match_url("http://example.com/match");
+  // Picture a 2D matrix. The rows are MockDownloadItems and the columns are
+  // methods. Every cell contains a value that matches the filters, except for
+  // the diagonal. Every item matches all the filters except one filter, which
+  // it fails, except one item, which matches all the filters without exception.

[Randy Smith (Not in Mondays), 2011/12/12 18:17:54]

This comment doesn't match (to me, at least) with the existence of
SWITCH3/4--those macros make it sound like, at least for a few of these, you're
doing something more complex.  Put in comments explaining the complexity?  

[benjhayden, 2011/12/12 19:52:10]

Done.

+  for (size_t i = 0; i < kNumItems; ++i) {
+    EXPECT_CALL(mock(i), GetId()).WillRepeatedly(Return(i));
+    EXPECT_CALL(mock(i), GetReceivedBytes()).WillRepeatedly(Return(SWITCH2(i,
+        1, 2,
+           1)));
+    EXPECT_CALL(mock(i), GetSafetyState()).WillRepeatedly(Return(SWITCH2(i,
+        2, DownloadItem::DANGEROUS,
+           DownloadItem::DANGEROUS_BUT_VALIDATED)));
+    EXPECT_CALL(mock(i), GetFullPath()).WillRepeatedly(ReturnRef(SWITCH3(i,
+        3, refail_filename,
+        4, fail_filename,
+           match_filename)));
+    EXPECT_CALL(mock(i), GetMimeType()).WillRepeatedly(Return(SWITCH2(i,
+        5, "image",
+           "text")));
+    EXPECT_CALL(mock(i), IsPaused()).WillRepeatedly(Return(SWITCH2(i,
+        6, false,
+           true)));
+    EXPECT_CALL(mock(i), MatchesQuery(_)).WillRepeatedly(Return(SWITCH2(i,
+        7, false,
+           true)));
+    EXPECT_CALL(mock(i), GetStartTime()).WillRepeatedly(Return(SWITCH4(i,
+        8,  base::Time::FromTimeT(1),
+        9,  base::Time::FromTimeT(4),
+        10, base::Time::FromTimeT(3),
+            base::Time::FromTimeT(2))));
+    EXPECT_CALL(mock(i), GetTotalBytes()).WillRepeatedly(Return(SWITCH4(i,
+        11, 1,
+        12, 4,
+        13, 3,
+            2)));
+    EXPECT_CALL(mock(i), GetOriginalUrl()).WillRepeatedly(ReturnRef(SWITCH3(i,
+        14, refail_url,
+        15, fail_url,
+            match_url)));
+    EXPECT_CALL(mock(i), GetState()).WillRepeatedly(Return(SWITCH2(i,
+        17, DownloadItem::CANCELLED,
+            DownloadItem::IN_PROGRESS)));
+    EXPECT_CALL(mock(i), GetDangerType()).WillRepeatedly(Return(SWITCH2(i,
+        18, DownloadStateInfo::DANGEROUS_FILE,
+            DownloadStateInfo::NOT_DANGEROUS)));
+  }
+  for (size_t i = 0; i < kNumItems; ++i) {
+    switch (i) {
+      case 0: break;
+      case 1: AddFilter(DownloadQuery::FILTER_BYTES_RECEIVED, 1); break;
+      case 2: AddFilter(DownloadQuery::FILTER_DANGER_ACCEPTED, true);
+              break;
+      case 3: AddFilter(DownloadQuery::FILTER_FILENAME_REGEX, "a"); break;
+      case 4: AddFilter(DownloadQuery::FILTER_FILENAME,
+                        match_filename.value().c_str()); break;
+      case 5: AddFilter(DownloadQuery::FILTER_MIME, "text"); break;
+      case 6: AddFilter(DownloadQuery::FILTER_PAUSED, true); break;
+      case 7: AddFilter(DownloadQuery::FILTER_QUERY, ""); break;
+      case 8: AddFilter(DownloadQuery::FILTER_STARTED_AFTER, 1000); break;
+      case 9: AddFilter(DownloadQuery::FILTER_STARTED_BEFORE, 4000);
+              break;
+      case 10: AddFilter(DownloadQuery::FILTER_START_TIME, 2000); break;
+      case 11: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1);
+               break;
+      case 12: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4);
+               break;
+      case 13: AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2); break;
+      case 14: AddFilter(DownloadQuery::FILTER_URL_REGEX, "example");
+               break;
+      case 15: AddFilter(DownloadQuery::FILTER_URL,
+                         match_url.spec().c_str()); break;
+      case 16: CHECK(query()->AddFilter(base::Bind(&IdNotEqual, 16))); break;
+      case 17: query()->AddFilter(DownloadItem::IN_PROGRESS); break;
+      case 18: query()->AddFilter(DownloadStateInfo::NOT_DANGEROUS); break;
+      default: NOTREACHED(); break;
+    }
+    Search();
+    ASSERT_EQ(kNumItems - i, results()->size())
+      << "Failing filter: " << i;
+    if (i > 0) {
+      ASSERT_EQ(0, results()->at(0)->GetId())
+        << "Failing filter: " << i;
+      for (size_t j = 1; j < kNumItems - i; ++j) {
+        ASSERT_EQ(static_cast<int32>(j + i), results()->at(j)->GetId())
+          << "Failing filter: " << i;
+      }
+    }
+  }
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortBytesReceived) {
+  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);
+  Search();
+  EXPECT_EQ(1, results()->at(0)->GetReceivedBytes());
+  EXPECT_EQ(0, results()->at(1)->GetReceivedBytes());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortDanger) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetDangerType()).WillRepeatedly(Return(
+        DownloadStateInfo::DANGEROUS_FILE));
+  EXPECT_CALL(mock(1), GetDangerType()).WillRepeatedly(Return(
+        DownloadStateInfo::NOT_DANGEROUS));
+  query()->AddSorter(
+      DownloadQuery::SORT_DANGER, DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(DownloadStateInfo::NOT_DANGEROUS,
+            results()->at(0)->GetDangerType());
+  EXPECT_EQ(DownloadStateInfo::DANGEROUS_FILE,
+            results()->at(1)->GetDangerType());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortDangerAccepted) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetSafetyState()).WillRepeatedly(Return(
+        DownloadItem::DANGEROUS));
+  EXPECT_CALL(mock(1), GetSafetyState()).WillRepeatedly(Return(
+        DownloadItem::DANGEROUS_BUT_VALIDATED));
+  query()->AddSorter(
+      DownloadQuery::SORT_DANGER_ACCEPTED, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ(DownloadItem::DANGEROUS_BUT_VALIDATED,
+            results()->at(0)->GetSafetyState());
+  EXPECT_EQ(DownloadItem::DANGEROUS, results()->at(1)->GetSafetyState());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortFilename) {
+  CreateMocks(2);
+  FilePath a_filename("a");
+  FilePath b_filename("b");
+  EXPECT_CALL(mock(0), GetFullPath()).WillRepeatedly(ReturnRef(b_filename));
+  EXPECT_CALL(mock(1), GetFullPath()).WillRepeatedly(ReturnRef(a_filename));
+  query()->AddSorter(
+      DownloadQuery::SORT_FILENAME, DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(a_filename, results()->at(0)->GetFullPath());
+  EXPECT_EQ(b_filename, results()->at(1)->GetFullPath());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortMime) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetMimeType()).WillRepeatedly(Return("a"));
+  EXPECT_CALL(mock(1), GetMimeType()).WillRepeatedly(Return("b"));
+  query()->AddSorter(
+      DownloadQuery::SORT_MIME, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ("b", results()->at(0)->GetMimeType());
+  EXPECT_EQ("a", results()->at(1)->GetMimeType());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortPaused) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), IsPaused()).WillRepeatedly(Return(true));
+  EXPECT_CALL(mock(1), IsPaused()).WillRepeatedly(Return(false));
+  query()->AddSorter(
+      DownloadQuery::SORT_PAUSED, DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(false, results()->at(0)->IsPaused());
+  EXPECT_EQ(true, results()->at(1)->IsPaused());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortStartTime) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetStartTime()).WillRepeatedly(Return(
+        base::Time::FromTimeT(0)));
+  EXPECT_CALL(mock(1), GetStartTime()).WillRepeatedly(Return(
+        base::Time::FromTimeT(1)));
+  query()->AddSorter(
+      DownloadQuery::SORT_START_TIME, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ(base::Time::FromTimeT(1), results()->at(0)->GetStartTime());
+  EXPECT_EQ(base::Time::FromTimeT(0), results()->at(1)->GetStartTime());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortState) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetState()).WillRepeatedly(Return(
+        DownloadItem::IN_PROGRESS));
+  EXPECT_CALL(mock(1), GetState()).WillRepeatedly(Return(
+        DownloadItem::COMPLETE));
+  query()->AddSorter(
+      DownloadQuery::SORT_STATE, DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, results()->at(0)->GetState());
+  EXPECT_EQ(DownloadItem::COMPLETE, results()->at(1)->GetState());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortTotalBytes) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(1));
+  query()->AddSorter(
+      DownloadQuery::SORT_TOTAL_BYTES, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ(1, results()->at(0)->GetTotalBytes());
+  EXPECT_EQ(0, results()->at(1)->GetTotalBytes());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortUrl) {
+  CreateMocks(2);
+  GURL a_url("http://example.com/a");
+  GURL b_url("http://example.com/b");
+  EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(b_url));
+  EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(a_url));
+  query()->AddSorter(
+      DownloadQuery::SORT_URL, DownloadQuery::ASCENDING);
+  Search();
+  EXPECT_EQ(a_url, results()->at(0)->GetOriginalUrl());
+  EXPECT_EQ(b_url, results()->at(1)->GetOriginalUrl());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortId) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(0), GetId()).WillRepeatedly(Return(1));
+  EXPECT_CALL(mock(1), GetId()).WillRepeatedly(Return(0));
+  query()->AddSorter(
+      DownloadQuery::SORT_BYTES_RECEIVED, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ(0, results()->at(0)->GetId());
+  EXPECT_EQ(1, results()->at(1)->GetId());
+}
+
+TEST_F(DownloadQueryTest, DownloadQuerySortDbHandle) {
+  CreateMocks(2);
+  EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(0), GetId()).WillRepeatedly(Return(0));
+  EXPECT_CALL(mock(1), GetId()).WillRepeatedly(Return(0));

[Randy Smith (Not in Mondays), 2011/12/12 18:17:54]

Having the same id makes me nervous--we don't different ids in this code right
now, but eventually we will.  Maybe include ids that would sort opposite to the
DB handle sort?  (And why does this test have ids specified and the other ones
don't?)

[benjhayden, 2011/12/12 19:52:10]

Sorting by id doesn't kick in unless all the sorters return EQ. That's tested by
DownloadQuerySortId above (which also specifies ids...).
The db handle sorting doesn't kick in unless all the sorters return EQ *and* the
ids are equal.
These two implicit sorters (id and db_handle) are just used to stabilize the
sort operation. I could use the address of the DownloadItem instead of its id
and db_handle, but that seemed more magical to me.
If that doesn't help, feel free to roll over and let's chat irl before I need to
go home to let the pup out at 4:30.

+  EXPECT_CALL(mock(0), GetDbHandle()).WillRepeatedly(Return(1));
+  EXPECT_CALL(mock(1), GetDbHandle()).WillRepeatedly(Return(0));
+  query()->AddSorter(
+      DownloadQuery::SORT_BYTES_RECEIVED, DownloadQuery::DESCENDING);
+  Search();
+  EXPECT_EQ(0, results()->at(0)->GetDbHandle());
+  EXPECT_EQ(1, results()->at(1)->GetDbHandle());
+}
+
+TEST_F(DownloadQueryTest, DownloadQueryFilterPerformance) {
+  static const int kNumItems = 10000;
+  static const int kNumFilters = 1000;
+  CreateMocks(kNumItems);
+  for (size_t i = 0; i < (kNumFilters - 1); ++i) {
+    query()->AddFilter(base::Bind(&AlwaysReturn, true));
+  }
+  query()->AddFilter(base::Bind(&AlwaysReturn, false));
+  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";
+}