aboutsummaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/gmock-generated-actions_test.cc4
-rw-r--r--test/gmock-internal-utils_test.cc4
-rw-r--r--test/gmock-matchers_test.cc147
3 files changed, 144 insertions, 11 deletions
diff --git a/test/gmock-generated-actions_test.cc b/test/gmock-generated-actions_test.cc
index 784c59d1..c2d2a0a8 100644
--- a/test/gmock-generated-actions_test.cc
+++ b/test/gmock-generated-actions_test.cc
@@ -900,9 +900,9 @@ template <typename T1, typename T2>
// pattern requires the user to use it directly.
ConcatImplActionP3<std::string, T1, T2>
Concat(const std::string& a, T1 b, T2 c) {
- GTEST_INTENTIONAL_CONST_COND_PUSH_
+ GTEST_INTENTIONAL_CONST_COND_PUSH_()
if (true) {
- GTEST_INTENTIONAL_CONST_COND_POP_
+ GTEST_INTENTIONAL_CONST_COND_POP_()
// This branch verifies that ConcatImpl() can be invoked without
// explicit template arguments.
return ConcatImpl(a, b, c);
diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc
index e5e842a1..95a7dc39 100644
--- a/test/gmock-internal-utils_test.cc
+++ b/test/gmock-internal-utils_test.cc
@@ -247,9 +247,9 @@ TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
// Larger size => smaller size is not fine.
EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
- GTEST_INTENTIONAL_CONST_COND_PUSH_
+ GTEST_INTENTIONAL_CONST_COND_PUSH_()
if (sizeof(double) == sizeof(long double)) { // NOLINT
- GTEST_INTENTIONAL_CONST_COND_POP_
+ GTEST_INTENTIONAL_CONST_COND_POP_()
// In some implementations (e.g. MSVC), double and long double
// have the same size.
EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc
index 0f6bcb29..ea0153ea 100644
--- a/test/gmock-matchers_test.cc
+++ b/test/gmock-matchers_test.cc
@@ -33,10 +33,6 @@
//
// This file tests some commonly used argument matchers.
-// windows.h defines macros which conflict with standard identifiers used in
-// this test. Defining this symbol prevents windows.h from doing that.
-#define NOMINMAX
-
#include "gmock/gmock-matchers.h"
#include "gmock/gmock-more-matchers.h"
@@ -657,8 +653,21 @@ TEST(MatcherCastTest, ValueIsNotCopied) {
EXPECT_TRUE(m.Matches(n));
}
-class Base {};
-class Derived : public Base {};
+class Base {
+ public:
+ virtual ~Base() {}
+ Base() {}
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
+};
+
+class Derived : public Base {
+ public:
+ Derived() : Base() {}
+ int i;
+};
+
+class OtherDerived : public Base {};
// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
@@ -3135,6 +3144,107 @@ TEST(PointeeTest, ReferenceToNonConstRawPointer) {
EXPECT_FALSE(m.Matches(p));
}
+
+MATCHER_P(FieldIIs, inner_matcher, "") {
+ return ExplainMatchResult(inner_matcher, arg.i, result_listener);
+}
+
+TEST(WhenDynamicCastToTest, SameType) {
+ Derived derived;
+ derived.i = 4;
+
+ // Right type. A pointer is passed down.
+ Base* as_base_ptr = &derived;
+ EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
+ EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
+ EXPECT_THAT(as_base_ptr,
+ Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
+}
+
+TEST(WhenDynamicCastToTest, WrongTypes) {
+ Base base;
+ Derived derived;
+ OtherDerived other_derived;
+
+ // Wrong types. NULL is passed.
+ EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+ EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
+ Base* as_base_ptr = &derived;
+ EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
+ EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
+ as_base_ptr = &other_derived;
+ EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+ EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+TEST(WhenDynamicCastToTest, AlreadyNull) {
+ // Already NULL.
+ Base* as_base_ptr = NULL;
+ EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+struct AmbiguousCastTypes {
+ class VirtualDerived : public virtual Base {};
+ class DerivedSub1 : public VirtualDerived {};
+ class DerivedSub2 : public VirtualDerived {};
+ class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
+};
+
+TEST(WhenDynamicCastToTest, AmbiguousCast) {
+ AmbiguousCastTypes::DerivedSub1 sub1;
+ AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
+ // Multiply derived from Base. dynamic_cast<> returns NULL.
+ Base* as_base_ptr =
+ static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
+ EXPECT_THAT(as_base_ptr,
+ WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
+ as_base_ptr = &sub1;
+ EXPECT_THAT(
+ as_base_ptr,
+ WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
+}
+
+TEST(WhenDynamicCastToTest, Describe) {
+ Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+#if GTEST_HAS_RTTI
+ const string prefix =
+ "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
+#else // GTEST_HAS_RTTI
+ const string prefix = "when dynamic_cast, ";
+#endif // GTEST_HAS_RTTI
+ EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
+ EXPECT_EQ(prefix + "does not point to a value that is anything",
+ DescribeNegation(matcher));
+}
+
+TEST(WhenDynamicCastToTest, Explain) {
+ Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+ Base* null = NULL;
+ EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
+ Derived derived;
+ EXPECT_TRUE(matcher.Matches(&derived));
+ EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
+
+ // With references, the matcher itself can fail. Test for that one.
+ Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
+ EXPECT_THAT(Explain(ref_matcher, derived),
+ HasSubstr("which cannot be dynamic_cast"));
+}
+
+TEST(WhenDynamicCastToTest, GoodReference) {
+ Derived derived;
+ derived.i = 4;
+ Base& as_base_ref = derived;
+ EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
+ EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
+}
+
+TEST(WhenDynamicCastToTest, BadReference) {
+ Derived derived;
+ Base& as_base_ref = derived;
+ EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
+}
+
// Minimal const-propagating pointer.
template <typename T>
class ConstPropagatingPtr {
@@ -3210,17 +3320,24 @@ TEST(PointeeTest, AlwaysExplainsPointee) {
// An uncopyable class.
class Uncopyable {
public:
+ Uncopyable() : value_(-1) {}
explicit Uncopyable(int a_value) : value_(a_value) {}
int value() const { return value_; }
+ void set_value(int i) { value_ = i; }
+
private:
- const int value_;
+ int value_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable);
};
// Returns true iff x.value() is positive.
bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
+MATCHER_P(UncopyableIs, inner_matcher, "") {
+ return ExplainMatchResult(inner_matcher, arg.value(), result_listener);
+}
+
// A user-defined struct for testing Field().
struct AStruct {
AStruct() : x(0), y(1.0), z(5), p(NULL) {}
@@ -4527,6 +4644,13 @@ TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
EXPECT_THAT(s, Not(ElementsAreArray(expected)));
}
+TEST(ElementsAreTest, WorksWithUncopyable) {
+ Uncopyable objs[2];
+ objs[0].set_value(-3);
+ objs[1].set_value(1);
+ EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive)));
+}
+
// Tests for UnorderedElementsAreArray()
TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
@@ -4609,6 +4733,14 @@ class UnorderedElementsAreTest : public testing::Test {
typedef std::vector<int> IntVec;
};
+TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
+ Uncopyable objs[2];
+ objs[0].set_value(-3);
+ objs[1].set_value(1);
+ EXPECT_THAT(objs,
+ UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3)));
+}
+
TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
const int a[] = { 1, 2, 3 };
std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
@@ -5332,3 +5464,4 @@ TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
} // namespace gmock_matchers_test
} // namespace testing
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-23 20:20:07 +0000