Partially implemented SafeMatcherCast (by Vlad Losev); updated the implementation of Not, AnyOf, and AllOf to use SafeMatcherCast (by Vlad Losev); implemented ACTION_TEMPLATE (by Zhanyong Wan); worked around bugs on Symbian (by Zhanyong Wan).
This commit is contained in:
zhanyong.wan
@@ -1495,5 +1495,157 @@ TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
|
||||
|
||||
#endif // GTEST_HAS_EXCEPTIONS
|
||||
|
||||
// Tests that ACTION_TEMPLATE works when there is no value parameter.
|
||||
ACTION_TEMPLATE(CreateNew,
|
||||
HAS_1_TEMPLATE_PARAMS(typename, T),
|
||||
AND_0_VALUE_PARAMS()) {
|
||||
return new T;
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, WorksWithoutValueParam) {
|
||||
const Action<int*()> a = CreateNew<int>();
|
||||
int* p = a.Perform(make_tuple());
|
||||
delete p;
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATE works when there are value parameters.
|
||||
ACTION_TEMPLATE(CreateNew,
|
||||
HAS_1_TEMPLATE_PARAMS(typename, T),
|
||||
AND_1_VALUE_PARAMS(a0)) {
|
||||
return new T(a0);
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, WorksWithValueParams) {
|
||||
const Action<int*()> a = CreateNew<int>(42);
|
||||
int* p = a.Perform(make_tuple());
|
||||
EXPECT_EQ(42, *p);
|
||||
delete p;
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATE works for integral template parameters.
|
||||
ACTION_TEMPLATE(MyDeleteArg,
|
||||
HAS_1_TEMPLATE_PARAMS(int, k),
|
||||
AND_0_VALUE_PARAMS()) {
|
||||
delete std::tr1::get<k>(args);
|
||||
}
|
||||
|
||||
// Resets a bool variable in the destructor.
|
||||
class BoolResetter {
|
||||
public:
|
||||
explicit BoolResetter(bool* value) : value_(value) {}
|
||||
~BoolResetter() { *value_ = false; }
|
||||
private:
|
||||
bool* const value_;
|
||||
};
|
||||
|
||||
TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
|
||||
const Action<void(int*, BoolResetter*)> a = MyDeleteArg<1>();
|
||||
int n = 0;
|
||||
bool b = true;
|
||||
BoolResetter* resetter = new BoolResetter(&b);
|
||||
a.Perform(make_tuple(&n, resetter));
|
||||
EXPECT_FALSE(b); // Verifies that resetter is deleted.
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATES works for template template parameters.
|
||||
ACTION_TEMPLATE(ReturnSmartPointer,
|
||||
HAS_1_TEMPLATE_PARAMS(template <typename Pointee> class,
|
||||
Pointer),
|
||||
AND_1_VALUE_PARAMS(pointee)) {
|
||||
return Pointer<pointee_type>(new pointee_type(pointee));
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, WorksForTemplateTemplateParameters) {
|
||||
using ::testing::internal::linked_ptr;
|
||||
const Action<linked_ptr<int>()> a = ReturnSmartPointer<linked_ptr>(42);
|
||||
linked_ptr<int> p = a.Perform(make_tuple());
|
||||
EXPECT_EQ(42, *p);
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATE works for 10 template parameters.
|
||||
template <typename T1, typename T2, typename T3, int k4, bool k5,
|
||||
unsigned int k6, typename T7, typename T8, typename T9>
|
||||
struct GiantTemplate {
|
||||
public:
|
||||
explicit GiantTemplate(int a_value) : value(a_value) {}
|
||||
int value;
|
||||
};
|
||||
|
||||
ACTION_TEMPLATE(ReturnGiant,
|
||||
HAS_10_TEMPLATE_PARAMS(
|
||||
typename, T1,
|
||||
typename, T2,
|
||||
typename, T3,
|
||||
int, k4,
|
||||
bool, k5,
|
||||
unsigned int, k6,
|
||||
class, T7,
|
||||
class, T8,
|
||||
class, T9,
|
||||
template <typename T> class, T10),
|
||||
AND_1_VALUE_PARAMS(value)) {
|
||||
return GiantTemplate<T10<T1>, T2, T3, k4, k5, k6, T7, T8, T9>(value);
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, WorksFor10TemplateParameters) {
|
||||
using ::testing::internal::linked_ptr;
|
||||
typedef GiantTemplate<linked_ptr<int>, bool, double, 5,
|
||||
true, 6, char, unsigned, int> Giant;
|
||||
const Action<Giant()> a = ReturnGiant<
|
||||
int, bool, double, 5, true, 6, char, unsigned, int, linked_ptr>(42);
|
||||
Giant giant = a.Perform(make_tuple());
|
||||
EXPECT_EQ(42, giant.value);
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATE works for 10 value parameters.
|
||||
ACTION_TEMPLATE(ReturnSum,
|
||||
HAS_1_TEMPLATE_PARAMS(typename, Number),
|
||||
AND_10_VALUE_PARAMS(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)) {
|
||||
return static_cast<Number>(v1) + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9 + v10;
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, WorksFor10ValueParameters) {
|
||||
const Action<int()> a = ReturnSum<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
|
||||
EXPECT_EQ(55, a.Perform(make_tuple()));
|
||||
}
|
||||
|
||||
// Tests that ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded
|
||||
// on the number of value parameters.
|
||||
|
||||
ACTION(ReturnSum) { return 0; }
|
||||
|
||||
ACTION_P(ReturnSum, x) { return x; }
|
||||
|
||||
ACTION_TEMPLATE(ReturnSum,
|
||||
HAS_1_TEMPLATE_PARAMS(typename, Number),
|
||||
AND_2_VALUE_PARAMS(v1, v2)) {
|
||||
return static_cast<Number>(v1) + v2;
|
||||
}
|
||||
|
||||
ACTION_TEMPLATE(ReturnSum,
|
||||
HAS_1_TEMPLATE_PARAMS(typename, Number),
|
||||
AND_3_VALUE_PARAMS(v1, v2, v3)) {
|
||||
return static_cast<Number>(v1) + v2 + v3;
|
||||
}
|
||||
|
||||
ACTION_TEMPLATE(ReturnSum,
|
||||
HAS_2_TEMPLATE_PARAMS(typename, Number, int, k),
|
||||
AND_4_VALUE_PARAMS(v1, v2, v3, v4)) {
|
||||
return static_cast<Number>(v1) + v2 + v3 + v4 + k;
|
||||
}
|
||||
|
||||
TEST(ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters) {
|
||||
const Action<int()> a0 = ReturnSum();
|
||||
const Action<int()> a1 = ReturnSum(1);
|
||||
const Action<int()> a2 = ReturnSum<int>(1, 2);
|
||||
const Action<int()> a3 = ReturnSum<int>(1, 2, 3);
|
||||
const Action<int()> a4 = ReturnSum<int, 10000>(2000, 300, 40, 5);
|
||||
EXPECT_EQ(0, a0.Perform(make_tuple()));
|
||||
EXPECT_EQ(1, a1.Perform(make_tuple()));
|
||||
EXPECT_EQ(3, a2.Perform(make_tuple()));
|
||||
EXPECT_EQ(6, a3.Perform(make_tuple()));
|
||||
EXPECT_EQ(12345, a4.Perform(make_tuple()));
|
||||
}
|
||||
|
||||
} // namespace gmock_generated_actions_test
|
||||
} // namespace testing
|
||||
|
||||
@@ -366,6 +366,76 @@ TEST(MatcherCastTest, FromSameType) {
|
||||
EXPECT_FALSE(m2.Matches(1));
|
||||
}
|
||||
|
||||
class Base {};
|
||||
class Derived : public Base {};
|
||||
|
||||
// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
|
||||
TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
|
||||
Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
|
||||
EXPECT_TRUE(m2.Matches(' '));
|
||||
EXPECT_FALSE(m2.Matches('\n'));
|
||||
}
|
||||
|
||||
// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T
|
||||
// can be implicitly converted to U.
|
||||
TEST(SafeMatcherCastTest, FromImplicitlyConvertibleType) {
|
||||
Matcher<double> m1 = DoubleEq(1.0);
|
||||
Matcher<int> m2 = SafeMatcherCast<int>(m1);
|
||||
EXPECT_TRUE(m2.Matches(1));
|
||||
EXPECT_FALSE(m2.Matches(2));
|
||||
}
|
||||
|
||||
// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
|
||||
// are pointers or references to a derived and a base class, correspondingly.
|
||||
TEST(SafeMatcherCastTest, FromBaseClass) {
|
||||
Derived d, d2;
|
||||
Matcher<Base*> m1 = Eq(&d);
|
||||
Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
|
||||
EXPECT_TRUE(m2.Matches(&d));
|
||||
EXPECT_FALSE(m2.Matches(&d2));
|
||||
|
||||
Matcher<Base&> m3 = Ref(d);
|
||||
Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
|
||||
EXPECT_TRUE(m4.Matches(d));
|
||||
EXPECT_FALSE(m4.Matches(d2));
|
||||
}
|
||||
|
||||
// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
|
||||
TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
|
||||
int n = 0;
|
||||
Matcher<const int&> m1 = Ref(n);
|
||||
Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
|
||||
int n1 = 0;
|
||||
EXPECT_TRUE(m2.Matches(n));
|
||||
EXPECT_FALSE(m2.Matches(n1));
|
||||
}
|
||||
|
||||
// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
|
||||
TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
|
||||
Matcher<int> m1 = Eq(0);
|
||||
Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
|
||||
EXPECT_TRUE(m2.Matches(0));
|
||||
EXPECT_FALSE(m2.Matches(1));
|
||||
}
|
||||
|
||||
// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
|
||||
TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
|
||||
Matcher<int> m1 = Eq(0);
|
||||
Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
|
||||
int n = 0;
|
||||
EXPECT_TRUE(m2.Matches(n));
|
||||
n = 1;
|
||||
EXPECT_FALSE(m2.Matches(n));
|
||||
}
|
||||
|
||||
// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
|
||||
TEST(SafeMatcherCastTest, FromSameType) {
|
||||
Matcher<int> m1 = Eq(0);
|
||||
Matcher<int> m2 = SafeMatcherCast<int>(m1);
|
||||
EXPECT_TRUE(m2.Matches(0));
|
||||
EXPECT_FALSE(m2.Matches(1));
|
||||
}
|
||||
|
||||
// Tests that A<T>() matches any value of type T.
|
||||
TEST(ATest, MatchesAnyValue) {
|
||||
// Tests a matcher for a value type.
|
||||
@@ -626,9 +696,6 @@ TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
|
||||
// used wherever Ref(base) can be used (Ref(derived) is a sub-type
|
||||
// of Ref(base), but not vice versa.
|
||||
|
||||
class Base {};
|
||||
class Derived : public Base {};
|
||||
|
||||
TEST(RefTest, IsCovariant) {
|
||||
Base base, base2;
|
||||
Derived derived;
|
||||
@@ -1355,6 +1422,16 @@ TEST(NotTest, CanDescribeSelf) {
|
||||
EXPECT_EQ("is not equal to 5", Describe(m));
|
||||
}
|
||||
|
||||
// Tests that monomorphic matchers are safely cast by the Not matcher.
|
||||
TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
|
||||
// greater_than_5 is a monomorphic matcher.
|
||||
Matcher<int> greater_than_5 = Gt(5);
|
||||
|
||||
Matcher<const int&> m = Not(greater_than_5);
|
||||
Matcher<int&> m2 = Not(greater_than_5);
|
||||
Matcher<int&> m3 = Not(m);
|
||||
}
|
||||
|
||||
// Tests that AllOf(m1, ..., mn) matches any value that matches all of
|
||||
// the given matchers.
|
||||
TEST(AllOfTest, MatchesWhenAllMatch) {
|
||||
@@ -1415,6 +1492,21 @@ TEST(AllOfTest, CanDescribeSelf) {
|
||||
"(is not equal to 7))))", Describe(m));
|
||||
}
|
||||
|
||||
// Tests that monomorphic matchers are safely cast by the AllOf matcher.
|
||||
TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
|
||||
// greater_than_5 and less_than_10 are monomorphic matchers.
|
||||
Matcher<int> greater_than_5 = Gt(5);
|
||||
Matcher<int> less_than_10 = Lt(10);
|
||||
|
||||
Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
|
||||
Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
|
||||
Matcher<int&> m3 = AllOf(greater_than_5, m2);
|
||||
|
||||
// Tests that BothOf works when composing itself.
|
||||
Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
|
||||
Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
|
||||
}
|
||||
|
||||
// Tests that AnyOf(m1, ..., mn) matches any value that matches at
|
||||
// least one of the given matchers.
|
||||
TEST(AnyOfTest, MatchesWhenAnyMatches) {
|
||||
@@ -1473,6 +1565,21 @@ TEST(AnyOfTest, CanDescribeSelf) {
|
||||
Describe(m));
|
||||
}
|
||||
|
||||
// Tests that monomorphic matchers are safely cast by the AnyOf matcher.
|
||||
TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
|
||||
// greater_than_5 and less_than_10 are monomorphic matchers.
|
||||
Matcher<int> greater_than_5 = Gt(5);
|
||||
Matcher<int> less_than_10 = Lt(10);
|
||||
|
||||
Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
|
||||
Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
|
||||
Matcher<int&> m3 = AnyOf(greater_than_5, m2);
|
||||
|
||||
// Tests that EitherOf works when composing itself.
|
||||
Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
|
||||
Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
|
||||
}
|
||||
|
||||
// The following predicate function and predicate functor are for
|
||||
// testing the Truly(predicate) matcher.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user