Skip to content

Commit 13a433a

Browse files
Abseil Teamvslashg
Abseil Team
authored and
vslashg
committed
Googletest export
Change string matchers, like HasSubstr, to accept `string_view` input if available. PiperOrigin-RevId: 315726484
1 parent 9f287b4 commit 13a433a

File tree

3 files changed

+82
-40
lines changed

3 files changed

+82
-40
lines changed

‎googlemock/include/gmock/gmock-matchers.h

+34-25
Original file line numberDiff line numberDiff line change
@@ -903,9 +903,10 @@ bool CaseInsensitiveStringEquals(const StringType& s1,
903903
template <typename StringType>
904904
class StrEqualityMatcher {
905905
public:
906-
StrEqualityMatcher(const StringType& str, bool expect_eq,
907-
bool case_sensitive)
908-
: string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
906+
StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
907+
: string_(std::move(str)),
908+
expect_eq_(expect_eq),
909+
case_sensitive_(case_sensitive) {}
909910

910911
#if GTEST_INTERNAL_HAS_STRING_VIEW
911912
bool MatchAndExplain(const internal::StringView& s,
@@ -3990,52 +3991,60 @@ internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
39903991
// String matchers.
39913992

39923993
// Matches a string equal to str.
3993-
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
3994-
const std::string& str) {
3994+
template <typename T = std::string>
3995+
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
3996+
const internal::StringLike<T>& str) {
39953997
return MakePolymorphicMatcher(
3996-
internal::StrEqualityMatcher<std::string>(str, true, true));
3998+
internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
39973999
}
39984000

39994001
// Matches a string not equal to str.
4000-
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
4001-
const std::string& str) {
4002+
template <typename T = std::string>
4003+
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
4004+
const internal::StringLike<T>& str) {
40024005
return MakePolymorphicMatcher(
4003-
internal::StrEqualityMatcher<std::string>(str, false, true));
4006+
internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
40044007
}
40054008

40064009
// Matches a string equal to str, ignoring case.
4007-
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
4008-
const std::string& str) {
4010+
template <typename T = std::string>
4011+
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
4012+
const internal::StringLike<T>& str) {
40094013
return MakePolymorphicMatcher(
4010-
internal::StrEqualityMatcher<std::string>(str, true, false));
4014+
internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
40114015
}
40124016

40134017
// Matches a string not equal to str, ignoring case.
4014-
inline PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
4015-
const std::string& str) {
4016-
return MakePolymorphicMatcher(
4017-
internal::StrEqualityMatcher<std::string>(str, false, false));
4018+
template <typename T = std::string>
4019+
PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
4020+
const internal::StringLike<T>& str) {
4021+
return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
4022+
std::string(str), false, false));
40184023
}
40194024

40204025
// Creates a matcher that matches any string, std::string, or C string
40214026
// that contains the given substring.
4022-
inline PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
4023-
const std::string& substring) {
4027+
template <typename T = std::string>
4028+
PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
4029+
const internal::StringLike<T>& substring) {
40244030
return MakePolymorphicMatcher(
4025-
internal::HasSubstrMatcher<std::string>(substring));
4031+
internal::HasSubstrMatcher<std::string>(std::string(substring)));
40264032
}
40274033

40284034
// Matches a string that starts with 'prefix' (case-sensitive).
4029-
inline PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
4030-
const std::string& prefix) {
4035+
template <typename T = std::string>
4036+
PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
4037+
const internal::StringLike<T>& prefix) {
40314038
return MakePolymorphicMatcher(
4032-
internal::StartsWithMatcher<std::string>(prefix));
4039+
internal::StartsWithMatcher<std::string>(std::string(prefix)));
40334040
}
40344041

40354042
// Matches a string that ends with 'suffix' (case-sensitive).
4036-
inline PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
4037-
const std::string& suffix) {
4038-
return MakePolymorphicMatcher(internal::EndsWithMatcher<std::string>(suffix));
4043+
template <typename T = std::string>
4044+
PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
4045+
const internal::StringLike<T>& suffix) {
4046+
return MakePolymorphicMatcher(
4047+
internal::EndsWithMatcher<std::string>(std::string(suffix)));
40394048
}
40404049

40414050
#if GTEST_HAS_STD_WSTRING

‎googlemock/test/gmock-matchers_test.cc

+36-9
Original file line numberDiff line numberDiff line change
@@ -1226,6 +1226,25 @@ TEST(RefTest, ExplainsResult) {
12261226

12271227
// Tests string comparison matchers.
12281228

1229+
template <typename T = std::string>
1230+
std::string FromStringLike(internal::StringLike<T> str) {
1231+
return std::string(str);
1232+
}
1233+
1234+
TEST(StringLike, TestConversions) {
1235+
EXPECT_EQ("foo", FromStringLike("foo"));
1236+
EXPECT_EQ("foo", FromStringLike(std::string("foo")));
1237+
#if GTEST_INTERNAL_HAS_STRING_VIEW
1238+
EXPECT_EQ("foo", FromStringLike(internal::StringView("foo")));
1239+
#endif // GTEST_INTERNAL_HAS_STRING_VIEW
1240+
1241+
// Non deducible types.
1242+
EXPECT_EQ("", FromStringLike({}));
1243+
EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'}));
1244+
const char buf[] = "foo";
1245+
EXPECT_EQ("foo", FromStringLike({buf, buf + 3}));
1246+
}
1247+
12291248
TEST(StrEqTest, MatchesEqualString) {
12301249
Matcher<const char*> m = StrEq(std::string("Hello"));
12311250
EXPECT_TRUE(m.Matches("Hello"));
@@ -1237,7 +1256,8 @@ TEST(StrEqTest, MatchesEqualString) {
12371256
EXPECT_FALSE(m2.Matches("Hi"));
12381257

12391258
#if GTEST_INTERNAL_HAS_STRING_VIEW
1240-
Matcher<const internal::StringView&> m3 = StrEq("Hello");
1259+
Matcher<const internal::StringView&> m3 =
1260+
StrEq(internal::StringView("Hello"));
12411261
EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
12421262
EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
12431263
EXPECT_FALSE(m3.Matches(internal::StringView()));
@@ -1274,7 +1294,7 @@ TEST(StrNeTest, MatchesUnequalString) {
12741294
EXPECT_FALSE(m2.Matches("Hello"));
12751295

12761296
#if GTEST_INTERNAL_HAS_STRING_VIEW
1277-
Matcher<const internal::StringView> m3 = StrNe("Hello");
1297+
Matcher<const internal::StringView> m3 = StrNe(internal::StringView("Hello"));
12781298
EXPECT_TRUE(m3.Matches(internal::StringView("")));
12791299
EXPECT_TRUE(m3.Matches(internal::StringView()));
12801300
EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
@@ -1298,7 +1318,8 @@ TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
12981318
EXPECT_FALSE(m2.Matches("Hi"));
12991319

13001320
#if GTEST_INTERNAL_HAS_STRING_VIEW
1301-
Matcher<const internal::StringView&> m3 = StrCaseEq(std::string("Hello"));
1321+
Matcher<const internal::StringView&> m3 =
1322+
StrCaseEq(internal::StringView("Hello"));
13021323
EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
13031324
EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
13041325
EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
@@ -1348,7 +1369,8 @@ TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
13481369
EXPECT_FALSE(m2.Matches("Hello"));
13491370

13501371
#if GTEST_INTERNAL_HAS_STRING_VIEW
1351-
Matcher<const internal::StringView> m3 = StrCaseNe("Hello");
1372+
Matcher<const internal::StringView> m3 =
1373+
StrCaseNe(internal::StringView("Hello"));
13521374
EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
13531375
EXPECT_TRUE(m3.Matches(internal::StringView()));
13541376
EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
@@ -1397,7 +1419,8 @@ TEST(HasSubstrTest, WorksForCStrings) {
13971419
#if GTEST_INTERNAL_HAS_STRING_VIEW
13981420
// Tests that HasSubstr() works for matching StringView-typed values.
13991421
TEST(HasSubstrTest, WorksForStringViewClasses) {
1400-
const Matcher<internal::StringView> m1 = HasSubstr("foo");
1422+
const Matcher<internal::StringView> m1 =
1423+
HasSubstr(internal::StringView("foo"));
14011424
EXPECT_TRUE(m1.Matches(internal::StringView("I love food.")));
14021425
EXPECT_FALSE(m1.Matches(internal::StringView("tofo")));
14031426
EXPECT_FALSE(m1.Matches(internal::StringView()));
@@ -1650,7 +1673,8 @@ TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
16501673
EXPECT_FALSE(m2.Matches(" Hi"));
16511674

16521675
#if GTEST_INTERNAL_HAS_STRING_VIEW
1653-
const Matcher<internal::StringView> m_empty = StartsWith("");
1676+
const Matcher<internal::StringView> m_empty =
1677+
StartsWith(internal::StringView(""));
16541678
EXPECT_TRUE(m_empty.Matches(internal::StringView()));
16551679
EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
16561680
EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
@@ -1678,7 +1702,8 @@ TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
16781702
EXPECT_FALSE(m2.Matches("Hi "));
16791703

16801704
#if GTEST_INTERNAL_HAS_STRING_VIEW
1681-
const Matcher<const internal::StringView&> m4 = EndsWith("");
1705+
const Matcher<const internal::StringView&> m4 =
1706+
EndsWith(internal::StringView(""));
16821707
EXPECT_TRUE(m4.Matches("Hi"));
16831708
EXPECT_TRUE(m4.Matches(""));
16841709
EXPECT_TRUE(m4.Matches(internal::StringView()));
@@ -1710,7 +1735,8 @@ TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
17101735
EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
17111736
EXPECT_FALSE(m3.Matches(internal::StringView("1az")));
17121737
EXPECT_FALSE(m3.Matches(internal::StringView()));
1713-
const Matcher<const internal::StringView&> m4 = MatchesRegex("");
1738+
const Matcher<const internal::StringView&> m4 =
1739+
MatchesRegex(internal::StringView(""));
17141740
EXPECT_TRUE(m4.Matches(internal::StringView("")));
17151741
EXPECT_TRUE(m4.Matches(internal::StringView()));
17161742
#endif // GTEST_INTERNAL_HAS_STRING_VIEW
@@ -1749,7 +1775,8 @@ TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
17491775
EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
17501776
EXPECT_FALSE(m3.Matches(internal::StringView("1a")));
17511777
EXPECT_FALSE(m3.Matches(internal::StringView()));
1752-
const Matcher<const internal::StringView&> m4 = ContainsRegex("");
1778+
const Matcher<const internal::StringView&> m4 =
1779+
ContainsRegex(internal::StringView(""));
17531780
EXPECT_TRUE(m4.Matches(internal::StringView("")));
17541781
EXPECT_TRUE(m4.Matches(internal::StringView()));
17551782
#endif // GTEST_INTERNAL_HAS_STRING_VIEW

‎googletest/include/gtest/gtest-matchers.h

+12-6
Original file line numberDiff line numberDiff line change
@@ -612,6 +612,10 @@ class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
612612
static const char* NegatedDesc() { return "isn't >="; }
613613
};
614614

615+
template <typename T, typename = typename std::enable_if<
616+
std::is_constructible<std::string, T>::value>::type>
617+
using StringLike = T;
618+
615619
// Implements polymorphic matchers MatchesRegex(regex) and
616620
// ContainsRegex(regex), which can be used as a Matcher<T> as long as
617621
// T can be converted to a string.
@@ -672,9 +676,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
672676
const internal::RE* regex) {
673677
return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
674678
}
675-
inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
676-
const std::string& regex) {
677-
return MatchesRegex(new internal::RE(regex));
679+
template <typename T = std::string>
680+
PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
681+
const internal::StringLike<T>& regex) {
682+
return MatchesRegex(new internal::RE(std::string(regex)));
678683
}
679684

680685
// Matches a string that contains regular expression 'regex'.
@@ -683,9 +688,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
683688
const internal::RE* regex) {
684689
return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
685690
}
686-
inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
687-
const std::string& regex) {
688-
return ContainsRegex(new internal::RE(regex));
691+
template <typename T = std::string>
692+
PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
693+
const internal::StringLike<T>& regex) {
694+
return ContainsRegex(new internal::RE(std::string(regex)));
689695
}
690696

691697
// Creates a polymorphic matcher that matches anything equal to x.

0 commit comments

Comments
 (0)