mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 21:06:05 +00:00
8daace8b2d
Extend `GlobPattern` to support brace expansions, e.g., `foo.{c,cpp}` as discussed in https://reviews.llvm.org/D152762#4425203.
The high level change was to turn `Tokens` into a list that gets larger when we see a new brace expansion term. Then in `GlobPattern::match()` we must check against each token group.
This is a breaking change since `{` will no longer match a literal without escaping. However, `\{` will match the literal `{` before and after this change. Also, from a brief survey of LLVM, it seems that `GlobPattern` is mostly used for symbol and path matching, which likely won't need `{` in their patterns.
See https://github.com/devongovett/glob-match#syntax for a nice glob reference.
Reviewed By: MaskRay
Differential Revision: https://reviews.llvm.org/D153587
275 lines
8.6 KiB
C++
275 lines
8.6 KiB
C++
//===- llvm/unittest/Support/GlobPatternTest.cpp --------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/GlobPattern.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm;
|
|
namespace {
|
|
|
|
class GlobPatternTest : public ::testing::Test {};
|
|
|
|
TEST_F(GlobPatternTest, Empty) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match(""));
|
|
EXPECT_FALSE(Pat1->match("a"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, Glob) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("ab*c*def");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("abcdef"));
|
|
EXPECT_TRUE(Pat1->match("abxcxdef"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
EXPECT_FALSE(Pat1->match("xabcdef"));
|
|
EXPECT_FALSE(Pat1->match("abcdefx"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, Wildcard) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("a??c");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("axxc"));
|
|
EXPECT_FALSE(Pat1->match("axxx"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, Escape) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("\\*");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("*"));
|
|
EXPECT_FALSE(Pat1->match("\\*"));
|
|
EXPECT_FALSE(Pat1->match("a"));
|
|
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create("a?\\?c");
|
|
EXPECT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("ax?c"));
|
|
EXPECT_FALSE(Pat2->match("axxc"));
|
|
EXPECT_FALSE(Pat2->match(""));
|
|
|
|
auto Pat3 = GlobPattern::create("\\{");
|
|
ASSERT_TRUE((bool)Pat3);
|
|
EXPECT_TRUE(Pat3->match("{"));
|
|
EXPECT_FALSE(Pat3->match("\\{"));
|
|
EXPECT_FALSE(Pat3->match(""));
|
|
|
|
auto Pat4 = GlobPattern::create("\\a");
|
|
ASSERT_TRUE((bool)Pat4);
|
|
EXPECT_TRUE(Pat4->match("a"));
|
|
EXPECT_FALSE(Pat4->match("\\a"));
|
|
|
|
for (size_t I = 0; I != 4; ++I) {
|
|
std::string S(I, '\\');
|
|
Expected<GlobPattern> Pat = GlobPattern::create(S);
|
|
if (I % 2) {
|
|
EXPECT_FALSE((bool)Pat);
|
|
handleAllErrors(Pat.takeError(), [&](ErrorInfoBase &) {});
|
|
} else {
|
|
EXPECT_TRUE((bool)Pat);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, BasicCharacterClass) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("[abc-fy-z]");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("a"));
|
|
EXPECT_TRUE(Pat1->match("b"));
|
|
EXPECT_TRUE(Pat1->match("c"));
|
|
EXPECT_TRUE(Pat1->match("d"));
|
|
EXPECT_TRUE(Pat1->match("e"));
|
|
EXPECT_TRUE(Pat1->match("f"));
|
|
EXPECT_TRUE(Pat1->match("y"));
|
|
EXPECT_TRUE(Pat1->match("z"));
|
|
EXPECT_FALSE(Pat1->match("g"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create("[ab]*[cd]?**[ef]");
|
|
ASSERT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("aecde"));
|
|
EXPECT_FALSE(Pat2->match("aecdg"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, NegatedCharacterClass) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("[^abc-fy-z]");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("g"));
|
|
EXPECT_FALSE(Pat1->match("a"));
|
|
EXPECT_FALSE(Pat1->match("b"));
|
|
EXPECT_FALSE(Pat1->match("c"));
|
|
EXPECT_FALSE(Pat1->match("d"));
|
|
EXPECT_FALSE(Pat1->match("e"));
|
|
EXPECT_FALSE(Pat1->match("f"));
|
|
EXPECT_FALSE(Pat1->match("y"));
|
|
EXPECT_FALSE(Pat1->match("z"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create("[!abc-fy-z]");
|
|
EXPECT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("g"));
|
|
EXPECT_FALSE(Pat2->match("a"));
|
|
EXPECT_FALSE(Pat2->match("b"));
|
|
EXPECT_FALSE(Pat2->match("c"));
|
|
EXPECT_FALSE(Pat2->match("d"));
|
|
EXPECT_FALSE(Pat2->match("e"));
|
|
EXPECT_FALSE(Pat2->match("f"));
|
|
EXPECT_FALSE(Pat2->match("y"));
|
|
EXPECT_FALSE(Pat2->match("z"));
|
|
EXPECT_FALSE(Pat2->match(""));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, BracketFrontOfCharacterClass) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("[]a]x");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("]x"));
|
|
EXPECT_TRUE(Pat1->match("ax"));
|
|
EXPECT_FALSE(Pat1->match("a]x"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, SpecialCharsInCharacterClass) {
|
|
auto Pat1 = GlobPattern::create("[*?^{},]");
|
|
ASSERT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("*"));
|
|
EXPECT_TRUE(Pat1->match("?"));
|
|
EXPECT_TRUE(Pat1->match("^"));
|
|
EXPECT_TRUE(Pat1->match("{"));
|
|
EXPECT_TRUE(Pat1->match("}"));
|
|
EXPECT_TRUE(Pat1->match(","));
|
|
EXPECT_FALSE(Pat1->match("*?^{},"));
|
|
EXPECT_FALSE(Pat1->match(""));
|
|
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create("[*]");
|
|
ASSERT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("*"));
|
|
EXPECT_FALSE(Pat2->match("]"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, Invalid) {
|
|
for (const auto &InvalidPattern : {"[", "[]"}) {
|
|
auto Pat1 = GlobPattern::create(InvalidPattern);
|
|
EXPECT_FALSE((bool)Pat1) << "Expected invalid pattern: " << InvalidPattern;
|
|
handleAllErrors(Pat1.takeError(), [&](ErrorInfoBase &EIB) {});
|
|
}
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, InvalidBraceExpansion) {
|
|
for (const auto &InvalidPattern :
|
|
{"{", "{{", "{\\", "{\\}", "{}", "{a}", "[{}"}) {
|
|
auto Pat1 = GlobPattern::create(InvalidPattern, /*MaxSubPatterns=*/1024);
|
|
EXPECT_FALSE((bool)Pat1) << "Expected invalid pattern: " << InvalidPattern;
|
|
handleAllErrors(Pat1.takeError(), [&](ErrorInfoBase &EIB) {});
|
|
}
|
|
auto Pat1 = GlobPattern::create("{a,b}{c,d}{e,f}", /*MaxSubPatterns=*/7);
|
|
EXPECT_FALSE((bool)Pat1);
|
|
handleAllErrors(Pat1.takeError(), [&](ErrorInfoBase &EIB) {});
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, BraceExpansion) {
|
|
auto Pat1 = GlobPattern::create("{a,b}{1,2}", /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("a1"));
|
|
EXPECT_TRUE(Pat1->match("a2"));
|
|
EXPECT_TRUE(Pat1->match("b1"));
|
|
EXPECT_TRUE(Pat1->match("b2"));
|
|
EXPECT_FALSE(Pat1->match("ab"));
|
|
|
|
auto Pat2 = GlobPattern::create(",}{foo,\\,\\},z*}", /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match(",}foo"));
|
|
EXPECT_TRUE(Pat2->match(",},}"));
|
|
EXPECT_TRUE(Pat2->match(",}z"));
|
|
EXPECT_TRUE(Pat2->match(",}zoo"));
|
|
EXPECT_FALSE(Pat2->match(",}fooz"));
|
|
EXPECT_FALSE(Pat2->match("foo"));
|
|
EXPECT_FALSE(Pat2->match(""));
|
|
|
|
// This test breaks if we store terms separately and attempt to match them one
|
|
// by one instead of using subglobs
|
|
auto Pat3 = GlobPattern::create("{a,ab}b", /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat3);
|
|
EXPECT_TRUE(Pat3->match("ab"));
|
|
EXPECT_TRUE(Pat3->match("abb"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, NoBraceExpansion) {
|
|
auto Pat1 = GlobPattern::create("{a,b}{1,2}");
|
|
ASSERT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("{a,b}{1,2}"));
|
|
EXPECT_FALSE(Pat1->match("a1"));
|
|
|
|
auto Pat2 = GlobPattern::create("{{");
|
|
ASSERT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("{{"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, BraceExpansionCharacterClass) {
|
|
// Matches mangled names of C++ standard library functions
|
|
auto Pat =
|
|
GlobPattern::create("_Z{N,NK,}S[tabsiod]*", /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat);
|
|
EXPECT_TRUE(Pat->match("_ZNSt6vectorIiSaIiEE9push_backEOi"));
|
|
EXPECT_TRUE(Pat->match("_ZNKStfoo"));
|
|
EXPECT_TRUE(Pat->match("_ZNSafoo"));
|
|
EXPECT_TRUE(Pat->match("_ZStfoo"));
|
|
EXPECT_FALSE(Pat->match("_Zfoo"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, ExtSym) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("a*\xFF");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->match("axxx\xFF"));
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create("[\xFF-\xFF]");
|
|
EXPECT_TRUE((bool)Pat2);
|
|
EXPECT_TRUE(Pat2->match("\xFF"));
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, IsTrivialMatchAll) {
|
|
Expected<GlobPattern> Pat1 = GlobPattern::create("*");
|
|
EXPECT_TRUE((bool)Pat1);
|
|
EXPECT_TRUE(Pat1->isTrivialMatchAll());
|
|
|
|
const char *NegativeCases[] = {"a*", "*a", "?*", "*?", "**", "\\*"};
|
|
for (auto *P : NegativeCases) {
|
|
Expected<GlobPattern> Pat2 = GlobPattern::create(P);
|
|
EXPECT_TRUE((bool)Pat2);
|
|
EXPECT_FALSE(Pat2->isTrivialMatchAll());
|
|
}
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, NUL) {
|
|
for (char C : "?*") {
|
|
std::string S(1, C);
|
|
Expected<GlobPattern> Pat = GlobPattern::create(S);
|
|
ASSERT_TRUE((bool)Pat);
|
|
EXPECT_TRUE(Pat->match(S));
|
|
if (C == '*') {
|
|
EXPECT_TRUE(Pat->match(S + '\0'));
|
|
} else {
|
|
EXPECT_FALSE(Pat->match(S + '\0'));
|
|
handleAllErrors(Pat.takeError(), [&](ErrorInfoBase &) {});
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(GlobPatternTest, Pathological) {
|
|
std::string P, S(40, 'a');
|
|
StringRef Pieces[] = {"a*", "[ba]*", "{b*,a*}*"};
|
|
for (int I = 0; I != 30; ++I)
|
|
P += Pieces[I % 3];
|
|
Expected<GlobPattern> Pat = GlobPattern::create(P, /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat);
|
|
EXPECT_TRUE(Pat->match(S));
|
|
P += 'b';
|
|
Pat = GlobPattern::create(P, /*MaxSubPatterns=*/1024);
|
|
ASSERT_TRUE((bool)Pat);
|
|
EXPECT_FALSE(Pat->match(S));
|
|
EXPECT_TRUE(Pat->match(S + 'b'));
|
|
}
|
|
}
|