mirror of
https://github.com/google/googletest.git
synced 2026-09-25 04:09:59 +03:00
Use std::regex (defining GTEST_USES_STD_RE) instead of hand-rolled regex engine (defining GTEST_USES_SIMPLE_RE) in GoogleTest
Previously, non-Abseil builds of GoogleTest used either the POSIX <regex.h> header, or a hand-rolled bare-bones regex engine in GoogleTest.
This commit removes the custom regex engine and switches to the C++11 <regex> header instead, which primarily affects Windows builds. Correspondingly, the GTEST_USES_SIMPLE_RE macro is removed and GTEST_USES_STD_RE is defined in its place, so users that depend on the macro should update their code accordingly.
This commit may break on any exotic toolchains or platforms that lack all of these libraries, but these have been long unsupported, as GoogleTest requires C++17.
Note: MSVC's engine can be prone to overflowing the stack on some patterns and inputs. As a trivial example:
#include <regex>
int main() {
std::string corpus;
for (size_t i = 0; i < 1000; ++i) {
corpus += "a\n";
}
// Stack overflow
std::regex_match(corpus, std::regex("(\n|.)*", std::regex_constants::ECMAScript));
}
In such cases, it is recommended to use alternative patterns accomplishing the same goal, such as checking for pieces of a pattern independently.
PiperOrigin-RevId: 978659894
Change-Id: I4594285e696af12a008e1e4cee300f292bbdbf32
This commit is contained in:
Abseil Team
committed by
Copybara-Service
Copybara-Service
parent
7e91a413e8
commit
dd0a37b843
+7
-32
@@ -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
|
||||
|
||||
|
||||
@@ -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 <regex> 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);
|
||||
|
||||
@@ -105,54 +105,10 @@ GTEST_API_ bool InDeathTestChild();
|
||||
//
|
||||
// On the regular expressions used in death tests:
|
||||
//
|
||||
// On POSIX-compliant systems (*nix), we use the <regex.h> 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 <regex.h> library,
|
||||
// the C++11 standard library's <regex> 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:
|
||||
//
|
||||
|
||||
@@ -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 <regex.h> // 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 <regex> // 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 <regex.h>. It uses the POSIX Extended
|
||||
// Regular Expression syntax.
|
||||
// A simple C++ wrapper for <regex.h> or <regex>.
|
||||
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
|
||||
};
|
||||
|
||||
@@ -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.
|
||||
|
||||
+20
-223
@@ -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 <ctype.h>, 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<size_t>(-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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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 <typename Str>
|
||||
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
|
||||
|
||||
|
||||
Reference in New Issue
Block a user