| Matcher | Description |
| :------------------------ | :---------------------------------------------- |
| `Pointee(m)` | `argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`. |
+| `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`. |
| `WhenDynamicCastTo<T>(m)` | when `argument` is passed through `dynamic_cast<T>()`, it matches matcher `m`. |
<!-- mdformat on -->
template <typename Pointer>
class Impl : public MatcherInterface<Pointer> {
public:
- typedef typename PointeeOf<GTEST_REMOVE_REFERENCE_AND_CONST_(Pointer)>::type
- Pointee;
+ using Pointee =
+ typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+ Pointer)>::element_type;
explicit Impl(const InnerMatcher& matcher)
: matcher_(MatcherCast<const Pointee&>(matcher)) {}
const InnerMatcher matcher_;
};
+// Implements the Pointer(m) matcher
+// Implements the Pointer(m) matcher for matching a pointer that matches matcher
+// m. The pointer can be either raw or smart, and will match `m` against the
+// raw pointer.
+template <typename InnerMatcher>
+class PointerMatcher {
+ public:
+ explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+ // This type conversion operator template allows Pointer(m) to be
+ // used as a matcher for any pointer type whose pointer type is
+ // compatible with the inner matcher, where type PointerType can be
+ // either a raw pointer or a smart pointer.
+ //
+ // The reason we do this instead of relying on
+ // MakePolymorphicMatcher() is that the latter is not flexible
+ // enough for implementing the DescribeTo() method of Pointer().
+ template <typename PointerType>
+ operator Matcher<PointerType>() const { // NOLINT
+ return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
+ }
+
+ private:
+ // The monomorphic implementation that works for a particular pointer type.
+ template <typename PointerType>
+ class Impl : public MatcherInterface<PointerType> {
+ public:
+ using Pointer =
+ const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+ PointerType)>::element_type*;
+
+ explicit Impl(const InnerMatcher& matcher)
+ : matcher_(MatcherCast<Pointer>(matcher)) {}
+
+ void DescribeTo(::std::ostream* os) const override {
+ *os << "is a pointer that ";
+ matcher_.DescribeTo(os);
+ }
+
+ void DescribeNegationTo(::std::ostream* os) const override {
+ *os << "is not a pointer that ";
+ matcher_.DescribeTo(os);
+ }
+
+ bool MatchAndExplain(PointerType pointer,
+ MatchResultListener* listener) const override {
+ *listener << "which is a pointer that ";
+ Pointer p = GetRawPointer(pointer);
+ return MatchPrintAndExplain(p, matcher_, listener);
+ }
+
+ private:
+ Matcher<Pointer> matcher_;
+ };
+
+ const InnerMatcher matcher_;
+};
+
#if GTEST_HAS_RTTI
// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
// reference that matches inner_matcher when dynamic_cast<T> is applied.
return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
std::forward<M>(matchers)...);
}
+
+// Creates a matcher that matches a pointer (raw or smart) that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointerMatcher<InnerMatcher> Pointer(
+ const InnerMatcher& inner_matcher) {
+ return internal::PointerMatcher<InnerMatcher>(inner_matcher);
+}
} // namespace no_adl
// Returns a predicate that is satisfied by anything that matches the
// "foo_bar_123" are converted to "foo bar 123".
GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
-// PointeeOf<Pointer>::type is the type of a value pointed to by a
-// Pointer, which can be either a smart pointer or a raw pointer. The
-// following default implementation is for the case where Pointer is a
-// smart pointer.
-template <typename Pointer>
-struct PointeeOf {
- // Smart pointer classes define type element_type as the type of
- // their pointees.
- typedef typename Pointer::element_type type;
-};
-// This specialization is for the raw pointer case.
-template <typename T>
-struct PointeeOf<T*> { typedef T type; }; // NOLINT
-
// GetRawPointer(p) returns the raw pointer underlying p when p is a
// smart pointer, or returns p itself when p is already a raw pointer.
// The following default implementation is for the smart pointer case.
class StlContainerView< ::std::tuple<ElementPointer, Size> > {
public:
typedef typename std::remove_const<
- typename internal::PointeeOf<ElementPointer>::type>::type RawElement;
+ typename std::pointer_traits<ElementPointer>::element_type>::type
+ RawElement;
typedef internal::NativeArray<RawElement> type;
typedef const type const_reference;
ConvertIdentifierNameToWords("_Chapter11Section_1_"));
}
-TEST(PointeeOfTest, WorksForSmartPointers) {
- EXPECT_TRUE(
- (std::is_same<int, PointeeOf<std::unique_ptr<int>>::type>::value));
- EXPECT_TRUE(
- (std::is_same<std::string,
- PointeeOf<std::shared_ptr<std::string>>::type>::value));
-}
-
-TEST(PointeeOfTest, WorksForRawPointers) {
- EXPECT_TRUE((std::is_same<int, PointeeOf<int*>::type>::value));
- EXPECT_TRUE((std::is_same<const char, PointeeOf<const char*>::type>::value));
- EXPECT_TRUE((std::is_void<PointeeOf<void*>::type>::value));
-}
-
TEST(GetRawPointerTest, WorksForSmartPointers) {
const char* const raw_p1 = new const char('a'); // NOLINT
const std::unique_ptr<const char> p1(raw_p1);
EXPECT_FALSE(m.Matches(p));
}
+TEST(PointeeTest, SmartPointer) {
+ const Matcher<std::unique_ptr<int>> m = Pointee(Ge(0));
+
+ std::unique_ptr<int> n(new int(1));
+ EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(PointeeTest, SmartPointerToConst) {
+ const Matcher<std::unique_ptr<const int>> m = Pointee(Ge(0));
+
+ // There's no implicit conversion from unique_ptr<int> to const
+ // unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
+ // matcher.
+ std::unique_ptr<const int> n(new int(1));
+ EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(PointerTest, RawPointer) {
+ int n = 1;
+ const Matcher<int*> m = Pointer(Eq(&n));
+
+ EXPECT_TRUE(m.Matches(&n));
+
+ int* p = nullptr;
+ EXPECT_FALSE(m.Matches(p));
+ EXPECT_FALSE(m.Matches(nullptr));
+}
+
+TEST(PointerTest, RawPointerToConst) {
+ int n = 1;
+ const Matcher<const int*> m = Pointer(Eq(&n));
+
+ EXPECT_TRUE(m.Matches(&n));
+
+ int* p = nullptr;
+ EXPECT_FALSE(m.Matches(p));
+ EXPECT_FALSE(m.Matches(nullptr));
+}
+
+TEST(PointerTest, SmartPointer) {
+ std::unique_ptr<int> n(new int(10));
+ int* raw_n = n.get();
+ const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));
+
+ EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(PointerTest, SmartPointerToConst) {
+ std::unique_ptr<const int> n(new int(10));
+ const int* raw_n = n.get();
+ const Matcher<std::unique_ptr<const int>> m = Pointer(Eq(raw_n));
+
+ // There's no implicit conversion from unique_ptr<int> to const
+ // unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
+ // matcher.
+ std::unique_ptr<const int> p(new int(10));
+ EXPECT_FALSE(m.Matches(p));
+}
+
MATCHER_P(FieldIIs, inner_matcher, "") {
return ExplainMatchResult(inner_matcher, arg.i, result_listener);
}
projects / googletest.git / commitdiff