lib/yamlcpp/test/regex_test.cpp

#include "regex_yaml.h"
#include "stream.h"
#include "gtest/gtest.h"

using YAML::RegEx;
using YAML::Stream;

namespace {
const auto MIN_CHAR = Stream::eof() + 1;

TEST(RegExTest, Empty) {
  RegEx empty;
  EXPECT_TRUE(empty.Matches(std::string()));
  EXPECT_EQ(0, empty.Match(std::string()));
  for (int i = MIN_CHAR; i < 128; ++i) {
    auto str = std::string(1, char(i));
    EXPECT_FALSE(empty.Matches(str));
    EXPECT_EQ(-1, empty.Match(str));
  }
}

TEST(RegExTest, Range) {
  for (int i = MIN_CHAR; i < 128; ++i) {
    for (int j = MIN_CHAR; j < 128; ++j) {
      RegEx ex((char)i, (char)j);
      for (int k = MIN_CHAR; k < 128; ++k) {
        auto str = std::string(1, char(k));
        if (i <= k && k <= j) {
          EXPECT_TRUE(ex.Matches(str));
          EXPECT_EQ(1, ex.Match(str));
        } else {
          EXPECT_FALSE(ex.Matches(str));
          EXPECT_EQ(-1, ex.Match(str));
        }
      }
    }
  }
}

TEST(RegExTest, EmptyString) {
  RegEx ex = RegEx(std::string());
  EXPECT_TRUE(ex.Matches(std::string()));
  EXPECT_EQ(0, ex.Match(std::string()));

  // Matches anything, unlike RegEx()!
  EXPECT_TRUE(ex.Matches(std::string("hello")));
  EXPECT_EQ(0, ex.Match(std::string("hello")));
}

TEST(RegExTest, SingleCharacterString) {
  for (int i = MIN_CHAR; i < 128; ++i) {
    RegEx ex(std::string(1, (char)i));
    for (int j = MIN_CHAR; j < 128; ++j) {
      auto str = std::string(1, char(j));
      if (j == i) {
        EXPECT_TRUE(ex.Matches(str));
        EXPECT_EQ(1, ex.Match(str));
        // Match at start of string only!
        std::string prefixed =
            std::string(1, i + 1) + std::string("prefix: ") + str;
        EXPECT_FALSE(ex.Matches(prefixed));
        EXPECT_EQ(-1, ex.Match(prefixed));
      } else {
        EXPECT_FALSE(ex.Matches(str));
        EXPECT_EQ(-1, ex.Match(str));
      }
    }
  }
}

TEST(RegExTest, MultiCharacterString) {
  RegEx ex(std::string("ab"));

  EXPECT_FALSE(ex.Matches(std::string("a")));
  EXPECT_EQ(-1, ex.Match(std::string("a")));

  EXPECT_TRUE(ex.Matches(std::string("ab")));
  EXPECT_EQ(2, ex.Match(std::string("ab")));
  EXPECT_TRUE(ex.Matches(std::string("abba")));
  EXPECT_EQ(2, ex.Match(std::string("abba")));

  // match at start of string only!
  EXPECT_FALSE(ex.Matches(std::string("baab")));
  EXPECT_EQ(-1, ex.Match(std::string("baab")));
}

TEST(RegExTest, OperatorNot) {
  RegEx ex = !RegEx(std::string("ab"));

  EXPECT_TRUE(ex.Matches(std::string("a")));
  EXPECT_EQ(1, ex.Match(std::string("a")));

  EXPECT_FALSE(ex.Matches(std::string("ab")));
  EXPECT_EQ(-1, ex.Match(std::string("ab")));
  EXPECT_FALSE(ex.Matches(std::string("abba")));
  EXPECT_EQ(-1, ex.Match(std::string("abba")));

  // match at start of string only!
  EXPECT_TRUE(ex.Matches(std::string("baab")));
  // Operator not causes only one character to be matched.
  EXPECT_EQ(1, ex.Match(std::string("baab")));
}

TEST(RegExTest, OperatorOr) {
  for (int i = MIN_CHAR; i < 127; ++i) {
    for (int j = i + 1; j < 128; ++j) {
      auto iStr = std::string(1, char(i));
      auto jStr = std::string(1, char(j));
      RegEx ex1 = RegEx(iStr) | RegEx(jStr);
      RegEx ex2 = RegEx(jStr) | RegEx(iStr);

      for (int k = MIN_CHAR; k < 128; ++k) {
        auto str = std::string(1, char(k));
        if (i == k || j == k) {
          EXPECT_TRUE(ex1.Matches(str));
          EXPECT_TRUE(ex2.Matches(str));
          EXPECT_EQ(1, ex1.Match(str));
          EXPECT_EQ(1, ex2.Match(str));
        } else {
          EXPECT_FALSE(ex1.Matches(str));
          EXPECT_FALSE(ex2.Matches(str));
          EXPECT_EQ(-1, ex1.Match(str));
          EXPECT_EQ(-1, ex2.Match(str));
        }
      }
    }
  }
}

TEST(RegExTest, OperatorOrShortCircuits) {
  RegEx ex1 = RegEx(std::string("aaaa")) | RegEx(std::string("aa"));
  RegEx ex2 = RegEx(std::string("aa")) | RegEx(std::string("aaaa"));

  EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
  EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));

  EXPECT_TRUE(ex2.Matches(std::string("aaaaa")));
  EXPECT_EQ(2, ex2.Match(std::string("aaaaa")));
}

TEST(RegExTest, OperatorAnd) {
  RegEx emptySet = RegEx('a') & RegEx();
  EXPECT_FALSE(emptySet.Matches(std::string("a")));
}

TEST(RegExTest, OperatorAndShortCircuits) {
  RegEx ex1 = RegEx(std::string("aaaa")) & RegEx(std::string("aa"));
  RegEx ex2 = RegEx(std::string("aa")) & RegEx(std::string("aaaa"));

  EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
  EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));

  EXPECT_TRUE(ex2.Matches(std::string("aaaaa")));
  EXPECT_EQ(2, ex2.Match(std::string("aaaaa")));
}

TEST(RegExTest, OperatorPlus) {
  RegEx ex = RegEx(std::string("hello ")) + RegEx(std::string("there"));

  EXPECT_TRUE(ex.Matches(std::string("hello there")));
  EXPECT_FALSE(ex.Matches(std::string("hello ")));
  EXPECT_FALSE(ex.Matches(std::string("there")));
  EXPECT_EQ(11, ex.Match(std::string("hello there")));
}

TEST(RegExTest, StringOr) {
  std::string str = "abcde";
  RegEx ex = RegEx(str, YAML::REGEX_OR);

  for (size_t i = 0; i < str.size(); ++i) {
    EXPECT_TRUE(ex.Matches(str.substr(i, 1)));
    EXPECT_EQ(1, ex.Match(str.substr(i, 1)));
  }

  EXPECT_EQ(1, ex.Match(str));
}
}  // namespace