blob: 35cb413e4bd2d9a7d7a5f992eda9215ddbf1f64f [file] [log] [blame]
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by an MIT-style license that can be
// found in the LICENSE file or at https://opensource.org/licenses/MIT.
#include "third_party/liburlpattern/pattern.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/liburlpattern/parse.h"
namespace {
absl::StatusOr<std::string> PassThrough(absl::string_view input) {
return std::string(input);
}
} // namespace
namespace liburlpattern {
void RunRegexTest(absl::string_view input,
absl::string_view expected_regex,
std::vector<std::string> expected_name_list,
Options options = Options()) {
auto result = Parse(input, PassThrough, options);
ASSERT_TRUE(result.ok());
auto& pattern = result.value();
std::vector<std::string> name_list;
std::string regex = pattern.GenerateRegexString(&name_list);
EXPECT_EQ(regex, expected_regex);
EXPECT_EQ(name_list, expected_name_list);
}
// The following expected test case values were generated using path-to-regexp
// 6.2.0.
TEST(PatternRegexTest, Fixed) {
RunRegexTest("/foo/bar", R"(^\/foo\/bar[\/#\?]?$)", {});
}
TEST(PatternRegexTest, FixedWithModifier) {
RunRegexTest("{/foo/bar}?", R"(^(?:\/foo\/bar)?[\/#\?]?$)", {});
}
TEST(PatternRegexTest, Name) {
RunRegexTest(":foo", R"(^([^\/#\?]+?)[\/#\?]?$)", {"foo"});
}
TEST(PatternRegexTest, NameWithUnicode) {
RunRegexTest(":fooßar", R"(^([^\/#\?]+?)[\/#\?]?$)", {"fooßar"});
}
TEST(PatternRegexTest, NameWithOptionalModifier) {
RunRegexTest(":foo?", R"(^([^\/#\?]+?)?[\/#\?]?$)", {"foo"});
}
TEST(PatternRegexTest, NameWithZeroOrMoreModifier) {
RunRegexTest(":foo*", R"(^((?:[^\/#\?]+?)*)[\/#\?]?$)", {"foo"});
}
TEST(PatternRegexTest, NameWithOneOrMoreModifier) {
RunRegexTest(":foo+", R"(^((?:[^\/#\?]+?)+)[\/#\?]?$)", {"foo"});
}
TEST(PatternRegexTest, NameWithPrefix) {
RunRegexTest("/foo/:bar", R"(^\/foo(?:\/([^\/#\?]+?))[\/#\?]?$)", {"bar"});
}
TEST(PatternRegexTest, NameWithPrefixAndOptionalModifier) {
RunRegexTest("/foo/:bar?", R"(^\/foo(?:\/([^\/#\?]+?))?[\/#\?]?$)", {"bar"});
}
TEST(PatternRegexTest, NameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))[\/#\?]?$)",
{"bar"});
}
TEST(PatternRegexTest, NameWithPrefixAndZeroOrMoreModifier) {
RunRegexTest("/foo/:bar*",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))?[\/#\?]?$)",
{"bar"});
}
TEST(PatternRegexTest, Regex) {
RunRegexTest("([a-z]+)", R"(^([a-z]+)[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, RegexFullWildcard) {
RunRegexTest("(.*)", R"(^(.*)[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, Wildcard) {
RunRegexTest("*", R"(^(.*)[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, RegexWithOptionalModifier) {
RunRegexTest("([a-z]+)?", R"(^([a-z]+)?[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, WildcardWithOptionalModifier) {
RunRegexTest("*?", R"(^(.*)?[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, RegexWithPrefix) {
RunRegexTest("/foo/([a-z]+)", R"(^\/foo(?:\/([a-z]+))[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, WildcardWithPrefix) {
RunRegexTest("/foo/*", R"(^\/foo(?:\/(.*))[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, RegexWithPrefixAndOptionalModifier) {
RunRegexTest("/foo/([a-z]+)?", R"(^\/foo(?:\/([a-z]+))?[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, WildcardWithPrefixAndOptionalModifier) {
RunRegexTest("/foo/*?", R"(^\/foo(?:\/(.*))?[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, RegexWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/([a-z]+)+",
R"(^\/foo(?:\/((?:[a-z]+)(?:\/(?:[a-z]+))*))[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, WildcardWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/*+", R"(^\/foo(?:\/((?:.*)(?:\/(?:.*))*))[\/#\?]?$)",
{"0"});
}
TEST(PatternRegexTest, RegexWithPrefixAndZeroOrMoreModifier) {
RunRegexTest("/foo/([a-z]+)*",
R"(^\/foo(?:\/((?:[a-z]+)(?:\/(?:[a-z]+))*))?[\/#\?]?$)", {"0"});
}
TEST(PatternRegexTest, WildcardWithPrefixAndZeroOrMoreModifier) {
RunRegexTest("/foo/**", R"(^\/foo(?:\/((?:.*)(?:\/(?:.*))*))?[\/#\?]?$)",
{"0"});
}
TEST(PatternRegexTest, NameWithCustomRegex) {
RunRegexTest(":foo([a-z]+)", R"(^([a-z]+)[\/#\?]?$)", {"foo"});
}
TEST(PatternRegexTest, ManyGroups) {
RunRegexTest("/([a-z])+/:foo/([a-z])+/:bar+",
R"(^(?:\/((?:[a-z])(?:\/(?:[a-z]))*))(?:\/([^\/#\?]+?))(?:\/)"
R"(((?:[a-z])(?:\/(?:[a-z]))*))(?:\/((?:[^\/#\?]+?)(?:\/)"
R"((?:[^\/#\?]+?))*))[\/#\?]?$)",
{"0", "foo", "1", "bar"});
}
TEST(PatternRegexTest, StrictNameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))$)", {"bar"},
{.strict = true});
}
TEST(PatternRegexTest, NoEndNameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))(?:[\/)"
R"(#\?](?=[]|$))?(?=[\/#\?]|[]|$))",
{"bar"}, {.end = false});
}
TEST(PatternRegexTest, NoEndFixedWithTrailingDelimiter) {
RunRegexTest("/foo/bar/", R"(^\/foo\/bar\/(?:[\/#\?](?=[]|$))?)", {},
{.end = false});
}
TEST(PatternRegexTest, StrictNoEndFixedWithTrailingDelimiter) {
RunRegexTest("/foo/bar/", R"(^\/foo\/bar\/)", {},
{.strict = true, .end = false});
}
TEST(PatternRegexTest, StrictNoEndFixedWithoutTrailingDelimiter) {
RunRegexTest("/foo/bar", R"(^\/foo\/bar(?=[\/#\?]|[]|$))", {},
{.strict = true, .end = false});
}
TEST(PatternRegexTest, NoStartNameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))[\/#\?]?$)",
{"bar"}, {.start = false});
}
TEST(PatternRegexTest, EndsWithNameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))[\/)"
R"(#\?]?(?=[#]|$))",
{"bar"}, {.ends_with = "#"});
}
TEST(PatternRegexTest, EndsWithNoEndNameWithPrefixAndOneOrMoreModifier) {
RunRegexTest("/foo/:bar+",
R"(^\/foo(?:\/((?:[^\/#\?]+?)(?:\/(?:[^\/#\?]+?))*))(?:[\/)"
R"(#\?](?=[#]|$))?(?=[\/#\?]|[#]|$))",
{"bar"}, {.end = false, .ends_with = "#"});
}
void RunPatternStringTest(absl::string_view input,
absl::string_view expected_pattern_string) {
auto result = Parse(input, PassThrough);
ASSERT_TRUE(result.ok());
auto& pattern = result.value();
std::string pattern_string = pattern.GeneratePatternString();
EXPECT_EQ(pattern_string, expected_pattern_string);
// The computed pattern string should be valid and parse correctly.
auto result2 = Parse(pattern_string, PassThrough);
EXPECT_TRUE(result.ok());
// The second Pattern object may or may not be identical to the first
// due to normalization. For example, stripping the unnecessary grouping
// from a `{foo}` term.
// Computing a second pattern string should result in an identical
// value, however.
std::string pattern_string2 = result2.value().GeneratePatternString();
EXPECT_EQ(pattern_string2, pattern_string);
}
TEST(PatternStringTest, Fixed) {
RunPatternStringTest("/foo/bar", "/foo/bar");
}
TEST(PatternStringTest, Group) {
RunPatternStringTest("/foo/{bar}", "/foo/bar");
}
TEST(PatternStringTest, GroupWithRegexp) {
RunPatternStringTest("/foo/{(bar)}", "/foo/{(bar)}");
}
TEST(PatternStringTest, GroupWithPrefixAndRegexp) {
RunPatternStringTest("/foo/{b(ar)}", "/foo/{b(ar)}");
}
TEST(PatternStringTest, GroupWithDefaultPrefixAndRegexp) {
RunPatternStringTest("/foo{/(bar)}", "/foo/(bar)");
}
TEST(PatternStringTest, GroupWithRegexpAndSuffix) {
RunPatternStringTest("/foo/{(ba)r}", "/foo/{(ba)r}");
}
TEST(PatternStringTest, GroupWithDefaultPrefixRegexpAndSuffix) {
RunPatternStringTest("/foo{/(ba)r}", "/foo{/(ba)r}");
}
TEST(PatternStringTest, GroupWithQuestionModifier) {
RunPatternStringTest("/foo/{bar}?", "/foo/{bar}?");
}
TEST(PatternStringTest, GroupWithStarModifier) {
RunPatternStringTest("/foo/{bar}*", "/foo/{bar}*");
}
TEST(PatternStringTest, GroupWithPlusModifier) {
RunPatternStringTest("/foo/{bar}+", "/foo/{bar}+");
}
TEST(PatternStringTest, NamedGroup) {
RunPatternStringTest("/foo/:bar", "/foo/:bar");
}
TEST(PatternStringTest, SegmentWildcardWithoutName) {
RunPatternStringTest("/foo/([^\\/#\\?]+?)", "/foo/([^\\/#\\?]+?)");
}
TEST(PatternStringTest, NamedGroupWithRegexp) {
RunPatternStringTest("/foo/:bar(baz)", "/foo/:bar(baz)");
}
TEST(PatternStringTest, NamedGroupWithEquivalentRegexp) {
RunPatternStringTest("/foo/:bar([^\\/#\\?]+?)", "/foo/:bar");
}
TEST(PatternStringTest, NamedGroupWithWildcardEquivalentRegexp) {
RunPatternStringTest("/foo/:bar(.*)", "/foo/:bar(.*)");
}
TEST(PatternStringTest, NamedGroupWithQuestionModifier) {
RunPatternStringTest("/foo/:bar?", "/foo/:bar?");
}
TEST(PatternStringTest, NamedGroupWithStarModifier) {
RunPatternStringTest("/foo/:bar*", "/foo/:bar*");
}
TEST(PatternStringTest, NamedGroupWithPlusModifier) {
RunPatternStringTest("/foo/:bar+", "/foo/:bar+");
}
TEST(PatternStringTest, Regexp) {
RunPatternStringTest("/foo/(bar)", "/foo/(bar)");
}
TEST(PatternStringTest, RegexpWithQuestionModifier) {
RunPatternStringTest("/foo/(bar)?", "/foo/(bar)?");
}
TEST(PatternStringTest, RegexpWithStarModifier) {
RunPatternStringTest("/foo/(bar)*", "/foo/(bar)*");
}
TEST(PatternStringTest, RegexpWithPlusModifier) {
RunPatternStringTest("/foo/(bar)+", "/foo/(bar)+");
}
TEST(PatternStringTest, Wildcard) {
RunPatternStringTest("/foo/*", "/foo/*");
}
TEST(PatternStringTest, RegexpWildcardEquivalent) {
RunPatternStringTest("/foo/(.*)", "/foo/*");
}
TEST(PatternStringTest, RegexpEscapedNonPatternChar) {
RunPatternStringTest("/foo/\\bar", "/foo/bar");
}
TEST(PatternStringTest, RegexpEscapedPatternChar) {
RunPatternStringTest("/foo/\\:bar", "/foo/\\:bar");
}
TEST(PatternStringTest, RegexpEscapedPatternCharInPrefix) {
RunPatternStringTest("/foo/{\\:bar(foo)}", "/foo/{\\:bar(foo)}");
}
TEST(PatternStringTest, RegexpEscapedPatternCharInSuffix) {
RunPatternStringTest("/foo/{(foo)\\:bar}", "/foo/{(foo)\\:bar}");
}
TEST(PatternStringTest, RegexpFollowedByWildcard) {
RunPatternStringTest("(foo)(.*)", "(foo)(.*)");
}
TEST(PatternStringTest, RegexpWithOptionalModifierFollowedByWildcard) {
RunPatternStringTest("(foo)?(.*)", "(foo)?*");
}
TEST(PatternStringTest, RegexpWithSuffixModifierFollowedByWildcard) {
RunPatternStringTest("{(foo)a}(.*)", "{(foo)a}(.*)");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByWildcard) {
RunPatternStringTest("{:foo}(.*)", "{:foo}(.*)");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByRegexp) {
RunPatternStringTest("{:foo}(bar)", "{:foo}(bar)");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByWildcardInGrouping) {
RunPatternStringTest("{:foo}{(.*)}", "{:foo}(.*)");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByWildcardWithSuffix) {
RunPatternStringTest("{:foo}{(.*)bar}", ":foo{*bar}");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByWildcardWithPrefix) {
RunPatternStringTest("{:foo}{bar(.*)}", ":foo{bar*}");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByWildcardWithCustomName) {
RunPatternStringTest("{:foo}:bar(.*)", ":foo:bar(.*)");
}
TEST(PatternStringTest,
NamedGroupInGroupingWithOptionalModifierFollowedByWildcard) {
RunPatternStringTest("{:foo}?(.*)", ":foo?*");
}
TEST(PatternStringTest, NamedGroupWithEscapedValidNameSuffix) {
RunPatternStringTest("{:foo\\bar}", "{:foo\\bar}");
}
TEST(PatternStringTest, NamedGroupWithEscapedInvalidNameSuffix) {
RunPatternStringTest("{:foo\\.bar}", "{:foo.bar}");
}
TEST(PatternStringTest, NamedGroupInGroupingFollowedByValidNameText) {
RunPatternStringTest("{:foo}bar", "{:foo}bar");
}
TEST(PatternStringTest, NamedGroupFollowedByEscapedValidNameText) {
RunPatternStringTest(":foo\\bar", "{:foo}bar");
}
TEST(PatternStringTest, NamedGroupWithRegexpFollowedByValidNameText) {
RunPatternStringTest(":foo(baz)bar", ":foo(baz)bar");
}
TEST(PatternStringTest, NamedGroupFollowedByEmptyGroupAndWildcard) {
RunPatternStringTest(":foo{}(.*)", "{:foo}(.*)");
}
TEST(PatternStringTest, NamedGroupFollowedByEmptyGroupAndValidNameText) {
RunPatternStringTest(":foo{}bar", "{:foo}bar");
}
TEST(PatternStringTest,
NamedGroupFollowedByEmptyGroupWithOptionalModifierAndValidNameText) {
RunPatternStringTest(":foo{}?bar", "{:foo}bar");
}
TEST(PatternStringTest, NamedGroupWithRegexpFollowedByWildcard) {
RunPatternStringTest(":foo(bar)(.*)", ":foo(bar)(.*)");
}
TEST(PatternStringTest, NamedGroupWithRegexpAndValidNameSuffix) {
RunPatternStringTest("{:foo(baz)bar}", "{:foo(baz)bar}");
}
TEST(PatternStringTest, WildcardSlashAndWildcard) {
RunPatternStringTest("*/*", "*/*");
}
TEST(PatternStringTest, WildcardEscapedSlashAndWildcard) {
// The backslash in the original input forces the `/` to not be an
// implicit prefix for the second `*`. The generated pattern string
// must similarly prevent the implicit prefix from occuring. This
// is done using the `{}` grouping instead, however, as its a bit more
// readable than escape backslashes.
RunPatternStringTest("*\\/*", "*/{*}");
}
TEST(PatternStringTest, WildcardSlashAndWildcardInGrouping) {
RunPatternStringTest("*/{*}", "*/{*}");
}
TEST(PatternStringTest, WildcardSlashSlashAndWildcard) {
RunPatternStringTest("*//*", "*//*");
}
TEST(
PatternStringTest,
WildcardFollowedByEmptyGroupWithZeroOrMoreModifierAndWildcardWithOptionalModifier) {
RunPatternStringTest("*{}**?", "*(.*)?");
}
TEST(PatternStringTest, CaseFromFuzzer) {
RunPatternStringTest(".:bax\\a*{}**", "{.:bax}a*(.*)");
}
struct DirectMatchCase {
absl::string_view input;
bool expected_match = true;
std::vector<std::pair<absl::string_view, absl::optional<absl::string_view>>>
expected_groups;
};
void RunDirectMatchTest(absl::string_view input,
std::vector<DirectMatchCase> case_list) {
auto result =
Parse(input, PassThrough,
{.sensitive = true, .strict = true, .end = true, .start = true});
ASSERT_TRUE(result.ok());
auto& pattern = result.value();
EXPECT_TRUE(pattern.CanDirectMatch());
for (const auto& c : case_list) {
std::vector<std::pair<absl::string_view, absl::optional<absl::string_view>>>
matched_groups;
EXPECT_EQ(c.expected_match, pattern.DirectMatch(c.input, &matched_groups));
ASSERT_EQ(c.expected_groups.size(), matched_groups.size());
for (size_t i = 0; i < matched_groups.size(); ++i) {
EXPECT_EQ(c.expected_groups[i], matched_groups[i]);
}
}
}
void RunDirectMatchUnsupportedTest(absl::string_view input,
Options options = {.sensitive = true,
.strict = true,
.end = true,
.start = true}) {
auto result = Parse(input, PassThrough, options);
ASSERT_TRUE(result.ok());
auto& pattern = result.value();
EXPECT_FALSE(pattern.CanDirectMatch());
}
TEST(PatternDirectMatch, FullWildcardSupported) {
RunDirectMatchTest("*",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardInGroupSupported) {
RunDirectMatchTest("{*}",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardUsingRegexSupported) {
RunDirectMatchTest("(.*)",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardAndOptionalModifierSupported) {
RunDirectMatchTest("*?",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardAndOneOrMoreModifierSupported) {
RunDirectMatchTest("*+",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardAndZeroOrMoreModifierSupported) {
RunDirectMatchTest("**",
{
{.input = "/foo", .expected_groups = {{"0", "/foo"}}},
{.input = "", .expected_groups = {{"0", ""}}},
});
}
TEST(PatternDirectMatch, FullWildcardWithNameUsingRegexSupported) {
RunDirectMatchTest(
":name(.*)", {
{.input = "/foo", .expected_groups = {{"name", "/foo"}}},
{.input = "", .expected_groups = {{"name", ""}}},
});
}
TEST(PatternDirectMatch, OptionsFalseStartUnsupported) {
RunDirectMatchUnsupportedTest(
"*", {.sensitive = true, .strict = true, .end = true, .start = false});
}
TEST(PatternDirectMatch, OptionsFalseEndUnsupported) {
RunDirectMatchUnsupportedTest(
"*", {.sensitive = true, .strict = true, .end = false, .start = true});
}
TEST(PatternDirectMatch, OptionsFalseStrictUnsupported) {
RunDirectMatchUnsupportedTest(
"*", {.sensitive = true, .strict = false, .end = true, .start = true});
}
TEST(PatternDirectMatch, OptionsFalseSensitiveUnsupported) {
RunDirectMatchUnsupportedTest(
"*", {.sensitive = false, .strict = true, .end = true, .start = true});
}
TEST(PatternDirectMatch, FullWildcardWithPrefixUnsupported) {
RunDirectMatchUnsupportedTest("/*");
}
TEST(PatternDirectMatch, FullWildcardInGroupWithPrefixUnsupported) {
RunDirectMatchUnsupportedTest("{foo*}");
}
TEST(PatternDirectMatch, FullWildcardInGroupWithSuffixUnsupported) {
RunDirectMatchUnsupportedTest("{*foo}");
}
TEST(PatternDirectMatch, EmptyPatternSupported) {
RunDirectMatchTest("", {
{.input = "", .expected_groups = {}},
{.input = "/", .expected_match = false},
});
}
TEST(PatternDirectMatch, FixedTextSupported) {
RunDirectMatchTest("foo", {
{.input = "foo", .expected_groups = {}},
{.input = "fo", .expected_match = false},
{.input = "foobar", .expected_match = false},
});
}
TEST(PatternDirectMatch, FixedTextInGroupSupported) {
RunDirectMatchTest("{foo}", {
{.input = "foo", .expected_groups = {}},
{.input = "fo", .expected_match = false},
{.input = "foobar", .expected_match = false},
});
}
TEST(PatternDirectMatch, FixedTextInGroupWithOptionalModifierUnsupported) {
RunDirectMatchUnsupportedTest("{foo}?");
}
TEST(PatternDirectMatch, FixedTextInGroupWithZeroOrMoreModifierUnsupported) {
RunDirectMatchUnsupportedTest("{foo}*");
}
TEST(PatternDirectMatch, FixedTextInGroupWithOneOrMoreModifierUnsupported) {
RunDirectMatchUnsupportedTest("{foo}+");
}
TEST(PatternDirectMatch, FixedTextAndFullWildcardUnsupported) {
RunDirectMatchUnsupportedTest("/foo*");
}
TEST(PatternDirectMatch, NamedGroupUnsupported) {
RunDirectMatchUnsupportedTest(":name");
}
TEST(PatternDirectMatch, RegexUnsupported) {
RunDirectMatchUnsupportedTest("(foo)");
}
} // namespace liburlpattern