coffee/googletest
1
0
Fork 0
mirror of https://github.com/google/googletest.git synced 2026-07-30 16:26:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Make string matchers work with std::wstring_view

Browse Source 
Fixes: #4912
PiperOrigin-RevId: 953423131
Change-Id: Id288c01c9d1bd9c92ce78b89ec3e8587f4ffc2a7
This commit is contained in:
Abseil Team 2026-07-24 10:02:48 -07:00 committed by Copybara-Service
parent a798392000
commit fef8e5e23b
3 changed files with 77 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
googlemock/include/gmock/gmock-matchers.h
View File

@ -4982,116 +4982,68 @@ internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
// Matches a string equal to str. // Matches a string equal to str.
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrEq( PolymorphicMatcher<internal::StrEqualityMatcher<internal::StringType<T>>> StrEq(
const internal::StringLike<T>& str) { const T& str) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::string>(std::string(str), true, true)); internal::StrEqualityMatcher<internal::StringType<T>>(
internal::StringType<T>(str), true, true));
} }
// Matches a string not equal to str. // Matches a string not equal to str.
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrNe( PolymorphicMatcher<internal::StrEqualityMatcher<internal::StringType<T>>> StrNe(
const internal::StringLike<T>& str) { const T& str) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::string>(std::string(str), false, true)); internal::StrEqualityMatcher<internal::StringType<T>>(
internal::StringType<T>(str), false, true));
} }
// Matches a string equal to str, ignoring case. // Matches a string equal to str, ignoring case.
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseEq( PolymorphicMatcher<internal::StrEqualityMatcher<internal::StringType<T>>>
const internal::StringLike<T>& str) { StrCaseEq(const T& str) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::string>(std::string(str), true, false)); internal::StrEqualityMatcher<internal::StringType<T>>(
internal::StringType<T>(str), true, false));
} }
// Matches a string not equal to str, ignoring case. // Matches a string not equal to str, ignoring case.
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseNe( PolymorphicMatcher<internal::StrEqualityMatcher<internal::StringType<T>>>
const internal::StringLike<T>& str) { StrCaseNe(const T& str) {
return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>( return MakePolymorphicMatcher(
std::string(str), false, false)); internal::StrEqualityMatcher<internal::StringType<T>>(
internal::StringType<T>(str), false, false));
} }
// Creates a matcher that matches any string, std::string, or C string // Creates a matcher that matches any string, std::string, or C string
// that contains the given substring. // that contains the given substring.
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::HasSubstrMatcher<std::string>> HasSubstr( PolymorphicMatcher<internal::HasSubstrMatcher<internal::StringType<T>>>
const internal::StringLike<T>& substring) { HasSubstr(const T& substring) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::HasSubstrMatcher<std::string>(std::string(substring))); internal::HasSubstrMatcher<internal::StringType<T>>(
internal::StringType<T>(substring)));
} }
// Matches a string that starts with 'prefix' (case-sensitive). // Matches a string that starts with 'prefix' (case-sensitive).
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::StartsWithMatcher<std::string>> StartsWith( PolymorphicMatcher<internal::StartsWithMatcher<internal::StringType<T>>>
const internal::StringLike<T>& prefix) { StartsWith(const T& prefix) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::StartsWithMatcher<std::string>(std::string(prefix))); internal::StartsWithMatcher<internal::StringType<T>>(
internal::StringType<T>(prefix)));
} }
// Matches a string that ends with 'suffix' (case-sensitive). // Matches a string that ends with 'suffix' (case-sensitive).
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::EndsWithMatcher<std::string>> EndsWith( PolymorphicMatcher<internal::EndsWithMatcher<internal::StringType<T>>> EndsWith(
const internal::StringLike<T>& suffix) { const T& suffix) {
return MakePolymorphicMatcher( return MakePolymorphicMatcher(
internal::EndsWithMatcher<std::string>(std::string(suffix))); internal::EndsWithMatcher<internal::StringType<T>>(
internal::StringType<T>(suffix)));
} }
#if GTEST_HAS_STD_WSTRING
// Wide string matchers.
// Matches a string equal to str.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrEq(
const std::wstring& str) {
return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::wstring>(str, true, true));
}
// Matches a string not equal to str.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrNe(
const std::wstring& str) {
return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::wstring>(str, false, true));
}
// Matches a string equal to str, ignoring case.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseEq(
const std::wstring& str) {
return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::wstring>(str, true, false));
}
// Matches a string not equal to str, ignoring case.
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseNe(
const std::wstring& str) {
return MakePolymorphicMatcher(
internal::StrEqualityMatcher<std::wstring>(str, false, false));
}
// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
// that contains the given substring.
inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasSubstr(
const std::wstring& substring) {
return MakePolymorphicMatcher(
internal::HasSubstrMatcher<std::wstring>(substring));
}
// Matches a string that starts with 'prefix' (case-sensitive).
inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> StartsWith(
const std::wstring& prefix) {
return MakePolymorphicMatcher(
internal::StartsWithMatcher<std::wstring>(prefix));
}
// Matches a string that ends with 'suffix' (case-sensitive).
inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsWith(
const std::wstring& suffix) {
return MakePolymorphicMatcher(
internal::EndsWithMatcher<std::wstring>(suffix));
}
#endif // GTEST_HAS_STD_WSTRING
// Creates a polymorphic matcher that matches a 2-tuple where the // Creates a polymorphic matcher that matches a 2-tuple where the
// first field == the second field. // first field == the second field.
inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); } inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }

18
googlemock/test/gmock-matchers-comparisons_test.cc
View File

@ -1254,22 +1254,22 @@ TEST(RefTest, ExplainsResult) {
// Tests string comparison matchers. // Tests string comparison matchers.
template <typename T = std::string> template <typename T = std::string>
std::string FromStringLike(internal::StringLike<T> str) { internal::StringType<T> ToString(T str) {
return std::string(str); return internal::StringType<T>(str);
} }
TEST(StringLike, TestConversions) { TEST(StringType, TestConversions) {
EXPECT_EQ("foo", FromStringLike("foo")); EXPECT_EQ("foo", ToString("foo"));
EXPECT_EQ("foo", FromStringLike(std::string("foo"))); EXPECT_EQ("foo", ToString(std::string("foo")));
#if GTEST_INTERNAL_HAS_STRING_VIEW #if GTEST_INTERNAL_HAS_STRING_VIEW
EXPECT_EQ("foo", FromStringLike(internal::StringView("foo"))); EXPECT_EQ("foo", ToString(internal::StringView("foo")));
#endif // GTEST_INTERNAL_HAS_STRING_VIEW #endif // GTEST_INTERNAL_HAS_STRING_VIEW
// Non deducible types. // Non deducible types.
EXPECT_EQ("", FromStringLike({})); EXPECT_EQ("", ToString({}));
EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'})); EXPECT_EQ("foo", ToString({'f', 'o', 'o'}));
const char buf[] = "foo"; const char buf[] = "foo";
EXPECT_EQ("foo", FromStringLike({buf, buf + 3})); EXPECT_EQ("foo", ToString({buf, buf + 3}));
} }
TEST(StrEqTest, MatchesEqualString) { TEST(StrEqTest, MatchesEqualString) {

48
googletest/include/gtest/gtest-matchers.h
View File

@ -45,6 +45,7 @@
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <string> #include <string>
#include <string_view>
#include <type_traits> #include <type_traits>
#include "gtest/gtest-printers.h" #include "gtest/gtest-printers.h"
@ -812,9 +813,36 @@ class [[nodiscard]] ImplicitCastEqMatcher {
StoredRhs stored_rhs_; StoredRhs stored_rhs_;
}; };
template <typename T, // Dummy function (never defined) whose return type evaluates to std::string if
typename = std::enable_if_t<std::is_constructible_v<std::string, T>>> // the given type is a string-like type that can be converted to std::string,
using StringLike = T; // either directly or through an intermediate std::string_view.
template <class T>
extern std::enable_if_t<std::is_convertible_v<T, std::string> ||
(std::is_constructible_v<std::string, T> &&
std::is_convertible_v<T, internal::StringView>),
std::string>
ResolveAsString(const void* /* preferred */);
#if GTEST_HAS_STD_WSTRING
// Same as above, but for std::wstring. In cases where both conversions are
// possible, this overload takes lower priority.
template <class T>
extern std::enable_if_t<std::is_convertible_v<T, std::wstring> ||
(std::is_constructible_v<std::wstring, T> &&
std::is_convertible_v<T, std::wstring_view>),
std::wstring>
ResolveAsString(... /* fallback */);
#endif
// Evaluates to the std::basic_string type that the given string-like type can
// be converted to. Prefers std::string over std::wstring if both are possible.
// Fails in a SFINAE-friendly way if no conversion was viable.
//
// For example, const char* and std::string_view would both evaluate to
// std::string, but std::allocator<char> would fail to evaluate via SFINAE
// (despite std::string being constructible from it).
template <typename T>
using StringType = decltype(ResolveAsString<T>(nullptr));
// Implements polymorphic matchers MatchesRegex(regex) and // Implements polymorphic matchers MatchesRegex(regex) and
// ContainsRegex(regex), which can be used as a Matcher<T> as long as // ContainsRegex(regex), which can be used as a Matcher<T> as long as
@ -877,9 +905,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true)); return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
} }
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( std::enable_if_t<std::is_constructible_v<internal::RE, internal::StringType<T>>,
const internal::StringLike<T>& regex) { PolymorphicMatcher<internal::MatchesRegexMatcher>>
return MatchesRegex(new internal::RE(std::string(regex))); MatchesRegex(const T& regex) {
return MatchesRegex(new internal::RE(internal::StringType<T>(regex)));
} }
// Matches a string that contains regular expression 'regex'. // Matches a string that contains regular expression 'regex'.
@ -889,9 +918,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false)); return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
} }
template <typename T = std::string> template <typename T = std::string>
PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( std::enable_if_t<std::is_constructible_v<internal::RE, internal::StringType<T>>,
const internal::StringLike<T>& regex) { PolymorphicMatcher<internal::MatchesRegexMatcher>>
return ContainsRegex(new internal::RE(std::string(regex))); ContainsRegex(const T& regex) {
return ContainsRegex(new internal::RE(internal::StringType<T>(regex)));
} }
// Creates a polymorphic matcher that matches anything equal to x. // Creates a polymorphic matcher that matches anything equal to x.