diff options
author | joaodasilva@chromium.org <joaodasilva@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-12-13 20:36:53 +0000 |
---|---|---|
committer | joaodasilva@chromium.org <joaodasilva@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-12-13 20:36:53 +0000 |
commit | 716c016d95025a8f4d42baab6639b9dc90498f2d (patch) | |
tree | 9efb703e070ecbfb1b73bfac9b350a3b81af14f6 /components/url_matcher/substring_set_matcher_unittest.cc | |
parent | 32c90a98f03fa68da4ba3d97a8e56ca70e92a07d (diff) | |
download | chromium_src-716c016d95025a8f4d42baab6639b9dc90498f2d.zip chromium_src-716c016d95025a8f4d42baab6639b9dc90498f2d.tar.gz chromium_src-716c016d95025a8f4d42baab6639b9dc90498f2d.tar.bz2 |
Move extensions/common/matcher into components/url_matcher.
This allows using that code in builds that don't include extensions without
having to introduce layering exceptions. This is meant for inclusion on the
iOS build.
BUG=271392
TBR=brettw@chromium.org
Review URL: https://codereview.chromium.org/113903002
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@240736 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'components/url_matcher/substring_set_matcher_unittest.cc')
-rw-r--r-- | components/url_matcher/substring_set_matcher_unittest.cc | 170 |
1 files changed, 170 insertions, 0 deletions
diff --git a/components/url_matcher/substring_set_matcher_unittest.cc b/components/url_matcher/substring_set_matcher_unittest.cc new file mode 100644 index 0000000..f5f2be0 --- /dev/null +++ b/components/url_matcher/substring_set_matcher_unittest.cc @@ -0,0 +1,170 @@ +// Copyright 2013 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 "components/url_matcher/substring_set_matcher.h" + +#include <set> +#include <string> +#include <vector> + +#include "testing/gtest/include/gtest/gtest.h" + +namespace url_matcher { + +namespace { + +void TestOnePattern(const std::string& test_string, + const std::string& pattern, + bool is_match) { + std::string test = + "TestOnePattern(" + test_string + ", " + pattern + ", " + + (is_match ? "1" : "0") + ")"; + std::vector<const StringPattern*> patterns; + StringPattern substring_pattern(pattern, 1); + patterns.push_back(&substring_pattern); + SubstringSetMatcher matcher; + matcher.RegisterPatterns(patterns); + std::set<int> matches; + matcher.Match(test_string, &matches); + + size_t expected_matches = (is_match ? 1 : 0); + EXPECT_EQ(expected_matches, matches.size()) << test; + EXPECT_EQ(is_match, matches.find(1) != matches.end()) << test; +} + +void TestTwoPatterns(const std::string& test_string, + const std::string& pattern_1, + const std::string& pattern_2, + bool is_match_1, + bool is_match_2) { + std::string test = + "TestTwoPatterns(" + test_string + ", " + pattern_1 + ", " + pattern_2 + + ", " + (is_match_1 ? "1" : "0") + ", " + (is_match_2 ? "1" : "0") + ")"; + StringPattern substring_pattern_1(pattern_1, 1); + StringPattern substring_pattern_2(pattern_2, 2); + // In order to make sure that the order in which patterns are registered + // does not make any difference we try both permutations. + for (int permutation = 0; permutation < 2; ++permutation) { + std::vector<const StringPattern*> patterns; + if (permutation == 0) { + patterns.push_back(&substring_pattern_1); + patterns.push_back(&substring_pattern_2); + } else { + patterns.push_back(&substring_pattern_2); + patterns.push_back(&substring_pattern_1); + } + SubstringSetMatcher matcher; + matcher.RegisterPatterns(patterns); + std::set<int> matches; + matcher.Match(test_string, &matches); + + size_t expected_matches = (is_match_1 ? 1 : 0) + (is_match_2 ? 1 : 0); + EXPECT_EQ(expected_matches, matches.size()) << test; + EXPECT_EQ(is_match_1, matches.find(1) != matches.end()) << test; + EXPECT_EQ(is_match_2, matches.find(2) != matches.end()) << test; + } +} + +} // namespace + +TEST(SubstringSetMatcherTest, TestMatcher) { + // Test overlapping patterns + // String abcde + // Pattern 1 bc + // Pattern 2 cd + TestTwoPatterns("abcde", "bc", "cd", true, true); + + // Test subpatterns - part 1 + // String abcde + // Pattern 1 bc + // Pattern 2 b + TestTwoPatterns("abcde", "bc", "b", true, true); + + // Test subpatterns - part 2 + // String abcde + // Pattern 1 bc + // Pattern 2 c + TestTwoPatterns("abcde", "bc", "c", true, true); + + // Test identical matches + // String abcde + // Pattern 1 abcde + TestOnePattern("abcde", "abcde", true); + + // Test multiple matches + // String aaaaa + // Pattern 1 a + TestOnePattern("abcde", "a", true); + + // Test matches at beginning and end + // String abcde + // Pattern 1 ab + // Pattern 2 de + TestTwoPatterns("abcde", "ab", "de", true, true); + + // Test duplicate patterns with different IDs + // String abcde + // Pattern 1 bc + // Pattern 2 bc + TestTwoPatterns("abcde", "bc", "bc", true, true); + + // Test non-match + // String abcde + // Pattern 1 fg + TestOnePattern("abcde", "fg", false); + + // Test empty pattern and too long pattern + // String abcde + // Pattern 1 + // Pattern 2 abcdef + TestTwoPatterns("abcde", std::string(), "abcdef", true, false); +} + +TEST(SubstringSetMatcherTest, RegisterAndRemove) { + SubstringSetMatcher matcher; + + StringPattern pattern_1("a", 1); + StringPattern pattern_2("b", 2); + StringPattern pattern_3("c", 3); + + std::vector<const StringPattern*> patterns; + patterns.push_back(&pattern_1); + matcher.RegisterPatterns(patterns); + + patterns.clear(); + patterns.push_back(&pattern_2); + patterns.push_back(&pattern_3); + matcher.RegisterPatterns(patterns); + + std::set<int> matches; + matcher.Match("abd", &matches); + EXPECT_EQ(2u, matches.size()); + EXPECT_TRUE(matches.end() != matches.find(1)); + EXPECT_TRUE(matches.end() != matches.find(2)); + + patterns.clear(); + patterns.push_back(&pattern_2); + matcher.UnregisterPatterns(patterns); + + matches.clear(); + matcher.Match("abd", &matches); + EXPECT_EQ(1u, matches.size()); + EXPECT_TRUE(matches.end() != matches.find(1)); + EXPECT_TRUE(matches.end() == matches.find(2)); + + patterns.clear(); + patterns.push_back(&pattern_1); + patterns.push_back(&pattern_3); + matcher.UnregisterPatterns(patterns); + EXPECT_TRUE(matcher.IsEmpty()); +} + +TEST(SubstringSetMatcherTest, TestEmptyMatcher) { + SubstringSetMatcher matcher; + std::set<int> matches; + matcher.Match("abd", &matches); + EXPECT_TRUE(matches.empty()); +} + +} // namespace url_matcher |