chrome/browser/download/download_query_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/bind.h"
   8 #include "base/files/file_path.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string16.h"
  13 #include "base/time/time.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/download/download_query.h"
  16 #include "content/public/test/mock_download_item.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using ::testing::Return;
  21 using ::testing::ReturnRef;
  22 using ::testing::_;
  23 using base::Time;
  24 using base::Value;
  25 using content::DownloadItem;
  26 typedef DownloadQuery::DownloadVector DownloadVector;
  27
  28 namespace {
  29
  30 static const int kSomeKnownTime = 1355864160;
  31 static const char kSomeKnownTime8601[] = "2012-12-18T20:56:0";
  32 static const char k8601Suffix[] = ".000Z";
  33
  34 bool IdNotEqual(uint32 not_id, const DownloadItem& item) {
  35   return item.GetId() != not_id;
  36 }
  37
  38 bool AlwaysReturn(bool result, const DownloadItem& item) {
  39   return result;
  40 }
  41
  42 }  // anonymous namespace
  43
  44 class DownloadQueryTest : public testing::Test {
  45  public:
  46   DownloadQueryTest() {}
  47
  48   virtual ~DownloadQueryTest() {}
  49
  50   virtual void TearDown() {
  51     STLDeleteElements(&mocks_);
  52   }
  53
  54   void CreateMocks(int count) {
  55     for (int i = 0; i < count; ++i) {
  56       mocks_.push_back(new content::MockDownloadItem());
  57       EXPECT_CALL(mock(mocks_.size() - 1), GetId()).WillRepeatedly(Return(
  58           mocks_.size() - 1));
  59     }
  60   }
  61
  62   content::MockDownloadItem& mock(int index) { return *mocks_[index]; }
  63
  64   DownloadQuery* query() { return &query_; }
  65
  66   template<typename ValueType> void AddFilter(
  67       DownloadQuery::FilterType name, ValueType value);
  68
  69   void Search() {
  70     query_.Search(mocks_.begin(), mocks_.end(), &results_);
  71   }
  72
  73   DownloadVector* results() { return &results_; }
  74
  75   // Filter tests generally contain 2 items. mock(0) matches the filter, mock(1)
  76   // does not.
  77   void ExpectStandardFilterResults() {
  78     Search();
  79     ASSERT_EQ(1U, results()->size());
  80     ASSERT_EQ(0U, results()->at(0)->GetId());
  81   }
  82
  83   // If no sorters distinguish between two items, then DownloadQuery sorts by ID
  84   // ascending. In order to test that a sorter distinguishes between two items,
  85   // the sorter must sort them by ID descending.
  86   void ExpectSortInverted() {
  87     Search();
  88     ASSERT_EQ(2U, results()->size());
  89     ASSERT_EQ(1U, results()->at(0)->GetId());
  90     ASSERT_EQ(0U, results()->at(1)->GetId());
  91   }
  92
  93  private:
  94   std::vector<content::MockDownloadItem*> mocks_;
  95   DownloadQuery query_;
  96   DownloadVector results_;
  97
  98   DISALLOW_COPY_AND_ASSIGN(DownloadQueryTest);
  99 };
 100
 101 template<> void DownloadQueryTest::AddFilter(
 102     DownloadQuery::FilterType name, bool cpp_value) {
 103   scoped_ptr<base::Value> value(new base::FundamentalValue(cpp_value));
 104   CHECK(query_.AddFilter(name, *value.get()));
 105 }
 106
 107 template<> void DownloadQueryTest::AddFilter(
 108     DownloadQuery::FilterType name, int cpp_value) {
 109   scoped_ptr<base::Value> value(new base::FundamentalValue(cpp_value));
 110   CHECK(query_.AddFilter(name, *value.get()));
 111 }
 112
 113 template<> void DownloadQueryTest::AddFilter(
 114     DownloadQuery::FilterType name, const char* cpp_value) {
 115   CHECK(query_.AddFilter(name, base::StringValue(cpp_value)));
 116 }
 117
 118 template<> void DownloadQueryTest::AddFilter(
 119     DownloadQuery::FilterType name, std::string cpp_value) {
 120   CHECK(query_.AddFilter(name, base::StringValue(cpp_value)));
 121 }
 122
 123 template<> void DownloadQueryTest::AddFilter(
 124     DownloadQuery::FilterType name, const base::char16* cpp_value) {
 125   CHECK(query_.AddFilter(name, base::StringValue(cpp_value)));
 126 }
 127
 128 template<> void DownloadQueryTest::AddFilter(
 129     DownloadQuery::FilterType name, std::vector<base::string16> cpp_value) {
 130   scoped_ptr<base::ListValue> list(new base::ListValue());
 131   for (std::vector<base::string16>::const_iterator it = cpp_value.begin();
 132        it != cpp_value.end(); ++it) {
 133     list->Append(new base::StringValue(*it));
 134   }
 135   CHECK(query_.AddFilter(name, *list.get()));
 136 }
 137
 138 template<> void DownloadQueryTest::AddFilter(
 139     DownloadQuery::FilterType name, std::vector<std::string> cpp_value) {
 140   scoped_ptr<base::ListValue> list(new base::ListValue());
 141   for (std::vector<std::string>::const_iterator it = cpp_value.begin();
 142        it != cpp_value.end(); ++it) {
 143     list->Append(new base::StringValue(*it));
 144   }
 145   CHECK(query_.AddFilter(name, *list.get()));
 146 }
 147
 148 #if defined(OS_WIN)
 149 template<> void DownloadQueryTest::AddFilter(
 150     DownloadQuery::FilterType name, std::wstring cpp_value) {
 151   CHECK(query_.AddFilter(name, base::StringValue(cpp_value)));
 152 }
 153 #endif
 154
 155 TEST_F(DownloadQueryTest, DownloadQueryTest_ZeroItems) {
 156   Search();
 157   EXPECT_EQ(0U, results()->size());
 158 }
 159
 160 TEST_F(DownloadQueryTest, DownloadQueryTest_InvalidFilter) {
 161   scoped_ptr<base::Value> value(new base::FundamentalValue(0));
 162   EXPECT_FALSE(query()->AddFilter(
 163       static_cast<DownloadQuery::FilterType>(kint32max),
 164       *value.get()));
 165 }
 166
 167 TEST_F(DownloadQueryTest, DownloadQueryTest_EmptyQuery) {
 168   CreateMocks(2);
 169   Search();
 170   ASSERT_EQ(2U, results()->size());
 171   ASSERT_EQ(0U, results()->at(0)->GetId());
 172   ASSERT_EQ(1U, results()->at(1)->GetId());
 173 }
 174
 175 TEST_F(DownloadQueryTest, DownloadQueryTest_Limit) {
 176   CreateMocks(2);
 177   query()->Limit(1);
 178   ExpectStandardFilterResults();
 179 }
 180
 181 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterGenericQueryFilename) {
 182   CreateMocks(2);
 183   EXPECT_CALL(mock(0), GetBrowserContext()).WillRepeatedly(Return(
 184       static_cast<content::BrowserContext*>(NULL)));
 185   EXPECT_CALL(mock(1), GetBrowserContext()).WillRepeatedly(Return(
 186       static_cast<content::BrowserContext*>(NULL)));
 187   base::FilePath match_filename(FILE_PATH_LITERAL("query"));
 188   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 189       match_filename));
 190   base::FilePath fail_filename(FILE_PATH_LITERAL("fail"));
 191   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 192       fail_filename));
 193   GURL fail_url("http://example.com/fail");
 194   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 195   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 196   std::vector<std::string> query_terms;
 197   query_terms.push_back("query");
 198   AddFilter(DownloadQuery::FILTER_QUERY, query_terms);
 199   ExpectStandardFilterResults();
 200 }
 201
 202 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterGenericQueryUrl) {
 203   CreateMocks(2);
 204   EXPECT_CALL(mock(0), GetBrowserContext()).WillRepeatedly(Return(
 205       static_cast<content::BrowserContext*>(NULL)));
 206   EXPECT_CALL(mock(1), GetBrowserContext()).WillRepeatedly(Return(
 207       static_cast<content::BrowserContext*>(NULL)));
 208   base::FilePath fail_filename(FILE_PATH_LITERAL("fail"));
 209   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 210       fail_filename));
 211   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 212       fail_filename));
 213   GURL match_url("http://query.com/query");
 214   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(match_url));
 215   GURL fail_url("http://example.com/fail");
 216   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 217   std::vector<std::string> query_terms;
 218   query_terms.push_back("query");
 219   AddFilter(DownloadQuery::FILTER_QUERY, query_terms);
 220   ExpectStandardFilterResults();
 221 }
 222
 223 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterGenericQueryFilenameI18N) {
 224   CreateMocks(2);
 225   EXPECT_CALL(mock(0), GetBrowserContext()).WillRepeatedly(Return(
 226       static_cast<content::BrowserContext*>(NULL)));
 227   EXPECT_CALL(mock(1), GetBrowserContext()).WillRepeatedly(Return(
 228       static_cast<content::BrowserContext*>(NULL)));
 229   const base::FilePath::StringType kTestString(
 230 #if defined(OS_POSIX)
 231       "/\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd"
 232 #elif defined(OS_WIN)
 233       L"/\x4f60\x597d\x4f60\x597d"
 234 #endif
 235       );
 236   base::FilePath match_filename(kTestString);
 237   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 238       match_filename));
 239   base::FilePath fail_filename(FILE_PATH_LITERAL("fail"));
 240   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 241       fail_filename));
 242   GURL fail_url("http://example.com/fail");
 243   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 244   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 245   std::vector<base::FilePath::StringType> query_terms;
 246   query_terms.push_back(kTestString);
 247   AddFilter(DownloadQuery::FILTER_QUERY, query_terms);
 248   ExpectStandardFilterResults();
 249 }
 250
 251 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterFilenameRegex) {
 252   CreateMocks(2);
 253   base::FilePath match_filename(FILE_PATH_LITERAL("query"));
 254   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 255       match_filename));
 256   base::FilePath fail_filename(FILE_PATH_LITERAL("fail"));
 257   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 258       fail_filename));
 259   AddFilter(DownloadQuery::FILTER_FILENAME_REGEX, "y");
 260   ExpectStandardFilterResults();
 261 }
 262
 263 TEST_F(DownloadQueryTest, DownloadQueryTest_SortFilename) {
 264   CreateMocks(2);
 265   base::FilePath b_filename(FILE_PATH_LITERAL("b"));
 266   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 267       b_filename));
 268   base::FilePath a_filename(FILE_PATH_LITERAL("a"));
 269   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 270       a_filename));
 271   query()->AddSorter(DownloadQuery::SORT_FILENAME, DownloadQuery::ASCENDING);
 272   ExpectSortInverted();
 273 }
 274
 275 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterFilename) {
 276   CreateMocks(2);
 277   base::FilePath match_filename(FILE_PATH_LITERAL("query"));
 278   EXPECT_CALL(mock(0), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 279       match_filename));
 280   base::FilePath fail_filename(FILE_PATH_LITERAL("fail"));
 281   EXPECT_CALL(mock(1), GetTargetFilePath()).WillRepeatedly(ReturnRef(
 282       fail_filename));
 283   AddFilter(DownloadQuery::FILTER_FILENAME, match_filename.value().c_str());
 284   ExpectStandardFilterResults();
 285 }
 286
 287 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterUrlRegex) {
 288   CreateMocks(2);
 289   GURL match_url("http://query.com/query");
 290   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(match_url));
 291   GURL fail_url("http://example.com/fail");
 292   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 293   AddFilter(DownloadQuery::FILTER_URL_REGEX, "query");
 294   ExpectStandardFilterResults();
 295 }
 296
 297 TEST_F(DownloadQueryTest, DownloadQueryTest_SortUrl) {
 298   CreateMocks(2);
 299   GURL b_url("http://example.com/b");
 300   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(b_url));
 301   GURL a_url("http://example.com/a");
 302   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(a_url));
 303   query()->AddSorter(DownloadQuery::SORT_URL, DownloadQuery::ASCENDING);
 304   ExpectSortInverted();
 305 }
 306
 307 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterUrl) {
 308   CreateMocks(2);
 309   GURL match_url("http://query.com/query");
 310   EXPECT_CALL(mock(0), GetOriginalUrl()).WillRepeatedly(ReturnRef(match_url));
 311   GURL fail_url("http://example.com/fail");
 312   EXPECT_CALL(mock(1), GetOriginalUrl()).WillRepeatedly(ReturnRef(fail_url));
 313   AddFilter(DownloadQuery::FILTER_URL, match_url.spec().c_str());
 314   ExpectStandardFilterResults();
 315 }
 316
 317 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterCallback) {
 318   CreateMocks(2);
 319   CHECK(query()->AddFilter(base::Bind(&IdNotEqual, 1)));
 320   ExpectStandardFilterResults();
 321 }
 322
 323 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterBytesReceived) {
 324   CreateMocks(2);
 325   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
 326   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(1));
 327   AddFilter(DownloadQuery::FILTER_BYTES_RECEIVED, 0);
 328   ExpectStandardFilterResults();
 329 }
 330
 331 TEST_F(DownloadQueryTest, DownloadQueryTest_SortBytesReceived) {
 332   CreateMocks(2);
 333   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
 334   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(1));
 335   query()->AddSorter(DownloadQuery::SORT_BYTES_RECEIVED,
 336                      DownloadQuery::DESCENDING);
 337   ExpectSortInverted();
 338 }
 339
 340 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterDangerAccepted) {
 341   CreateMocks(2);
 342   EXPECT_CALL(mock(0), GetDangerType()).WillRepeatedly(Return(
 343       content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED));
 344   EXPECT_CALL(mock(1), GetDangerType()).WillRepeatedly(Return(
 345       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE));
 346   AddFilter(DownloadQuery::FILTER_DANGER_ACCEPTED, true);
 347   ExpectStandardFilterResults();
 348 }
 349
 350 TEST_F(DownloadQueryTest, DownloadQueryTest_SortDangerAccepted) {
 351   CreateMocks(2);
 352   EXPECT_CALL(mock(0), GetDangerType()).WillRepeatedly(Return(
 353       content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED));
 354   EXPECT_CALL(mock(1), GetDangerType()).WillRepeatedly(Return(
 355       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE));
 356   query()->AddSorter(DownloadQuery::SORT_DANGER_ACCEPTED,
 357                      DownloadQuery::ASCENDING);
 358   ExpectSortInverted();
 359 }
 360
 361 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterExists) {
 362   CreateMocks(2);
 363   EXPECT_CALL(mock(0), GetFileExternallyRemoved()).WillRepeatedly(Return(
 364       false));
 365   EXPECT_CALL(mock(1), GetFileExternallyRemoved()).WillRepeatedly(Return(
 366       true));
 367   AddFilter(DownloadQuery::FILTER_EXISTS, true);
 368   ExpectStandardFilterResults();
 369 }
 370
 371 TEST_F(DownloadQueryTest, DownloadQueryTest_SortExists) {
 372   CreateMocks(2);
 373   EXPECT_CALL(mock(0), GetFileExternallyRemoved()).WillRepeatedly(Return(
 374       false));
 375   EXPECT_CALL(mock(1), GetFileExternallyRemoved()).WillRepeatedly(Return(
 376       true));
 377   query()->AddSorter(DownloadQuery::SORT_EXISTS,
 378                      DownloadQuery::ASCENDING);
 379   ExpectSortInverted();
 380 }
 381
 382 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterMime) {
 383   CreateMocks(2);
 384   EXPECT_CALL(mock(0), GetMimeType()).WillRepeatedly(Return("text"));
 385   EXPECT_CALL(mock(1), GetMimeType()).WillRepeatedly(Return("image"));
 386   AddFilter(DownloadQuery::FILTER_MIME, "text");
 387   ExpectStandardFilterResults();
 388 }
 389
 390 TEST_F(DownloadQueryTest, DownloadQueryTest_SortMime) {
 391   CreateMocks(2);
 392   EXPECT_CALL(mock(0), GetMimeType()).WillRepeatedly(Return("b"));
 393   EXPECT_CALL(mock(1), GetMimeType()).WillRepeatedly(Return("a"));
 394   query()->AddSorter(DownloadQuery::SORT_MIME, DownloadQuery::ASCENDING);
 395   ExpectSortInverted();
 396 }
 397
 398 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterPaused) {
 399   CreateMocks(2);
 400   EXPECT_CALL(mock(0), IsPaused()).WillRepeatedly(Return(true));
 401   EXPECT_CALL(mock(1), IsPaused()).WillRepeatedly(Return(false));
 402   AddFilter(DownloadQuery::FILTER_PAUSED, true);
 403   ExpectStandardFilterResults();
 404 }
 405
 406 TEST_F(DownloadQueryTest, DownloadQueryTest_SortPaused) {
 407   CreateMocks(2);
 408   EXPECT_CALL(mock(0), IsPaused()).WillRepeatedly(Return(true));
 409   EXPECT_CALL(mock(1), IsPaused()).WillRepeatedly(Return(false));
 410   query()->AddSorter(DownloadQuery::SORT_PAUSED, DownloadQuery::ASCENDING);
 411   ExpectSortInverted();
 412 }
 413
 414 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterStartedAfter) {
 415   CreateMocks(2);
 416   EXPECT_CALL(mock(0), GetStartTime()).WillRepeatedly(Return(
 417       base::Time::FromTimeT(kSomeKnownTime + 2)));
 418   EXPECT_CALL(mock(1), GetStartTime()).WillRepeatedly(Return(
 419       base::Time::FromTimeT(kSomeKnownTime + 1)));
 420   AddFilter(DownloadQuery::FILTER_STARTED_AFTER,
 421             std::string(kSomeKnownTime8601) + "1" + std::string(k8601Suffix));
 422   ExpectStandardFilterResults();
 423 }
 424
 425 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterStartedBefore) {
 426   CreateMocks(2);
 427   EXPECT_CALL(mock(0), GetStartTime()).WillRepeatedly(Return(
 428       base::Time::FromTimeT(kSomeKnownTime + 2)));
 429   EXPECT_CALL(mock(1), GetStartTime()).WillRepeatedly(Return(
 430       base::Time::FromTimeT(kSomeKnownTime + 4)));
 431   AddFilter(DownloadQuery::FILTER_STARTED_BEFORE,
 432             std::string(kSomeKnownTime8601) + "4" + std::string(k8601Suffix));
 433   ExpectStandardFilterResults();
 434 }
 435
 436 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterStartTime) {
 437   CreateMocks(2);
 438   EXPECT_CALL(mock(0), GetStartTime()).WillRepeatedly(Return(
 439       base::Time::FromTimeT(kSomeKnownTime + 2)));
 440   EXPECT_CALL(mock(1), GetStartTime()).WillRepeatedly(Return(
 441       base::Time::FromTimeT(kSomeKnownTime + 4)));
 442   AddFilter(DownloadQuery::FILTER_START_TIME,
 443             std::string(kSomeKnownTime8601) + "2" + std::string(k8601Suffix));
 444   ExpectStandardFilterResults();
 445 }
 446
 447 TEST_F(DownloadQueryTest, DownloadQueryTest_SortStartTime) {
 448   CreateMocks(2);
 449   EXPECT_CALL(mock(0), GetStartTime()).WillRepeatedly(Return(
 450       base::Time::FromTimeT(kSomeKnownTime + 2)));
 451   EXPECT_CALL(mock(1), GetStartTime()).WillRepeatedly(Return(
 452       base::Time::FromTimeT(kSomeKnownTime + 4)));
 453   query()->AddSorter(DownloadQuery::SORT_START_TIME, DownloadQuery::DESCENDING);
 454   ExpectSortInverted();
 455 }
 456
 457 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterEndedAfter) {
 458   CreateMocks(2);
 459   EXPECT_CALL(mock(0), GetEndTime()).WillRepeatedly(Return(
 460       base::Time::FromTimeT(kSomeKnownTime + 2)));
 461   EXPECT_CALL(mock(1), GetEndTime()).WillRepeatedly(Return(
 462       base::Time::FromTimeT(kSomeKnownTime + 1)));
 463   AddFilter(DownloadQuery::FILTER_ENDED_AFTER,
 464             std::string(kSomeKnownTime8601) + "1" + std::string(k8601Suffix));
 465   ExpectStandardFilterResults();
 466 }
 467
 468 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterEndedBefore) {
 469   CreateMocks(2);
 470   EXPECT_CALL(mock(0), GetEndTime()).WillRepeatedly(Return(
 471       base::Time::FromTimeT(kSomeKnownTime + 2)));
 472   EXPECT_CALL(mock(1), GetEndTime()).WillRepeatedly(Return(
 473       base::Time::FromTimeT(kSomeKnownTime + 4)));
 474   AddFilter(DownloadQuery::FILTER_ENDED_BEFORE,
 475             std::string(kSomeKnownTime8601) + "4" + std::string(k8601Suffix));
 476   ExpectStandardFilterResults();
 477 }
 478
 479 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterEndTime) {
 480   CreateMocks(2);
 481   EXPECT_CALL(mock(0), GetEndTime()).WillRepeatedly(Return(
 482       base::Time::FromTimeT(kSomeKnownTime + 2)));
 483   EXPECT_CALL(mock(1), GetEndTime()).WillRepeatedly(Return(
 484       base::Time::FromTimeT(kSomeKnownTime + 4)));
 485   AddFilter(DownloadQuery::FILTER_END_TIME,
 486             std::string(kSomeKnownTime8601) + "2" + std::string(k8601Suffix));
 487   ExpectStandardFilterResults();
 488 }
 489
 490 TEST_F(DownloadQueryTest, DownloadQueryTest_SortEndTime) {
 491   CreateMocks(2);
 492   EXPECT_CALL(mock(0), GetEndTime()).WillRepeatedly(Return(
 493       base::Time::FromTimeT(kSomeKnownTime + 2)));
 494   EXPECT_CALL(mock(1), GetEndTime()).WillRepeatedly(Return(
 495       base::Time::FromTimeT(kSomeKnownTime + 4)));
 496   query()->AddSorter(DownloadQuery::SORT_END_TIME, DownloadQuery::DESCENDING);
 497   ExpectSortInverted();
 498 }
 499
 500 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesGreater) {
 501   CreateMocks(2);
 502   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
 503   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(1));
 504   AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_GREATER, 1);
 505   ExpectStandardFilterResults();
 506 }
 507
 508 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytesLess) {
 509   CreateMocks(2);
 510   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
 511   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
 512   AddFilter(DownloadQuery::FILTER_TOTAL_BYTES_LESS, 4);
 513   ExpectStandardFilterResults();
 514 }
 515
 516 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterTotalBytes) {
 517   CreateMocks(2);
 518   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
 519   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
 520   AddFilter(DownloadQuery::FILTER_TOTAL_BYTES, 2);
 521   ExpectStandardFilterResults();
 522 }
 523
 524 TEST_F(DownloadQueryTest, DownloadQueryTest_SortTotalBytes) {
 525   CreateMocks(2);
 526   EXPECT_CALL(mock(0), GetTotalBytes()).WillRepeatedly(Return(2));
 527   EXPECT_CALL(mock(1), GetTotalBytes()).WillRepeatedly(Return(4));
 528   query()->AddSorter(DownloadQuery::SORT_TOTAL_BYTES,
 529                      DownloadQuery::DESCENDING);
 530   ExpectSortInverted();
 531 }
 532
 533 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterState) {
 534   CreateMocks(2);
 535   EXPECT_CALL(mock(0), GetState()).WillRepeatedly(Return(
 536       DownloadItem::IN_PROGRESS));
 537   EXPECT_CALL(mock(1), GetState()).WillRepeatedly(Return(
 538       DownloadItem::CANCELLED));
 539   query()->AddFilter(DownloadItem::IN_PROGRESS);
 540   ExpectStandardFilterResults();
 541 }
 542
 543 TEST_F(DownloadQueryTest, DownloadQueryTest_SortState) {
 544   CreateMocks(2);
 545   EXPECT_CALL(mock(0), GetState()).WillRepeatedly(Return(
 546       DownloadItem::IN_PROGRESS));
 547   EXPECT_CALL(mock(1), GetState()).WillRepeatedly(Return(
 548       DownloadItem::CANCELLED));
 549   query()->AddSorter(DownloadQuery::SORT_STATE, DownloadQuery::DESCENDING);
 550   ExpectSortInverted();
 551 }
 552
 553 TEST_F(DownloadQueryTest, DownloadQueryTest_FilterDanger) {
 554   CreateMocks(2);
 555   EXPECT_CALL(mock(0), GetDangerType()).WillRepeatedly(Return(
 556       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS));
 557   EXPECT_CALL(mock(1), GetDangerType()).WillRepeatedly(Return(
 558       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE));
 559   query()->AddFilter(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 560   ExpectStandardFilterResults();
 561 }
 562
 563 TEST_F(DownloadQueryTest, DownloadQueryTest_SortDanger) {
 564   CreateMocks(2);
 565   EXPECT_CALL(mock(0), GetDangerType()).WillRepeatedly(Return(
 566       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS));
 567   EXPECT_CALL(mock(1), GetDangerType()).WillRepeatedly(Return(
 568       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE));
 569   query()->AddSorter(DownloadQuery::SORT_DANGER, DownloadQuery::DESCENDING);
 570   ExpectSortInverted();
 571 }
 572
 573 TEST_F(DownloadQueryTest, DownloadQueryTest_DefaultSortById1) {
 574   CreateMocks(2);
 575   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
 576   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(0));
 577   query()->AddSorter(DownloadQuery::SORT_BYTES_RECEIVED,
 578                      DownloadQuery::ASCENDING);
 579   Search();
 580   ASSERT_EQ(2U, results()->size());
 581   EXPECT_EQ(0U, results()->at(0)->GetId());
 582   EXPECT_EQ(1U, results()->at(1)->GetId());
 583 }
 584
 585 TEST_F(DownloadQueryTest, DownloadQueryTest_DefaultSortById2) {
 586   CreateMocks(2);
 587   EXPECT_CALL(mock(0), GetReceivedBytes()).WillRepeatedly(Return(0));
 588   EXPECT_CALL(mock(1), GetReceivedBytes()).WillRepeatedly(Return(0));
 589   query()->AddSorter(DownloadQuery::SORT_BYTES_RECEIVED,
 590                      DownloadQuery::DESCENDING);
 591   Search();
 592   ASSERT_EQ(2U, results()->size());
 593   EXPECT_EQ(0U, results()->at(0)->GetId());
 594   EXPECT_EQ(1U, results()->at(1)->GetId());
 595 }
 596
 597 TEST_F(DownloadQueryTest, DownloadQueryFilterPerformance) {
 598   static const int kNumItems = 100;
 599   static const int kNumFilters = 100;
 600   CreateMocks(kNumItems);
 601   for (size_t i = 0; i < (kNumFilters - 1); ++i) {
 602     query()->AddFilter(base::Bind(&AlwaysReturn, true));
 603   }
 604   query()->AddFilter(base::Bind(&AlwaysReturn, false));
 605   base::Time start = base::Time::Now();
 606   Search();
 607   base::Time end = base::Time::Now();
 608   double nanos = (end - start).InMillisecondsF() * 1000.0 * 1000.0;
 609   double nanos_per_item = nanos / static_cast<double>(kNumItems);
 610   double nanos_per_item_per_filter = nanos_per_item
 611     / static_cast<double>(kNumFilters);
 612   std::cout << "Search took " << nanos_per_item_per_filter
 613             << " nanoseconds per item per filter.\n";
 614 }