Refactor URLBlacklistManager to use URLMatcher.

chrome/common/extensions/matcher/url_matcher_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/common/extensions/matcher/url_matcher.h"
 
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 147 matching lines @@
   // GURL guarantees that neither domain, nor path, nor query may contain
   // non ASCII-7 characters. We test this here, because a change to this
   // guarantee breaks this implementation horribly.
   GURL url("http://www.föö.com/föö?föö#föö");
   EXPECT_TRUE(IsStringASCII(url.host()));
   EXPECT_TRUE(IsStringASCII(url.path()));
   EXPECT_TRUE(IsStringASCII(url.query()));
   EXPECT_FALSE(IsStringASCII(url.ref()));
 }
 
+TEST(URLMatcherConditionFactoryTest, Criteria) {
+  URLMatcherConditionFactory factory;
+  EXPECT_EQ(URLMatcherCondition::HOST_PREFIX,
+            factory.CreateHostPrefixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::HOST_SUFFIX,
+            factory.CreateHostSuffixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::HOST_CONTAINS,
+            factory.CreateHostContainsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::HOST_EQUALS,
+            factory.CreateHostEqualsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::PATH_PREFIX,
+            factory.CreatePathPrefixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::PATH_SUFFIX,
+            factory.CreatePathSuffixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::PATH_CONTAINS,
+            factory.CreatePathContainsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::PATH_EQUALS,
+            factory.CreatePathEqualsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::QUERY_PREFIX,
+            factory.CreateQueryPrefixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::QUERY_SUFFIX,
+            factory.CreateQuerySuffixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::QUERY_CONTAINS,
+            factory.CreateQueryContainsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::QUERY_EQUALS,
+            factory.CreateQueryEqualsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::HOST_SUFFIX_PATH_PREFIX,
+            factory.CreateHostSuffixPathPrefixCondition("foo",
+                                                        "bar").criterion());
+  EXPECT_EQ(URLMatcherCondition::HOST_EQUALS_PATH_PREFIX,
+            factory.CreateHostEqualsPathPrefixCondition("foo",
+                                                        "bar").criterion());
+  EXPECT_EQ(URLMatcherCondition::URL_PREFIX,
+            factory.CreateURLPrefixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::URL_SUFFIX,
+            factory.CreateURLSuffixCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::URL_CONTAINS,
+            factory.CreateURLContainsCondition("foo").criterion());
+  EXPECT_EQ(URLMatcherCondition::URL_EQUALS,
+            factory.CreateURLEqualsCondition("foo").criterion());
+}
+
 TEST(URLMatcherConditionFactoryTest, TestSingletonProperty) {
   URLMatcherConditionFactory factory;
   URLMatcherCondition c1 = factory.CreateHostEqualsCondition("www.google.com");
   URLMatcherCondition c2 = factory.CreateHostEqualsCondition("www.google.com");
   EXPECT_EQ(c1.criterion(), c2.criterion());
   EXPECT_EQ(c1.substring_pattern(), c2.substring_pattern());
   URLMatcherCondition c3 = factory.CreateHostEqualsCondition("www.google.de");
   EXPECT_EQ(c2.criterion(), c3.criterion());
   EXPECT_NE(c2.substring_pattern(), c3.substring_pattern());
   EXPECT_NE(c2.substring_pattern()->id(), c3.substring_pattern()->id());
@@ skipping 87 matching lines @@
 
   // Test adjacent components
   EXPECT_TRUE(Matches(factory.CreateHostSuffixPathPrefixCondition(
       "google.com", "/webhp"), url));
   EXPECT_TRUE(Matches(factory.CreateHostSuffixPathPrefixCondition(
         "", "/webhp"), url));
   EXPECT_TRUE(Matches(factory.CreateHostSuffixPathPrefixCondition(
         "google.com", ""), url));
   EXPECT_FALSE(Matches(factory.CreateHostSuffixPathPrefixCondition(
         "www", ""), url));
+
+  EXPECT_TRUE(Matches(factory.CreateHostEqualsPathPrefixCondition(
+      "www.google.com", "/webhp"), url));
+  EXPECT_FALSE(Matches(factory.CreateHostEqualsPathPrefixCondition(
+        "", "/webhp"), url));
+  EXPECT_TRUE(Matches(factory.CreateHostEqualsPathPrefixCondition(
+        "www.google.com", ""), url));
+  EXPECT_FALSE(Matches(factory.CreateHostEqualsPathPrefixCondition(
+        "google.com", ""), url));
 }
 
 TEST(URLMatcherConditionFactoryTest, TestFullSearches) {
   GURL gurl("https://www.google.com/webhp?sourceid=chrome-instant&ie=UTF-8"
       "&ion=1#hl=en&output=search&sclient=psy-ab&q=chrome%20is%20awesome");
   URLMatcherConditionFactory factory;
   std::string url = factory.CanonicalizeURLForFullSearches(gurl);
 
   EXPECT_TRUE(Matches(factory.CreateURLPrefixCondition(""), url));
   EXPECT_TRUE(Matches(factory.CreateURLPrefixCondition("www.goog"), url));
@@ skipping 157 matching lines @@
   // The cached singleton in matcher.condition_factory_ should be destroyed to
   // free memory.
   int patternId2 = factory->CreateHostSuffixCondition(
       "example.com").substring_pattern()->id();
   // If patternId1 and patternId2 are different that indicates that
   // matcher.condition_factory_ does not leak memory.
   EXPECT_NE(patternId1, patternId2);
 }
 
 }  // namespace extensions