Upgrade gtest to r267 and gmock to r173.

testing/gmock/test/gmock-matchers_test.cc

 // Copyright 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
 string FormatMatcherDescriptionSyntaxError(const char* description,
                                            const char* error_pos);
 int GetParamIndex(const char* param_names[], const string& param_name);
 string JoinAsTuple(const Strings& fields);
 bool SkipPrefix(const char* prefix, const char** pstr);
 }  // namespace internal
 
 namespace gmock_matchers_test {
 
 using std::stringstream;
+using std::tr1::make_tuple;
 using testing::A;
+using testing::AllArgs;
 using testing::AllOf;
 using testing::An;
 using testing::AnyOf;
 using testing::ByRef;
 using testing::DoubleEq;
 using testing::EndsWith;
 using testing::Eq;
 using testing::Field;
 using testing::FloatEq;
 using testing::Ge;
@@ skipping 17 matching lines @@
 using testing::Property;
 using testing::Ref;
 using testing::ResultOf;
 using testing::StartsWith;
 using testing::StrCaseEq;
 using testing::StrCaseNe;
 using testing::StrEq;
 using testing::StrNe;
 using testing::Truly;
 using testing::TypedEq;
+using testing::Value;
 using testing::_;
 using testing::internal::FloatingEqMatcher;
 using testing::internal::FormatMatcherDescriptionSyntaxError;
 using testing::internal::GetParamIndex;
 using testing::internal::Interpolation;
 using testing::internal::Interpolations;
 using testing::internal::JoinAsTuple;
 using testing::internal::SkipPrefix;
 using testing::internal::String;
 using testing::internal::Strings;
@@ skipping 1215 matching lines @@
 // second field.
 TEST(Eq2Test, MatchesEqualArguments) {
   Matcher<const Tuple2&> m = Eq();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }
 
 // Tests that Eq() describes itself properly.
 TEST(Eq2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Eq();
-  EXPECT_EQ("argument #0 is equal to argument #1", Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x == y", Describe(m));
 }
 
 // Tests that Ge() matches a 2-tuple where the first field >= the
 // second field.
 TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
   Matcher<const Tuple2&> m = Ge();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }
 
 // Tests that Ge() describes itself properly.
 TEST(Ge2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Ge();
-  EXPECT_EQ("argument #0 is greater than or equal to argument #1",
-            Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x >= y", Describe(m));
 }
 
 // Tests that Gt() matches a 2-tuple where the first field > the
 // second field.
 TEST(Gt2Test, MatchesGreaterThanArguments) {
   Matcher<const Tuple2&> m = Gt();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }
 
 // Tests that Gt() describes itself properly.
 TEST(Gt2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Gt();
-  EXPECT_EQ("argument #0 is greater than argument #1", Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x > y", Describe(m));
 }
 
 // Tests that Le() matches a 2-tuple where the first field <= the
 // second field.
 TEST(Le2Test, MatchesLessThanOrEqualArguments) {
   Matcher<const Tuple2&> m = Le();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
 }
 
 // Tests that Le() describes itself properly.
 TEST(Le2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Le();
-  EXPECT_EQ("argument #0 is less than or equal to argument #1",
-            Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x <= y", Describe(m));
 }
 
 // Tests that Lt() matches a 2-tuple where the first field < the
 // second field.
 TEST(Lt2Test, MatchesLessThanArguments) {
   Matcher<const Tuple2&> m = Lt();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
 }
 
 // Tests that Lt() describes itself properly.
 TEST(Lt2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Lt();
-  EXPECT_EQ("argument #0 is less than argument #1", Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x < y", Describe(m));
 }
 
 // Tests that Ne() matches a 2-tuple where the first field != the
 // second field.
 TEST(Ne2Test, MatchesUnequalArguments) {
   Matcher<const Tuple2&> m = Ne();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
 }
 
 // Tests that Ne() describes itself properly.
 TEST(Ne2Test, CanDescribeSelf) {
   Matcher<const Tuple2&> m = Ne();
-  EXPECT_EQ("argument #0 is not equal to argument #1", Describe(m));
+  EXPECT_EQ("are a pair (x, y) where x != y", Describe(m));
 }
 
 // Tests that Not(m) matches any value that doesn't match m.
 TEST(NotTest, NegatesMatcher) {
   Matcher<int> m;
   m = Not(Eq(2));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
 }
 
@@ skipping 239 matching lines @@
 }
 
 // Tests that a Matcher on non-reference type can be used in
 // Matches().
 TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
   Matcher<int> eq5 = Eq(5);
   EXPECT_TRUE(Matches(eq5)(5));
   EXPECT_FALSE(Matches(eq5)(2));
 }
 
+// Tests Value(value, matcher).  Since Value() is a simple wrapper for
+// Matches(), which has been tested already, we don't spend a lot of
+// effort on testing Value().
+TEST(ValueTest, WorksWithPolymorphicMatcher) {
+  EXPECT_TRUE(Value("hi", StartsWith("h")));
+  EXPECT_FALSE(Value(5, Gt(10)));
+}
+
+TEST(ValueTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> is_zero = Eq(0);
+  EXPECT_TRUE(Value(0, is_zero));
+  EXPECT_FALSE(Value('a', is_zero));
+
+  int n = 0;
+  const Matcher<const int&> ref_n = Ref(n);
+  EXPECT_TRUE(Value(n, ref_n));
+  EXPECT_FALSE(Value(1, ref_n));
+}
+
+TEST(AllArgsTest, WorksForTuple) {
+  EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
+  EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
+}
+
+TEST(AllArgsTest, WorksForNonTuple) {
+  EXPECT_THAT(42, AllArgs(Gt(0)));
+  EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
+}
+
+class AllArgsHelper {
+ public:
+  MOCK_METHOD2(Helper, int(char x, int y));
+};
+
+TEST(AllArgsTest, WorksInWithClause) {
+  AllArgsHelper helper;
+  ON_CALL(helper, Helper(_, _))
+      .With(AllArgs(Lt()))
+      .WillByDefault(Return(1));
+  EXPECT_CALL(helper, Helper(_, _));
+  EXPECT_CALL(helper, Helper(_, _))
+      .With(AllArgs(Gt()))
+      .WillOnce(Return(2));
+
+  EXPECT_EQ(1, helper.Helper('\1', 2));
+  EXPECT_EQ(2, helper.Helper('a', 1));
+}
+
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
 // matches the matcher.
 TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
   ASSERT_THAT(5, Ge(2)) << "This should succeed.";
   ASSERT_THAT("Foo", EndsWith("oo"));
   EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
   EXPECT_THAT("Hello", StartsWith("Hell"));
 }
 
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
@@ skipping 1075 matching lines @@
 
   NotCopyable n1(1), n2(2);
   EXPECT_FALSE(m.Matches(n1));
   EXPECT_TRUE(m.Matches(n2));
 }
 
 // Tests ContainerEq with different container types, and
 // different element types.
 
 template <typename T>
-class ContainerEqTest : public testing::Test {
- public:
-};
+class ContainerEqTest : public testing::Test {};
 
 typedef testing::Types<
     std::set<int>,
     std::vector<size_t>,
     std::multiset<size_t>,
     std::list<int> >
     ContainerEqTestTypes;
 
 TYPED_TEST_CASE(ContainerEqTest, ContainerEqTestTypes);
 
@@ skipping 113 matching lines @@
   test_map[1] = "b";
 
   const Matcher<const std::map<int, std::string>&> m = ContainerEq(my_map);
   EXPECT_TRUE(m.Matches(my_map));
   EXPECT_FALSE(m.Matches(test_map));
 
   EXPECT_EQ("Only in actual: (0, \"aa\"); not in actual: (0, \"a\")",
             Explain(m, test_map));
 }
 
+TEST(ContainerEqExtraTest, WorksForNativeArray) {
+  int a1[] = { 1, 2, 3 };
+  int a2[] = { 1, 2, 3 };
+  int b[] = { 1, 2, 4 };
+
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+}
+
+TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
+  const char a1[][3] = { "hi", "lo" };
+  const char a2[][3] = { "hi", "lo" };
+  const char b[][3] = { "lo", "hi" };
+
+  // Tests using ContainerEq() in the first dimension.
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+
+  // Tests using ContainerEq() in the second dimension.
+  EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
+  EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
+}
+
+TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
+  const int a1[] = { 1, 2, 3 };
+  const int a2[] = { 1, 2, 3 };
+  const int b[] = { 1, 2, 3, 4 };
+
+  const int* const p1 = a1;
+  EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2));
+  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b)));
+
+  const int c[] = { 1, 3, 2 };
+  EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c)));
+}
+
+TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
+  std::string a1[][3] = {
+    { "hi", "hello", "ciao" },
+    { "bye", "see you", "ciao" }
+  };
+
+  std::string a2[][3] = {
+    { "hi", "hello", "ciao" },
+    { "bye", "see you", "ciao" }
+  };
+
+  const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
+  EXPECT_THAT(a1, m);
+
+  a2[0][0] = "ha";
+  EXPECT_THAT(a1, m);
+}
+
 // Tests GetParamIndex().
 
 TEST(GetParamIndexTest, WorksForEmptyParamList) {
   const char* params[] = { NULL };
   EXPECT_EQ(kTupleInterpolation, GetParamIndex(params, "*"));
   EXPECT_EQ(kInvalidInterpolation, GetParamIndex(params, "a"));
 }
 
 TEST(GetParamIndexTest, RecognizesStar) {
   const char* params[] = { "a", "b", NULL };
@@ skipping 276 matching lines @@
   const char* const desc = "> %(x)s %(x)";
   const Interpolation interp[] = { Interpolation(desc + 2, desc + 7, 0)  };
   EXPECT_EQ("> 9 %(x)",
             FormatMatcherDescription("Foo", desc,
                                      Interpolations(interp, interp + 1),
                                      Strings(params, params + 1)));
 }
 
 }  // namespace gmock_matchers_test
 }  // namespace testing