diff --git a/docs/advanced.md b/docs/advanced.md index d703a7b1..e2bdcf3e 100644 --- a/docs/advanced.md +++ b/docs/advanced.md @@ -416,41 +416,16 @@ systems (Linux, Cygwin, Mac), GoogleTest uses the syntax. To learn about POSIX syntax, you may want to read this [Wikipedia entry](https://en.wikipedia.org/wiki/Regular_expression#POSIX_extended). -On Windows, GoogleTest uses its own simple regular expression implementation. It -lacks many features. For example, we don't support union (`"x|y"`), grouping -(`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among -others. Below is what we do support (`A` denotes a literal character, period -(`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular -expressions.): - -Expression | Meaning ----------- | -------------------------------------------------------------- -`c` | matches any literal character `c` -`\\d` | matches any decimal digit -`\\D` | matches any character that's not a decimal digit -`\\f` | matches `\f` -`\\n` | matches `\n` -`\\r` | matches `\r` -`\\s` | matches any ASCII whitespace, including `\n` -`\\S` | matches any character that's not a whitespace -`\\t` | matches `\t` -`\\v` | matches `\v` -`\\w` | matches any letter, `_`, or decimal digit -`\\W` | matches any character that `\\w` doesn't match -`\\c` | matches any literal character `c`, which must be a punctuation -`.` | matches any single character except `\n` -`A?` | matches 0 or 1 occurrences of `A` -`A*` | matches 0 or many occurrences of `A` -`A+` | matches 1 or many occurrences of `A` -`^` | matches the beginning of a string (not that of each line) -`$` | matches the end of a string (not that of each line) -`xy` | matches `x` followed by `y` +Otherwise (e.g. on Windows), GoogleTest uses the +[`std::regex`](https://en.cppreference.com/w/cpp/regex) implementation from the +C++ standard library with the +[ECMAScript](https://en.cppreference.com/w/cpp/regex/ecmascript) syntax. To help you determine which capability is available on your system, GoogleTest defines macros to govern which regular expression it is using. The macros are: -`GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death -tests to work in all cases, you can either `#if` on these macros or use the more -limited syntax only. +`GTEST_USES_RE2=1`, `GTEST_USES_POSIX_RE=1`, or `GTEST_USES_STD_RE=1`. If you +want your death tests to work in all cases, you can either `#if` on these macros +or use regular expressions supported by all engines. ## Death Tests diff --git a/googlemock/test/gmock-spec-builders_test.cc b/googlemock/test/gmock-spec-builders_test.cc index 287b249d..5fe0fc47 100644 --- a/googlemock/test/gmock-spec-builders_test.cc +++ b/googlemock/test/gmock-spec-builders_test.cc @@ -1088,22 +1088,16 @@ TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) { // Verifies that the failure message contains the two unsatisfied // pre-requisites but not the satisfied one. -#ifdef GTEST_USES_POSIX_RE EXPECT_THAT(r.message(), ContainsRegex( // POSIX RE doesn't understand the (?s) prefix, but has no - // trouble with (.|\n). + // trouble with [^\b]. MSVC raises + // std::regex_constants::error_stack on some strings with + // (.|\n) but also has no trouble with [^\b]. "the following immediate pre-requisites are not satisfied:\n" - "(.|\n)*: pre-requisite #0\n" - "(.|\n)*: pre-requisite #1")); -#else - // We can only use Google Test's own simple regex. - EXPECT_THAT(r.message(), - ContainsRegex( - "the following immediate pre-requisites are not satisfied:")); - EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #0")); - EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #1")); -#endif // GTEST_USES_POSIX_RE + "[^\b]*: pre-requisite #0\n" + "[^\b]*: pre-requisite #1")) + << r.message(); b.DoB(1); b.DoB(3); diff --git a/googletest/include/gtest/gtest-death-test.h b/googletest/include/gtest/gtest-death-test.h index afd7b3a4..337313ea 100644 --- a/googletest/include/gtest/gtest-death-test.h +++ b/googletest/include/gtest/gtest-death-test.h @@ -105,54 +105,10 @@ GTEST_API_ bool InDeathTestChild(); // // On the regular expressions used in death tests: // -// On POSIX-compliant systems (*nix), we use the library, -// which uses the POSIX extended regex syntax. -// -// On other platforms (e.g. Windows or Mac), we only support a simple regex -// syntax implemented as part of Google Test. This limited -// implementation should be enough most of the time when writing -// death tests; though it lacks many features you can find in PCRE -// or POSIX extended regex syntax. For example, we don't support -// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and -// repetition count ("x{5,7}"), among others. -// -// Below is the syntax that we do support. We chose it to be a -// subset of both PCRE and POSIX extended regex, so it's easy to -// learn wherever you come from. In the following: 'A' denotes a -// literal character, period (.), or a single \\ escape sequence; -// 'x' and 'y' denote regular expressions; 'm' and 'n' are for -// natural numbers. -// -// c matches any literal character c -// \\d matches any decimal digit -// \\D matches any character that's not a decimal digit -// \\f matches \f -// \\n matches \n -// \\r matches \r -// \\s matches any ASCII whitespace, including \n -// \\S matches any character that's not a whitespace -// \\t matches \t -// \\v matches \v -// \\w matches any letter, _, or decimal digit -// \\W matches any character that \\w doesn't match -// \\c matches any literal character c, which must be a punctuation -// . matches any single character except \n -// A? matches 0 or 1 occurrences of A -// A* matches 0 or many occurrences of A -// A+ matches 1 or many occurrences of A -// ^ matches the beginning of a string (not that of each line) -// $ matches the end of a string (not that of each line) -// xy matches x followed by y -// -// If you accidentally use PCRE or POSIX extended regex features -// not implemented by us, you will get a run-time failure. In that -// case, please try to rewrite your regular expression within the -// above syntax. -// -// This implementation is *not* meant to be as highly tuned or robust -// as a compiled regex library, but should perform well enough for a -// death test, which already incurs significant overhead by launching -// a child process. +// Depending on the platform, this may use RE2, the POSIX library, +// the C++11 standard library's engine with ECMAScript syntax, or +// another similar engine. Regular expressions should be simple and portable +// enough to work across the engines of interest. // // Known caveats: // diff --git a/googletest/include/gtest/internal/gtest-port.h b/googletest/include/gtest/internal/gtest-port.h index 154be3c1..0947aee1 100644 --- a/googletest/include/gtest/internal/gtest-port.h +++ b/googletest/include/gtest/internal/gtest-port.h @@ -176,7 +176,7 @@ // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with // GTEST_HAS_POSIX_RE (see above) which users can // define themselves. -// GTEST_USES_SIMPLE_RE - our own simple regex is used; +// GTEST_USES_STD_RE - std::regex from the C++ standard library is used; // the above RE\b(s) are mutually exclusive. // GTEST_HAS_ABSL - Google Test is compiled with Abseil. @@ -438,8 +438,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION; #include // NOLINT #define GTEST_USES_POSIX_RE 1 #else -// Use our own simple regex implementation. -#define GTEST_USES_SIMPLE_RE 1 +// Use std::regex from the C++ standard library. +#include // NOLINT +#define GTEST_USES_STD_RE 1 #endif #ifndef GTEST_HAS_EXCEPTIONS @@ -992,12 +993,11 @@ class GTEST_API_ [[nodiscard]] RE { RE2 regex_; }; -#elif defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_SIMPLE_RE) +#elif defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_STD_RE) GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ /* class A needs to have dll-interface to be used by clients of class B */) -// A simple C++ wrapper for . It uses the POSIX Extended -// Regular Expression syntax. +// A simple C++ wrapper for or . class GTEST_API_ [[nodiscard]] RE { public: // A copy constructor is required by the Standard to initialize object @@ -1037,9 +1037,9 @@ class GTEST_API_ [[nodiscard]] RE { regex_t full_regex_; // For FullMatch(). regex_t partial_regex_; // For PartialMatch(). -#else // GTEST_USES_SIMPLE_RE +#else // GTEST_USES_STD_RE - std::string full_pattern_; // For FullMatch(); + std::regex regex_; #endif }; diff --git a/googletest/src/gtest-internal-inl.h b/googletest/src/gtest-internal-inl.h index 4bebca1b..5a6332a7 100644 --- a/googletest/src/gtest-internal-inl.h +++ b/googletest/src/gtest-internal-inl.h @@ -980,26 +980,7 @@ inline UnitTestImpl* GetUnitTestImpl() { return UnitTest::GetInstance()->impl(); } -#ifdef GTEST_USES_SIMPLE_RE -// Internal helper functions for implementing the simple regular -// expression matcher. -GTEST_API_ bool IsInSet(char ch, const char* str); -GTEST_API_ bool IsAsciiDigit(char ch); -GTEST_API_ bool IsAsciiPunct(char ch); -GTEST_API_ bool IsRepeat(char ch); -GTEST_API_ bool IsAsciiWhiteSpace(char ch); -GTEST_API_ bool IsAsciiWordChar(char ch); -GTEST_API_ bool IsValidEscape(char ch); -GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); -GTEST_API_ bool ValidateRegex(const char* regex); -GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); -GTEST_API_ bool MatchRepetitionAndRegexAtHead(bool escaped, char ch, - char repeat, const char* regex, - const char* str); -GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); - -#endif // GTEST_USES_SIMPLE_RE // Parses the command line for Google Test flags, without initializing // other parts of Google Test. diff --git a/googletest/src/gtest-port.cc b/googletest/src/gtest-port.cc index be5b16e7..68f77f71 100644 --- a/googletest/src/gtest-port.cc +++ b/googletest/src/gtest-port.cc @@ -766,249 +766,46 @@ void RE::Init(const char* regex) { delete[] full_pattern; } -#elif defined(GTEST_USES_SIMPLE_RE) - -// Returns true if and only if ch appears anywhere in str (excluding the -// terminating '\0' character). -bool IsInSet(char ch, const char* str) { - return ch != '\0' && strchr(str, ch) != nullptr; -} - -// Returns true if and only if ch belongs to the given classification. -// Unlike similar functions in , these aren't affected by the -// current locale. -bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; } -bool IsAsciiPunct(char ch) { - return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"); -} -bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); } -bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); } -bool IsAsciiWordChar(char ch) { - return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || - ('0' <= ch && ch <= '9') || ch == '_'; -} - -// Returns true if and only if "\\c" is a supported escape sequence. -bool IsValidEscape(char c) { - return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW")); -} - -// Returns true if and only if the given atom (specified by escaped and -// pattern) matches ch. The result is undefined if the atom is invalid. -bool AtomMatchesChar(bool escaped, char pattern_char, char ch) { - if (escaped) { // "\\p" where p is pattern_char. - switch (pattern_char) { - case 'd': - return IsAsciiDigit(ch); - case 'D': - return !IsAsciiDigit(ch); - case 'f': - return ch == '\f'; - case 'n': - return ch == '\n'; - case 'r': - return ch == '\r'; - case 's': - return IsAsciiWhiteSpace(ch); - case 'S': - return !IsAsciiWhiteSpace(ch); - case 't': - return ch == '\t'; - case 'v': - return ch == '\v'; - case 'w': - return IsAsciiWordChar(ch); - case 'W': - return !IsAsciiWordChar(ch); - } - return IsAsciiPunct(pattern_char) && pattern_char == ch; - } - - return (pattern_char == '.' && ch != '\n') || pattern_char == ch; -} - -// Helper function used by ValidateRegex() to format error messages. -static std::string FormatRegexSyntaxError(const char* regex, int index) { - return (Message() << "Syntax error at index " << index - << " in simple regular expression \"" << regex << "\": ") - .GetString(); -} - -// Generates non-fatal failures and returns false if regex is invalid; -// otherwise returns true. -bool ValidateRegex(const char* regex) { - if (regex == nullptr) { - ADD_FAILURE() << "NULL is not a valid simple regular expression."; - return false; - } - - bool is_valid = true; - - // True if and only if ?, *, or + can follow the previous atom. - bool prev_repeatable = false; - for (int i = 0; regex[i]; i++) { - if (regex[i] == '\\') { // An escape sequence - i++; - if (regex[i] == '\0') { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) - << "'\\' cannot appear at the end."; - return false; - } - - if (!IsValidEscape(regex[i])) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) - << "invalid escape sequence \"\\" << regex[i] << "\"."; - is_valid = false; - } - prev_repeatable = true; - } else { // Not an escape sequence. - const char ch = regex[i]; - - if (ch == '^' && i > 0) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'^' can only appear at the beginning."; - is_valid = false; - } else if (ch == '$' && regex[i + 1] != '\0') { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) - << "'$' can only appear at the end."; - is_valid = false; - } else if (IsInSet(ch, "()[]{}|")) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch - << "' is unsupported."; - is_valid = false; - } else if (IsRepeat(ch) && !prev_repeatable) { - ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch - << "' can only follow a repeatable token."; - is_valid = false; - } - - prev_repeatable = !IsInSet(ch, "^$?*+"); - } - } - - return is_valid; -} - -// Matches a repeated regex atom followed by a valid simple regular -// expression. The regex atom is defined as c if escaped is false, -// or \c otherwise. repeat is the repetition meta character (?, *, -// or +). The behavior is undefined if str contains too many -// characters to be indexable by size_t, in which case the test will -// probably time out anyway. We are fine with this limitation as -// std::string has it too. -bool MatchRepetitionAndRegexAtHead(bool escaped, char c, char repeat, - const char* regex, const char* str) { - const size_t min_count = (repeat == '+') ? 1 : 0; - const size_t max_count = (repeat == '?') ? 1 : static_cast(-1) - 1; - // We cannot call numeric_limits::max() as it conflicts with the - // max() macro on Windows. - - for (size_t i = 0; i <= max_count; ++i) { - // We know that the atom matches each of the first i characters in str. - if (i >= min_count && MatchRegexAtHead(regex, str + i)) { - // We have enough matches at the head, and the tail matches too. - // Since we only care about *whether* the pattern matches str - // (as opposed to *how* it matches), there is no need to find a - // greedy match. - return true; - } - if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) return false; - } - return false; -} - -// Returns true if and only if regex matches a prefix of str. regex must -// be a valid simple regular expression and not start with "^", or the -// result is undefined. -bool MatchRegexAtHead(const char* regex, const char* str) { - if (*regex == '\0') // An empty regex matches a prefix of anything. - return true; - - // "$" only matches the end of a string. Note that regex being - // valid guarantees that there's nothing after "$" in it. - if (*regex == '$') return *str == '\0'; - - // Is the first thing in regex an escape sequence? - const bool escaped = *regex == '\\'; - if (escaped) ++regex; - if (IsRepeat(regex[1])) { - // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so - // here's an indirect recursion. It terminates as the regex gets - // shorter in each recursion. - return MatchRepetitionAndRegexAtHead(escaped, regex[0], regex[1], regex + 2, - str); - } else { - // regex isn't empty, isn't "$", and doesn't start with a - // repetition. We match the first atom of regex with the first - // character of str and recurse. - return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) && - MatchRegexAtHead(regex + 1, str + 1); - } -} - -// Returns true if and only if regex matches any substring of str. regex must -// be a valid simple regular expression, or the result is undefined. -// -// The algorithm is recursive, but the recursion depth doesn't exceed -// the regex length, so we won't need to worry about running out of -// stack space normally. In rare cases the time complexity can be -// exponential with respect to the regex length + the string length, -// but usually it's must faster (often close to linear). -bool MatchRegexAnywhere(const char* regex, const char* str) { - if (regex == nullptr || str == nullptr) return false; - - if (*regex == '^') return MatchRegexAtHead(regex + 1, str); - - // A successful match can be anywhere in str. - do { - if (MatchRegexAtHead(regex, str)) return true; - } while (*str++ != '\0'); - return false; -} - -// Implements the RE class. +#elif defined(GTEST_USES_STD_RE) RE::~RE() = default; // Returns true if and only if regular expression re matches the entire str. bool RE::FullMatch(const char* str, const RE& re) { - return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_.c_str(), str); + if (!re.is_valid_ || str == nullptr) return false; + return std::regex_match(str, re.regex_); } // Returns true if and only if regular expression re matches a substring of // str (including str itself). bool RE::PartialMatch(const char* str, const RE& re) { - return re.is_valid_ && MatchRegexAnywhere(re.pattern_.c_str(), str); + if (!re.is_valid_ || str == nullptr) return false; + return std::regex_search(str, re.regex_); } // Initializes an RE from its string representation. void RE::Init(const char* regex) { - full_pattern_.clear(); - pattern_.clear(); + pattern_ = regex == nullptr ? "" : regex; + is_valid_ = false; - if (regex != nullptr) { - pattern_ = regex; - } - - is_valid_ = ValidateRegex(regex); - if (!is_valid_) { - // No need to calculate the full pattern when the regex is invalid. + if (regex == nullptr) { + ADD_FAILURE() << "NULL is not a valid regular expression."; return; } - // Reserves enough bytes to hold the regular expression used for a - // full match: we need space to prepend a '^' and append a '$'. - full_pattern_.reserve(pattern_.size() + 2); - - if (pattern_.empty() || pattern_.front() != '^') { - full_pattern_.push_back('^'); // Makes sure full_pattern_ starts with '^'. +#if GTEST_HAS_EXCEPTIONS + try { + regex_ = std::regex(regex, std::regex_constants::ECMAScript); + } catch (const std::regex_error& e) { + ADD_FAILURE() << "Regular expression \"" << regex + << "\" is not a valid regular expression: " << e.what(); + return; } +#else + regex_ = std::regex(regex, std::regex_constants::ECMAScript); +#endif - full_pattern_.append(pattern_); - - if (pattern_.empty() || pattern_.back() != '$') { - full_pattern_.push_back('$'); // Makes sure full_pattern_ ends with '$'. - } + is_valid_ = true; } #endif // GTEST_USES_POSIX_RE diff --git a/googletest/test/googletest-death-test-test.cc b/googletest/test/googletest-death-test-test.cc index 39987e61..c7ea2019 100644 --- a/googletest/test/googletest-death-test-test.cc +++ b/googletest/test/googletest-death-test-test.cc @@ -1362,11 +1362,8 @@ void DieWithMessage(const char* message) { TEST(MatcherDeathTest, DoesNotBreakBareRegexMatching) { // googletest tests this, of course; here we ensure that including googlemock // has not broken it. -#ifdef GTEST_USES_POSIX_RE EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I d[aeiou]e"); -#else EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I di?e"); -#endif } TEST(MatcherDeathTest, MonomorphicMatcherMatches) { diff --git a/googletest/test/googletest-port-test.cc b/googletest/test/googletest-port-test.cc index 24fcd9d9..0cfc8b87 100644 --- a/googletest/test/googletest-port-test.cc +++ b/googletest/test/googletest-port-test.cc @@ -395,11 +395,11 @@ TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) { #elif GTEST_HAS_POSIX_RE EXPECT_TRUE(GTEST_USES_POSIX_RE); #else - EXPECT_TRUE(GTEST_USES_SIMPLE_RE); + EXPECT_TRUE(GTEST_USES_STD_RE); #endif } -#ifdef GTEST_USES_POSIX_RE +#if defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_STD_RE) template class RETest : public ::testing::Test {}; @@ -424,9 +424,15 @@ TYPED_TEST(RETest, ImplicitConstructorWorks) { // Tests that RE's constructors reject invalid regular expressions. TYPED_TEST(RETest, RejectsInvalidRegex) { +#ifdef GTEST_USES_POSIX_RE EXPECT_NONFATAL_FAILURE( { const RE invalid(TypeParam("?")); }, "\"?\" is not a valid POSIX Extended regular expression."); +#elif GTEST_USES_STD_RE && GTEST_HAS_EXCEPTIONS + EXPECT_NONFATAL_FAILURE( + { const RE invalid(TypeParam("?")); }, + "\"?\" is not a valid regular expression"); +#endif } // Tests RE::FullMatch(). @@ -456,467 +462,7 @@ TYPED_TEST(RETest, PartialMatchWorks) { EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re)); } -#elif defined(GTEST_USES_SIMPLE_RE) - -TEST(IsInSetTest, NulCharIsNotInAnySet) { - EXPECT_FALSE(IsInSet('\0', "")); - EXPECT_FALSE(IsInSet('\0', "\0")); - EXPECT_FALSE(IsInSet('\0', "a")); -} - -TEST(IsInSetTest, WorksForNonNulChars) { - EXPECT_FALSE(IsInSet('a', "Ab")); - EXPECT_FALSE(IsInSet('c', "")); - - EXPECT_TRUE(IsInSet('b', "bcd")); - EXPECT_TRUE(IsInSet('b', "ab")); -} - -TEST(IsAsciiDigitTest, IsFalseForNonDigit) { - EXPECT_FALSE(IsAsciiDigit('\0')); - EXPECT_FALSE(IsAsciiDigit(' ')); - EXPECT_FALSE(IsAsciiDigit('+')); - EXPECT_FALSE(IsAsciiDigit('-')); - EXPECT_FALSE(IsAsciiDigit('.')); - EXPECT_FALSE(IsAsciiDigit('a')); -} - -TEST(IsAsciiDigitTest, IsTrueForDigit) { - EXPECT_TRUE(IsAsciiDigit('0')); - EXPECT_TRUE(IsAsciiDigit('1')); - EXPECT_TRUE(IsAsciiDigit('5')); - EXPECT_TRUE(IsAsciiDigit('9')); -} - -TEST(IsAsciiPunctTest, IsFalseForNonPunct) { - EXPECT_FALSE(IsAsciiPunct('\0')); - EXPECT_FALSE(IsAsciiPunct(' ')); - EXPECT_FALSE(IsAsciiPunct('\n')); - EXPECT_FALSE(IsAsciiPunct('a')); - EXPECT_FALSE(IsAsciiPunct('0')); -} - -TEST(IsAsciiPunctTest, IsTrueForPunct) { - for (const char* p = "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"; *p; p++) { - EXPECT_PRED1(IsAsciiPunct, *p); - } -} - -TEST(IsRepeatTest, IsFalseForNonRepeatChar) { - EXPECT_FALSE(IsRepeat('\0')); - EXPECT_FALSE(IsRepeat(' ')); - EXPECT_FALSE(IsRepeat('a')); - EXPECT_FALSE(IsRepeat('1')); - EXPECT_FALSE(IsRepeat('-')); -} - -TEST(IsRepeatTest, IsTrueForRepeatChar) { - EXPECT_TRUE(IsRepeat('?')); - EXPECT_TRUE(IsRepeat('*')); - EXPECT_TRUE(IsRepeat('+')); -} - -TEST(IsAsciiWhiteSpaceTest, IsFalseForNonWhiteSpace) { - EXPECT_FALSE(IsAsciiWhiteSpace('\0')); - EXPECT_FALSE(IsAsciiWhiteSpace('a')); - EXPECT_FALSE(IsAsciiWhiteSpace('1')); - EXPECT_FALSE(IsAsciiWhiteSpace('+')); - EXPECT_FALSE(IsAsciiWhiteSpace('_')); -} - -TEST(IsAsciiWhiteSpaceTest, IsTrueForWhiteSpace) { - EXPECT_TRUE(IsAsciiWhiteSpace(' ')); - EXPECT_TRUE(IsAsciiWhiteSpace('\n')); - EXPECT_TRUE(IsAsciiWhiteSpace('\r')); - EXPECT_TRUE(IsAsciiWhiteSpace('\t')); - EXPECT_TRUE(IsAsciiWhiteSpace('\v')); - EXPECT_TRUE(IsAsciiWhiteSpace('\f')); -} - -TEST(IsAsciiWordCharTest, IsFalseForNonWordChar) { - EXPECT_FALSE(IsAsciiWordChar('\0')); - EXPECT_FALSE(IsAsciiWordChar('+')); - EXPECT_FALSE(IsAsciiWordChar('.')); - EXPECT_FALSE(IsAsciiWordChar(' ')); - EXPECT_FALSE(IsAsciiWordChar('\n')); -} - -TEST(IsAsciiWordCharTest, IsTrueForLetter) { - EXPECT_TRUE(IsAsciiWordChar('a')); - EXPECT_TRUE(IsAsciiWordChar('b')); - EXPECT_TRUE(IsAsciiWordChar('A')); - EXPECT_TRUE(IsAsciiWordChar('Z')); -} - -TEST(IsAsciiWordCharTest, IsTrueForDigit) { - EXPECT_TRUE(IsAsciiWordChar('0')); - EXPECT_TRUE(IsAsciiWordChar('1')); - EXPECT_TRUE(IsAsciiWordChar('7')); - EXPECT_TRUE(IsAsciiWordChar('9')); -} - -TEST(IsAsciiWordCharTest, IsTrueForUnderscore) { - EXPECT_TRUE(IsAsciiWordChar('_')); -} - -TEST(IsValidEscapeTest, IsFalseForNonPrintable) { - EXPECT_FALSE(IsValidEscape('\0')); - EXPECT_FALSE(IsValidEscape('\007')); -} - -TEST(IsValidEscapeTest, IsFalseForDigit) { - EXPECT_FALSE(IsValidEscape('0')); - EXPECT_FALSE(IsValidEscape('9')); -} - -TEST(IsValidEscapeTest, IsFalseForWhiteSpace) { - EXPECT_FALSE(IsValidEscape(' ')); - EXPECT_FALSE(IsValidEscape('\n')); -} - -TEST(IsValidEscapeTest, IsFalseForSomeLetter) { - EXPECT_FALSE(IsValidEscape('a')); - EXPECT_FALSE(IsValidEscape('Z')); -} - -TEST(IsValidEscapeTest, IsTrueForPunct) { - EXPECT_TRUE(IsValidEscape('.')); - EXPECT_TRUE(IsValidEscape('-')); - EXPECT_TRUE(IsValidEscape('^')); - EXPECT_TRUE(IsValidEscape('$')); - EXPECT_TRUE(IsValidEscape('(')); - EXPECT_TRUE(IsValidEscape(']')); - EXPECT_TRUE(IsValidEscape('{')); - EXPECT_TRUE(IsValidEscape('|')); -} - -TEST(IsValidEscapeTest, IsTrueForSomeLetter) { - EXPECT_TRUE(IsValidEscape('d')); - EXPECT_TRUE(IsValidEscape('D')); - EXPECT_TRUE(IsValidEscape('s')); - EXPECT_TRUE(IsValidEscape('S')); - EXPECT_TRUE(IsValidEscape('w')); - EXPECT_TRUE(IsValidEscape('W')); -} - -TEST(AtomMatchesCharTest, EscapedPunct) { - EXPECT_FALSE(AtomMatchesChar(true, '\\', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, '\\', ' ')); - EXPECT_FALSE(AtomMatchesChar(true, '_', '.')); - EXPECT_FALSE(AtomMatchesChar(true, '.', 'a')); - - EXPECT_TRUE(AtomMatchesChar(true, '\\', '\\')); - EXPECT_TRUE(AtomMatchesChar(true, '_', '_')); - EXPECT_TRUE(AtomMatchesChar(true, '+', '+')); - EXPECT_TRUE(AtomMatchesChar(true, '.', '.')); -} - -TEST(AtomMatchesCharTest, Escaped_d) { - EXPECT_FALSE(AtomMatchesChar(true, 'd', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'd', 'a')); - EXPECT_FALSE(AtomMatchesChar(true, 'd', '.')); - - EXPECT_TRUE(AtomMatchesChar(true, 'd', '0')); - EXPECT_TRUE(AtomMatchesChar(true, 'd', '9')); -} - -TEST(AtomMatchesCharTest, Escaped_D) { - EXPECT_FALSE(AtomMatchesChar(true, 'D', '0')); - EXPECT_FALSE(AtomMatchesChar(true, 'D', '9')); - - EXPECT_TRUE(AtomMatchesChar(true, 'D', '\0')); - EXPECT_TRUE(AtomMatchesChar(true, 'D', 'a')); - EXPECT_TRUE(AtomMatchesChar(true, 'D', '-')); -} - -TEST(AtomMatchesCharTest, Escaped_s) { - EXPECT_FALSE(AtomMatchesChar(true, 's', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 's', 'a')); - EXPECT_FALSE(AtomMatchesChar(true, 's', '.')); - EXPECT_FALSE(AtomMatchesChar(true, 's', '9')); - - EXPECT_TRUE(AtomMatchesChar(true, 's', ' ')); - EXPECT_TRUE(AtomMatchesChar(true, 's', '\n')); - EXPECT_TRUE(AtomMatchesChar(true, 's', '\t')); -} - -TEST(AtomMatchesCharTest, Escaped_S) { - EXPECT_FALSE(AtomMatchesChar(true, 'S', ' ')); - EXPECT_FALSE(AtomMatchesChar(true, 'S', '\r')); - - EXPECT_TRUE(AtomMatchesChar(true, 'S', '\0')); - EXPECT_TRUE(AtomMatchesChar(true, 'S', 'a')); - EXPECT_TRUE(AtomMatchesChar(true, 'S', '9')); -} - -TEST(AtomMatchesCharTest, Escaped_w) { - EXPECT_FALSE(AtomMatchesChar(true, 'w', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'w', '+')); - EXPECT_FALSE(AtomMatchesChar(true, 'w', ' ')); - EXPECT_FALSE(AtomMatchesChar(true, 'w', '\n')); - - EXPECT_TRUE(AtomMatchesChar(true, 'w', '0')); - EXPECT_TRUE(AtomMatchesChar(true, 'w', 'b')); - EXPECT_TRUE(AtomMatchesChar(true, 'w', 'C')); - EXPECT_TRUE(AtomMatchesChar(true, 'w', '_')); -} - -TEST(AtomMatchesCharTest, Escaped_W) { - EXPECT_FALSE(AtomMatchesChar(true, 'W', 'A')); - EXPECT_FALSE(AtomMatchesChar(true, 'W', 'b')); - EXPECT_FALSE(AtomMatchesChar(true, 'W', '9')); - EXPECT_FALSE(AtomMatchesChar(true, 'W', '_')); - - EXPECT_TRUE(AtomMatchesChar(true, 'W', '\0')); - EXPECT_TRUE(AtomMatchesChar(true, 'W', '*')); - EXPECT_TRUE(AtomMatchesChar(true, 'W', '\n')); -} - -TEST(AtomMatchesCharTest, EscapedWhiteSpace) { - EXPECT_FALSE(AtomMatchesChar(true, 'f', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'f', '\n')); - EXPECT_FALSE(AtomMatchesChar(true, 'n', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'n', '\r')); - EXPECT_FALSE(AtomMatchesChar(true, 'r', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'r', 'a')); - EXPECT_FALSE(AtomMatchesChar(true, 't', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 't', 't')); - EXPECT_FALSE(AtomMatchesChar(true, 'v', '\0')); - EXPECT_FALSE(AtomMatchesChar(true, 'v', '\f')); - - EXPECT_TRUE(AtomMatchesChar(true, 'f', '\f')); - EXPECT_TRUE(AtomMatchesChar(true, 'n', '\n')); - EXPECT_TRUE(AtomMatchesChar(true, 'r', '\r')); - EXPECT_TRUE(AtomMatchesChar(true, 't', '\t')); - EXPECT_TRUE(AtomMatchesChar(true, 'v', '\v')); -} - -TEST(AtomMatchesCharTest, UnescapedDot) { - EXPECT_FALSE(AtomMatchesChar(false, '.', '\n')); - - EXPECT_TRUE(AtomMatchesChar(false, '.', '\0')); - EXPECT_TRUE(AtomMatchesChar(false, '.', '.')); - EXPECT_TRUE(AtomMatchesChar(false, '.', 'a')); - EXPECT_TRUE(AtomMatchesChar(false, '.', ' ')); -} - -TEST(AtomMatchesCharTest, UnescapedChar) { - EXPECT_FALSE(AtomMatchesChar(false, 'a', '\0')); - EXPECT_FALSE(AtomMatchesChar(false, 'a', 'b')); - EXPECT_FALSE(AtomMatchesChar(false, '$', 'a')); - - EXPECT_TRUE(AtomMatchesChar(false, '$', '$')); - EXPECT_TRUE(AtomMatchesChar(false, '5', '5')); - EXPECT_TRUE(AtomMatchesChar(false, 'Z', 'Z')); -} - -TEST(ValidateRegexTest, GeneratesFailureAndReturnsFalseForInvalid) { - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(NULL)), - "NULL is not a valid simple regular expression"); - EXPECT_NONFATAL_FAILURE( - ASSERT_FALSE(ValidateRegex("a\\")), - "Syntax error at index 1 in simple regular expression \"a\\\": "); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a\\")), - "'\\' cannot appear at the end"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\n\\")), - "'\\' cannot appear at the end"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("\\s\\hb")), - "invalid escape sequence \"\\h\""); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^^")), - "'^' can only appear at the beginning"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex(".*^b")), - "'^' can only appear at the beginning"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("$$")), - "'$' can only appear at the end"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^$a")), - "'$' can only appear at the end"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a(b")), - "'(' is unsupported"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("ab)")), - "')' is unsupported"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("[ab")), - "'[' is unsupported"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("a{2")), - "'{' is unsupported"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("?")), - "'?' can only follow a repeatable token"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("^*")), - "'*' can only follow a repeatable token"); - EXPECT_NONFATAL_FAILURE(ASSERT_FALSE(ValidateRegex("5*+")), - "'+' can only follow a repeatable token"); -} - -TEST(ValidateRegexTest, ReturnsTrueForValid) { - EXPECT_TRUE(ValidateRegex("")); - EXPECT_TRUE(ValidateRegex("a")); - EXPECT_TRUE(ValidateRegex(".*")); - EXPECT_TRUE(ValidateRegex("^a_+")); - EXPECT_TRUE(ValidateRegex("^a\\t\\&?")); - EXPECT_TRUE(ValidateRegex("09*$")); - EXPECT_TRUE(ValidateRegex("^Z$")); - EXPECT_TRUE(ValidateRegex("a\\^Z\\$\\(\\)\\|\\[\\]\\{\\}")); -} - -TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrOne) { - EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "a", "ba")); - // Repeating more than once. - EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "aab")); - - // Repeating zero times. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ba")); - // Repeating once. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, 'a', '?', "b", "ab")); - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '#', '?', ".", "##")); -} - -TEST(MatchRepetitionAndRegexAtHeadTest, WorksForZeroOrMany) { - EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '*', "a$", "baab")); - - // Repeating zero times. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "bc")); - // Repeating once. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '*', "b", "abc")); - // Repeating more than once. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '*', "-", "ab_1-g")); -} - -TEST(MatchRepetitionAndRegexAtHeadTest, WorksForOneOrMany) { - EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "a$", "baab")); - // Repeating zero times. - EXPECT_FALSE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "bc")); - - // Repeating once. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(false, '.', '+', "b", "abc")); - // Repeating more than once. - EXPECT_TRUE(MatchRepetitionAndRegexAtHead(true, 'w', '+', "-", "ab_1-g")); -} - -TEST(MatchRegexAtHeadTest, ReturnsTrueForEmptyRegex) { - EXPECT_TRUE(MatchRegexAtHead("", "")); - EXPECT_TRUE(MatchRegexAtHead("", "ab")); -} - -TEST(MatchRegexAtHeadTest, WorksWhenDollarIsInRegex) { - EXPECT_FALSE(MatchRegexAtHead("$", "a")); - - EXPECT_TRUE(MatchRegexAtHead("$", "")); - EXPECT_TRUE(MatchRegexAtHead("a$", "a")); -} - -TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithEscapeSequence) { - EXPECT_FALSE(MatchRegexAtHead("\\w", "+")); - EXPECT_FALSE(MatchRegexAtHead("\\W", "ab")); - - EXPECT_TRUE(MatchRegexAtHead("\\sa", "\nab")); - EXPECT_TRUE(MatchRegexAtHead("\\d", "1a")); -} - -TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) { - EXPECT_FALSE(MatchRegexAtHead(".+a", "abc")); - EXPECT_FALSE(MatchRegexAtHead("a?b", "aab")); - - EXPECT_TRUE(MatchRegexAtHead(".*a", "bc12-ab")); - EXPECT_TRUE(MatchRegexAtHead("a?b", "b")); - EXPECT_TRUE(MatchRegexAtHead("a?b", "ab")); -} - -TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetionOfEscapeSequence) { - EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc")); - EXPECT_FALSE(MatchRegexAtHead("\\s?b", " b")); - - EXPECT_TRUE(MatchRegexAtHead("\\(*a", "((((ab")); - EXPECT_TRUE(MatchRegexAtHead("\\^?b", "^b")); - EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "b")); - EXPECT_TRUE(MatchRegexAtHead("\\\\?b", "\\b")); -} - -TEST(MatchRegexAtHeadTest, MatchesSequentially) { - EXPECT_FALSE(MatchRegexAtHead("ab.*c", "acabc")); - - EXPECT_TRUE(MatchRegexAtHead("ab.*c", "ab-fsc")); -} - -TEST(MatchRegexAnywhereTest, ReturnsFalseWhenStringIsNull) { - EXPECT_FALSE(MatchRegexAnywhere("", NULL)); -} - -TEST(MatchRegexAnywhereTest, WorksWhenRegexStartsWithCaret) { - EXPECT_FALSE(MatchRegexAnywhere("^a", "ba")); - EXPECT_FALSE(MatchRegexAnywhere("^$", "a")); - - EXPECT_TRUE(MatchRegexAnywhere("^a", "ab")); - EXPECT_TRUE(MatchRegexAnywhere("^", "ab")); - EXPECT_TRUE(MatchRegexAnywhere("^$", "")); -} - -TEST(MatchRegexAnywhereTest, ReturnsFalseWhenNoMatch) { - EXPECT_FALSE(MatchRegexAnywhere("a", "bcde123")); - EXPECT_FALSE(MatchRegexAnywhere("a.+a", "--aa88888888")); -} - -TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingPrefix) { - EXPECT_TRUE(MatchRegexAnywhere("\\w+", "ab1_ - 5")); - EXPECT_TRUE(MatchRegexAnywhere(".*=", "=")); - EXPECT_TRUE(MatchRegexAnywhere("x.*ab?.*bc", "xaaabc")); -} - -TEST(MatchRegexAnywhereTest, ReturnsTrueWhenMatchingNonPrefix) { - EXPECT_TRUE(MatchRegexAnywhere("\\w+", "$$$ ab1_ - 5")); - EXPECT_TRUE(MatchRegexAnywhere("\\.+=", "= ...=")); -} - -// Tests RE's implicit constructors. -TEST(RETest, ImplicitConstructorWorks) { - const RE empty(""); - EXPECT_STREQ("", empty.pattern()); - - const RE simple("hello"); - EXPECT_STREQ("hello", simple.pattern()); -} - -// Tests that RE's constructors reject invalid regular expressions. -TEST(RETest, RejectsInvalidRegex) { - EXPECT_NONFATAL_FAILURE({ const RE normal(NULL); }, - "NULL is not a valid simple regular expression"); - - EXPECT_NONFATAL_FAILURE({ const RE normal(".*(\\w+"); }, - "'(' is unsupported"); - - EXPECT_NONFATAL_FAILURE({ const RE invalid("^?"); }, - "'?' can only follow a repeatable token"); -} - -// Tests RE::FullMatch(). -TEST(RETest, FullMatchWorks) { - const RE empty(""); - EXPECT_TRUE(RE::FullMatch("", empty)); - EXPECT_FALSE(RE::FullMatch("a", empty)); - - const RE re1("a"); - EXPECT_TRUE(RE::FullMatch("a", re1)); - - const RE re("a.*z"); - EXPECT_TRUE(RE::FullMatch("az", re)); - EXPECT_TRUE(RE::FullMatch("axyz", re)); - EXPECT_FALSE(RE::FullMatch("baz", re)); - EXPECT_FALSE(RE::FullMatch("azy", re)); -} - -// Tests RE::PartialMatch(). -TEST(RETest, PartialMatchWorks) { - const RE empty(""); - EXPECT_TRUE(RE::PartialMatch("", empty)); - EXPECT_TRUE(RE::PartialMatch("a", empty)); - - const RE re("a.*z"); - EXPECT_TRUE(RE::PartialMatch("az", re)); - EXPECT_TRUE(RE::PartialMatch("axyz", re)); - EXPECT_TRUE(RE::PartialMatch("baz", re)); - EXPECT_TRUE(RE::PartialMatch("azy", re)); - EXPECT_FALSE(RE::PartialMatch("zza", re)); -} - -#endif // GTEST_USES_POSIX_RE +#endif // GTEST_USES_POSIX_RE || GTEST_USES_STD_RE #ifndef GTEST_OS_WINDOWS_MOBILE