unittests/Support/GlobPatternTest.cpp

//===- 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'));
}
}