1 // Copyright 2013 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 "components/url_matcher/substring_set_matcher.h" 6 7 #include <set> 8 #include <string> 9 #include <vector> 10 11 #include "testing/gtest/include/gtest/gtest.h" 12 13 namespace url_matcher { 14 15 namespace { 16 17 void TestOnePattern(const std::string& test_string, 18 const std::string& pattern, 19 bool is_match) { 20 std::string test = 21 "TestOnePattern(" + test_string + ", " + pattern + ", " + 22 (is_match ? "1" : "0") + ")"; 23 std::vector<const StringPattern*> patterns; 24 StringPattern substring_pattern(pattern, 1); 25 patterns.push_back(&substring_pattern); 26 SubstringSetMatcher matcher; 27 matcher.RegisterPatterns(patterns); 28 std::set<int> matches; 29 matcher.Match(test_string, &matches); 30 31 size_t expected_matches = (is_match ? 1 : 0); 32 EXPECT_EQ(expected_matches, matches.size()) << test; 33 EXPECT_EQ(is_match, matches.find(1) != matches.end()) << test; 34 } 35 36 void TestTwoPatterns(const std::string& test_string, 37 const std::string& pattern_1, 38 const std::string& pattern_2, 39 bool is_match_1, 40 bool is_match_2) { 41 std::string test = 42 "TestTwoPatterns(" + test_string + ", " + pattern_1 + ", " + pattern_2 + 43 ", " + (is_match_1 ? "1" : "0") + ", " + (is_match_2 ? "1" : "0") + ")"; 44 StringPattern substring_pattern_1(pattern_1, 1); 45 StringPattern substring_pattern_2(pattern_2, 2); 46 // In order to make sure that the order in which patterns are registered 47 // does not make any difference we try both permutations. 48 for (int permutation = 0; permutation < 2; ++permutation) { 49 std::vector<const StringPattern*> patterns; 50 if (permutation == 0) { 51 patterns.push_back(&substring_pattern_1); 52 patterns.push_back(&substring_pattern_2); 53 } else { 54 patterns.push_back(&substring_pattern_2); 55 patterns.push_back(&substring_pattern_1); 56 } 57 SubstringSetMatcher matcher; 58 matcher.RegisterPatterns(patterns); 59 std::set<int> matches; 60 matcher.Match(test_string, &matches); 61 62 size_t expected_matches = (is_match_1 ? 1 : 0) + (is_match_2 ? 1 : 0); 63 EXPECT_EQ(expected_matches, matches.size()) << test; 64 EXPECT_EQ(is_match_1, matches.find(1) != matches.end()) << test; 65 EXPECT_EQ(is_match_2, matches.find(2) != matches.end()) << test; 66 } 67 } 68 69 } // namespace 70 71 TEST(SubstringSetMatcherTest, TestMatcher) { 72 // Test overlapping patterns 73 // String abcde 74 // Pattern 1 bc 75 // Pattern 2 cd 76 TestTwoPatterns("abcde", "bc", "cd", true, true); 77 78 // Test subpatterns - part 1 79 // String abcde 80 // Pattern 1 bc 81 // Pattern 2 b 82 TestTwoPatterns("abcde", "bc", "b", true, true); 83 84 // Test subpatterns - part 2 85 // String abcde 86 // Pattern 1 bc 87 // Pattern 2 c 88 TestTwoPatterns("abcde", "bc", "c", true, true); 89 90 // Test identical matches 91 // String abcde 92 // Pattern 1 abcde 93 TestOnePattern("abcde", "abcde", true); 94 95 // Test multiple matches 96 // String aaaaa 97 // Pattern 1 a 98 TestOnePattern("abcde", "a", true); 99 100 // Test matches at beginning and end 101 // String abcde 102 // Pattern 1 ab 103 // Pattern 2 de 104 TestTwoPatterns("abcde", "ab", "de", true, true); 105 106 // Test duplicate patterns with different IDs 107 // String abcde 108 // Pattern 1 bc 109 // Pattern 2 bc 110 TestTwoPatterns("abcde", "bc", "bc", true, true); 111 112 // Test non-match 113 // String abcde 114 // Pattern 1 fg 115 TestOnePattern("abcde", "fg", false); 116 117 // Test empty pattern and too long pattern 118 // String abcde 119 // Pattern 1 120 // Pattern 2 abcdef 121 TestTwoPatterns("abcde", std::string(), "abcdef", true, false); 122 } 123 124 TEST(SubstringSetMatcherTest, RegisterAndRemove) { 125 SubstringSetMatcher matcher; 126 127 StringPattern pattern_1("a", 1); 128 StringPattern pattern_2("b", 2); 129 StringPattern pattern_3("c", 3); 130 131 std::vector<const StringPattern*> patterns; 132 patterns.push_back(&pattern_1); 133 matcher.RegisterPatterns(patterns); 134 135 patterns.clear(); 136 patterns.push_back(&pattern_2); 137 patterns.push_back(&pattern_3); 138 matcher.RegisterPatterns(patterns); 139 140 std::set<int> matches; 141 matcher.Match("abd", &matches); 142 EXPECT_EQ(2u, matches.size()); 143 EXPECT_TRUE(matches.end() != matches.find(1)); 144 EXPECT_TRUE(matches.end() != matches.find(2)); 145 146 patterns.clear(); 147 patterns.push_back(&pattern_2); 148 matcher.UnregisterPatterns(patterns); 149 150 matches.clear(); 151 matcher.Match("abd", &matches); 152 EXPECT_EQ(1u, matches.size()); 153 EXPECT_TRUE(matches.end() != matches.find(1)); 154 EXPECT_TRUE(matches.end() == matches.find(2)); 155 156 patterns.clear(); 157 patterns.push_back(&pattern_1); 158 patterns.push_back(&pattern_3); 159 matcher.UnregisterPatterns(patterns); 160 EXPECT_TRUE(matcher.IsEmpty()); 161 } 162 163 TEST(SubstringSetMatcherTest, TestEmptyMatcher) { 164 SubstringSetMatcher matcher; 165 std::set<int> matches; 166 matcher.Match("abd", &matches); 167 EXPECT_TRUE(matches.empty()); 168 } 169 170 } // namespace url_matcher 171
