Skip to content

Commit a02a591

Browse files
Abseil Teamsuertreus
Abseil Team
authored and
suertreus
committed
Googletest export
Add a `Pointer` matcher as an analog to `Pointee`. Similar to `Pointee`, `Pointer` works with either raw or smart pointers and allows creating a matcher like Pointer(Eq(foo)) for smart pointers. PiperOrigin-RevId: 346164768
1 parent 7bf5057 commit a02a591

File tree

5 files changed

+131
-31
lines changed

5 files changed

+131
-31
lines changed

‎googlemock/docs/cheat_sheet.md

+1
Original file line numberDiff line numberDiff line change
@@ -421,6 +421,7 @@ messages, you can use:
421421
| Matcher | Description |
422422
| :------------------------ | :---------------------------------------------- |
423423
| `Pointee(m)` | `argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`. |
424+
| `Pointer(m)` | `argument` (either a smart pointer or a raw pointer) contains a pointer that matches `m`. `m` will match against the raw pointer regardless of the type of `argument`. |
424425
| `WhenDynamicCastTo<T>(m)` | when `argument` is passed through `dynamic_cast<T>()`, it matches matcher `m`. |
425426
<!-- mdformat on -->
426427

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

+69-2
Original file line numberDiff line numberDiff line change
@@ -1841,8 +1841,9 @@ class PointeeMatcher {
18411841
template <typename Pointer>
18421842
class Impl : public MatcherInterface<Pointer> {
18431843
public:
1844-
typedef typename PointeeOf<GTEST_REMOVE_REFERENCE_AND_CONST_(Pointer)>::type
1845-
Pointee;
1844+
using Pointee =
1845+
typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
1846+
Pointer)>::element_type;
18461847

18471848
explicit Impl(const InnerMatcher& matcher)
18481849
: matcher_(MatcherCast<const Pointee&>(matcher)) {}
@@ -1872,6 +1873,64 @@ class PointeeMatcher {
18721873
const InnerMatcher matcher_;
18731874
};
18741875

1876+
// Implements the Pointer(m) matcher
1877+
// Implements the Pointer(m) matcher for matching a pointer that matches matcher
1878+
// m. The pointer can be either raw or smart, and will match `m` against the
1879+
// raw pointer.
1880+
template <typename InnerMatcher>
1881+
class PointerMatcher {
1882+
public:
1883+
explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
1884+
1885+
// This type conversion operator template allows Pointer(m) to be
1886+
// used as a matcher for any pointer type whose pointer type is
1887+
// compatible with the inner matcher, where type PointerType can be
1888+
// either a raw pointer or a smart pointer.
1889+
//
1890+
// The reason we do this instead of relying on
1891+
// MakePolymorphicMatcher() is that the latter is not flexible
1892+
// enough for implementing the DescribeTo() method of Pointer().
1893+
template <typename PointerType>
1894+
operator Matcher<PointerType>() const { // NOLINT
1895+
return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
1896+
}
1897+
1898+
private:
1899+
// The monomorphic implementation that works for a particular pointer type.
1900+
template <typename PointerType>
1901+
class Impl : public MatcherInterface<PointerType> {
1902+
public:
1903+
using Pointer =
1904+
const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
1905+
PointerType)>::element_type*;
1906+
1907+
explicit Impl(const InnerMatcher& matcher)
1908+
: matcher_(MatcherCast<Pointer>(matcher)) {}
1909+
1910+
void DescribeTo(::std::ostream* os) const override {
1911+
*os << "is a pointer that ";
1912+
matcher_.DescribeTo(os);
1913+
}
1914+
1915+
void DescribeNegationTo(::std::ostream* os) const override {
1916+
*os << "is not a pointer that ";
1917+
matcher_.DescribeTo(os);
1918+
}
1919+
1920+
bool MatchAndExplain(PointerType pointer,
1921+
MatchResultListener* listener) const override {
1922+
*listener << "which is a pointer that ";
1923+
Pointer p = GetRawPointer(pointer);
1924+
return MatchPrintAndExplain(p, matcher_, listener);
1925+
}
1926+
1927+
private:
1928+
Matcher<Pointer> matcher_;
1929+
};
1930+
1931+
const InnerMatcher matcher_;
1932+
};
1933+
18751934
#if GTEST_HAS_RTTI
18761935
// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
18771936
// reference that matches inner_matcher when dynamic_cast<T> is applied.
@@ -4720,6 +4779,14 @@ internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
47204779
return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
47214780
std::forward<M>(matchers)...);
47224781
}
4782+
4783+
// Creates a matcher that matches a pointer (raw or smart) that matches
4784+
// inner_matcher.
4785+
template <typename InnerMatcher>
4786+
inline internal::PointerMatcher<InnerMatcher> Pointer(
4787+
const InnerMatcher& inner_matcher) {
4788+
return internal::PointerMatcher<InnerMatcher>(inner_matcher);
4789+
}
47234790
} // namespace no_adl
47244791

47254792
// Returns a predicate that is satisfied by anything that matches the

‎googlemock/include/gmock/internal/gmock-internal-utils.h

+2-15
Original file line numberDiff line numberDiff line change
@@ -71,20 +71,6 @@ GTEST_API_ std::string JoinAsTuple(const Strings& fields);
7171
// "foo_bar_123" are converted to "foo bar 123".
7272
GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
7373

74-
// PointeeOf<Pointer>::type is the type of a value pointed to by a
75-
// Pointer, which can be either a smart pointer or a raw pointer. The
76-
// following default implementation is for the case where Pointer is a
77-
// smart pointer.
78-
template <typename Pointer>
79-
struct PointeeOf {
80-
// Smart pointer classes define type element_type as the type of
81-
// their pointees.
82-
typedef typename Pointer::element_type type;
83-
};
84-
// This specialization is for the raw pointer case.
85-
template <typename T>
86-
struct PointeeOf<T*> { typedef T type; }; // NOLINT
87-
8874
// GetRawPointer(p) returns the raw pointer underlying p when p is a
8975
// smart pointer, or returns p itself when p is already a raw pointer.
9076
// The following default implementation is for the smart pointer case.
@@ -378,7 +364,8 @@ template <typename ElementPointer, typename Size>
378364
class StlContainerView< ::std::tuple<ElementPointer, Size> > {
379365
public:
380366
typedef typename std::remove_const<
381-
typename internal::PointeeOf<ElementPointer>::type>::type RawElement;
367+
typename std::pointer_traits<ElementPointer>::element_type>::type
368+
RawElement;
382369
typedef internal::NativeArray<RawElement> type;
383370
typedef const type const_reference;
384371

‎googlemock/test/gmock-internal-utils_test.cc

-14
Original file line numberDiff line numberDiff line change
@@ -124,20 +124,6 @@ TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
124124
ConvertIdentifierNameToWords("_Chapter11Section_1_"));
125125
}
126126

127-
TEST(PointeeOfTest, WorksForSmartPointers) {
128-
EXPECT_TRUE(
129-
(std::is_same<int, PointeeOf<std::unique_ptr<int>>::type>::value));
130-
EXPECT_TRUE(
131-
(std::is_same<std::string,
132-
PointeeOf<std::shared_ptr<std::string>>::type>::value));
133-
}
134-
135-
TEST(PointeeOfTest, WorksForRawPointers) {
136-
EXPECT_TRUE((std::is_same<int, PointeeOf<int*>::type>::value));
137-
EXPECT_TRUE((std::is_same<const char, PointeeOf<const char*>::type>::value));
138-
EXPECT_TRUE((std::is_void<PointeeOf<void*>::type>::value));
139-
}
140-
141127
TEST(GetRawPointerTest, WorksForSmartPointers) {
142128
const char* const raw_p1 = new const char('a'); // NOLINT
143129
const std::unique_ptr<const char> p1(raw_p1);

‎googlemock/test/gmock-matchers_test.cc

+59
Original file line numberDiff line numberDiff line change
@@ -3728,6 +3728,65 @@ TEST(PointeeTest, ReferenceToNonConstRawPointer) {
37283728
EXPECT_FALSE(m.Matches(p));
37293729
}
37303730

3731+
TEST(PointeeTest, SmartPointer) {
3732+
const Matcher<std::unique_ptr<int>> m = Pointee(Ge(0));
3733+
3734+
std::unique_ptr<int> n(new int(1));
3735+
EXPECT_TRUE(m.Matches(n));
3736+
}
3737+
3738+
TEST(PointeeTest, SmartPointerToConst) {
3739+
const Matcher<std::unique_ptr<const int>> m = Pointee(Ge(0));
3740+
3741+
// There's no implicit conversion from unique_ptr<int> to const
3742+
// unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
3743+
// matcher.
3744+
std::unique_ptr<const int> n(new int(1));
3745+
EXPECT_TRUE(m.Matches(n));
3746+
}
3747+
3748+
TEST(PointerTest, RawPointer) {
3749+
int n = 1;
3750+
const Matcher<int*> m = Pointer(Eq(&n));
3751+
3752+
EXPECT_TRUE(m.Matches(&n));
3753+
3754+
int* p = nullptr;
3755+
EXPECT_FALSE(m.Matches(p));
3756+
EXPECT_FALSE(m.Matches(nullptr));
3757+
}
3758+
3759+
TEST(PointerTest, RawPointerToConst) {
3760+
int n = 1;
3761+
const Matcher<const int*> m = Pointer(Eq(&n));
3762+
3763+
EXPECT_TRUE(m.Matches(&n));
3764+
3765+
int* p = nullptr;
3766+
EXPECT_FALSE(m.Matches(p));
3767+
EXPECT_FALSE(m.Matches(nullptr));
3768+
}
3769+
3770+
TEST(PointerTest, SmartPointer) {
3771+
std::unique_ptr<int> n(new int(10));
3772+
int* raw_n = n.get();
3773+
const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));
3774+
3775+
EXPECT_TRUE(m.Matches(n));
3776+
}
3777+
3778+
TEST(PointerTest, SmartPointerToConst) {
3779+
std::unique_ptr<const int> n(new int(10));
3780+
const int* raw_n = n.get();
3781+
const Matcher<std::unique_ptr<const int>> m = Pointer(Eq(raw_n));
3782+
3783+
// There's no implicit conversion from unique_ptr<int> to const
3784+
// unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
3785+
// matcher.
3786+
std::unique_ptr<const int> p(new int(10));
3787+
EXPECT_FALSE(m.Matches(p));
3788+
}
3789+
37313790
MATCHER_P(FieldIIs, inner_matcher, "") {
37323791
return ExplainMatchResult(inner_matcher, arg.i, result_listener);
37333792
}

0 commit comments

Comments
 (0)