Update gmock and gtest.

testing/gmock/test/gmock-spec-builders_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 79 matching lines @@
 using testing::internal::kErrorVerbosity;
 using testing::internal::kInfoVerbosity;
 using testing::internal::kWarningVerbosity;
 using testing::internal::ExpectationTester;
 using testing::internal::string;
 
 class Result {};
 
 class MockA {
  public:
+  MockA() {}
+
   MOCK_METHOD1(DoA, void(int n));  // NOLINT
   MOCK_METHOD1(ReturnResult, Result(int n));  // NOLINT
   MOCK_METHOD2(Binary, bool(int x, int y));  // NOLINT
   MOCK_METHOD2(ReturnInt, int(int x, int y));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
 };
 
 class MockB {
  public:
+  MockB() {}
+
   MOCK_CONST_METHOD0(DoB, int());  // NOLINT
   MOCK_METHOD1(DoB, int(int n));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
 };
 
 // Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
 // redefining a mock method name. This could happen, for example, when
 // the tested code #includes Win32 API headers which define many APIs
 // as macros, e.g. #define TextOut TextOutW.
 
 #define Method MethodW
 
 class CC {
  public:
   virtual ~CC() {}
   virtual int Method() = 0;
 };
 class MockCC : public CC {
  public:
+  MockCC() {}
+
   MOCK_METHOD0(Method, int());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
 };
 
 // Tests that a method with expanded name compiles.
 TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
   MockCC cc;
   ON_CALL(cc, Method());
 }
 
 // Tests that the method with expanded name not only compiles but runs
 // and returns a correct value, too.
@@ skipping 427 matching lines @@
     EXPECT_CALL(b, DoB(2))
         .Times(1)
         .WillOnce(Return(1))
         .WillRepeatedly(Return(2));  // #5
 
     // Satisfies the above expectations.
     b.DoB(1);
     b.DoB(2);
   }
   const string& output = GetCapturedTestStdout();
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too many actions specified.\n"
-                      "Expected to be never called, but has 1 WillOnce().",
-                      output);  // #1
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too many actions specified.\n"
-                      "Expected to be called at most once, "
-                      "but has 2 WillOnce()s.",
-                      output);  // #2
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too many actions specified.\n"
-                      "Expected to be called once, but has 2 WillOnce()s.",
-                      output);  // #3
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too many actions specified.\n"
-                      "Expected to be never called, but has 0 WillOnce()s "
-                      "and a WillRepeatedly().",
-                      output);  // #4
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too many actions specified.\n"
-                      "Expected to be called once, but has 1 WillOnce() "
-                      "and a WillRepeatedly().",
-                      output);  // #5
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be never called, but has 1 WillOnce().",
+      output);  // #1
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be called at most once, "
+      "but has 2 WillOnce()s.",
+      output);  // #2
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
+      "Expected to be called once, but has 2 WillOnce()s.",
+      output);  // #3
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be never called, but has 0 WillOnce()s "
+      "and a WillRepeatedly().",
+      output);  // #4
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
+      "Expected to be called once, but has 1 WillOnce() "
+      "and a WillRepeatedly().",
+      output);  // #5
 }
 
 // Tests that Google Mock warns on having too few actions in an
 // expectation compared to its cardinality.
 TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
   MockB b;
 
   EXPECT_CALL(b, DoB())
       .Times(Between(2, 3))
       .WillOnce(Return(1));
 
   CaptureTestStdout();
   b.DoB();
   const string& output = GetCapturedTestStdout();
-  EXPECT_PRED_FORMAT2(IsSubstring,
-                      "Too few actions specified.\n"
-                      "Expected to be called between 2 and 3 times, "
-                      "but has only 1 WillOnce().",
-                      output);
+  EXPECT_PRED_FORMAT2(
+      IsSubstring,
+      "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
+      "Expected to be called between 2 and 3 times, "
+      "but has only 1 WillOnce().",
+      output);
   b.DoB();
 }
 
 #endif  // 0
 
 // Tests the semantics of ON_CALL().
 
 // Tests that the built-in default action is taken when no ON_CALL()
 // is specified.
 TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
@@ skipping 55 matching lines @@
 }
 
 // Tests lower-bound violation.
 TEST(ExpectCallTest, CatchesTooFewCalls) {
   EXPECT_NONFATAL_FAILURE({  // NOLINT
     MockB b;
     EXPECT_CALL(b, DoB(5))
         .Times(AtLeast(2));
 
     b.DoB(5);
-  }, "Actual function call count doesn't match this expectation.\n"
+  }, "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
      "         Expected: to be called at least twice\n"
      "           Actual: called once - unsatisfied and active");
 }
 
 // Tests that the cardinality can be inferred when no Times(...) is
 // specified.
 TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
   {
     MockB b;
     EXPECT_CALL(b, DoB())
@@ skipping 186 matching lines @@
   EXPECT_CALL(a2, DoA(1));
   EXPECT_CALL(a2, DoA(3));
   a2.DoA(1);
   EXPECT_NONFATAL_FAILURE(
       a2.DoA(2),
       "Unexpected mock function call - returning directly.\n"
       "    Function call: DoA(2)\n"
       "Google Mock tried the following 2 expectations, but none matched:");
   EXPECT_NONFATAL_FAILURE(
       a2.DoA(2),
-      "tried expectation #0\n"
+      "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
       "  Expected arg #0: is equal to 1\n"
       "           Actual: 2\n"
       "         Expected: to be called once\n"
       "           Actual: called once - saturated and active");
   EXPECT_NONFATAL_FAILURE(
       a2.DoA(2),
-      "tried expectation #1\n"
+      "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
       "  Expected arg #0: is equal to 3\n"
       "           Actual: 2\n"
       "         Expected: to be called once\n"
       "           Actual: never called - unsatisfied and active");
   a2.DoA(3);
 }
 
 // Tests that an unexpected non-void function generates the right
 // failure message.
 TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
@@ skipping 688 matching lines @@
 
   delete a;  // a is trivially satisfied.
   EXPECT_EQ(1, b1->DoB(1));
   EXPECT_EQ(2, b2->DoB(2));
   delete b1;
   delete b2;
 }
 
 // Tests that it's OK to delete a mock object itself in its action.
 
+// Suppresses warning on unreferenced formal parameter in MSVC with
+// -W4.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 ACTION_P(Delete, ptr) { delete ptr; }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
   MockA* const a = new MockA;
   EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
   a->DoA(42);  // This will cause a to be deleted.
 }
 
 TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
   MockA* const a = new MockA;
   EXPECT_CALL(*a, ReturnResult(_))
       .WillOnce(DoAll(Delete(a), Return(Result())));
@@ skipping 52 matching lines @@
 }
 
 class EvenNumberCardinality : public CardinalityInterface {
  public:
   // Returns true iff call_count calls will satisfy this cardinality.
   virtual bool IsSatisfiedByCallCount(int call_count) const {
     return call_count % 2 == 0;
   }
 
   // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const { return false; }
+  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+    return false;
+  }
 
   // Describes self to an ostream.
   virtual void DescribeTo(::std::ostream* os) const {
     *os << "called even number of times";
   }
 };
 
 Cardinality EvenNumber() {
   return Cardinality(new EvenNumberCardinality);
 }
@@ skipping 28 matching lines @@
   os << "Printable";
 }
 
 struct Unprintable {
   Unprintable() : value(0) {}
   int value;
 };
 
 class MockC {
  public:
+  MockC() {}
+
   MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
                                 const Printable& x, Unprintable y));
   MOCK_METHOD0(NonVoidMethod, int());  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
 };
 
 // TODO(wan@google.com): find a way to re-enable these tests.
 #if 0
 
 // Tests that an uninteresting mock function call generates a warning
 // containing the stack trace.
 TEST(FunctionCallMessageTest, UninterestingCallGeneratesFyiWithStackTrace) {
   MockC c;
   CaptureTestStdout();
@@ skipping 172 matching lines @@
 // buffer) when it is not supposed to do so.
 class PrintMeNot {};
 
 void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
   ADD_FAILURE() << "Google Mock is printing a value that shouldn't be "
                 << "printed even to an internal buffer.";
 }
 
 class LogTestHelper {
  public:
+  LogTestHelper() {}
+
   MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
 };
 
 class GMockLogTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
     // The code needs to work when both ::string and ::std::string are
     // defined and the flag is implemented as a
     // testing::internal::String.  In this case, without the call to
     // c_str(), the compiler will complain that it cannot figure out
     // whether the String flag should be converted to a ::string or an
@@ skipping 96 matching lines @@
   EXPECT_EQ(0, b.DoB(1));
 }
 
 // Tests that we can verify and clear a mock object's expectations
 // when some, but not all, of its methods have expectations *and* the
 // verification fails.
 TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
   MockB b;
   EXPECT_CALL(b, DoB())
       .WillOnce(Return(1));
-  bool result;
+  bool result = true;
   EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
                           "Actual: never called");
   ASSERT_FALSE(result);
 
   // There should be no expectations on the methods now, so we can
   // freely call them.
   EXPECT_EQ(0, b.DoB());
   EXPECT_EQ(0, b.DoB(1));
 }
 
@@ skipping 17 matching lines @@
 
 // Tests that we can verify and clear a mock object's expectations
 // when a method has more than one expectation.
 TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
   MockB b;
   EXPECT_CALL(b, DoB(0))
       .WillOnce(Return(1));
   EXPECT_CALL(b, DoB(_))
       .WillOnce(Return(2));
   b.DoB(1);
-  bool result;
+  bool result = true;
   EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
                           "Actual: never called");
   ASSERT_FALSE(result);
 
   // There should be no expectations on the methods now, so we can
   // freely call them.
   EXPECT_EQ(0, b.DoB());
   EXPECT_EQ(0, b.DoB(1));
 }
 
@@ skipping 111 matching lines @@
 
 // Tests that VerifyAndClear() works when the verification fails.
 TEST(VerifyAndClearTest, Failure) {
   MockB b;
   ON_CALL(b, DoB(_))
       .WillByDefault(Return(1));
   EXPECT_CALL(b, DoB())
       .WillOnce(Return(2));
 
   b.DoB(1);
-  bool result;
+  bool result = true;
   EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
                           "Actual: never called");
   ASSERT_FALSE(result);
 
   // There should be no expectations on the methods now, so we can
   // freely call them.
   EXPECT_EQ(0, b.DoB());
   EXPECT_EQ(0, b.DoB(1));
 }
 
@@ skipping 95 matching lines @@
 #endif  // GMOCK_RENAME_MAIN
   testing::InitGoogleMock(&argc, argv);
 
   // Ensures that the tests pass no matter what value of
   // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
   testing::GMOCK_FLAG(catch_leaked_mocks) = true;
   testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
 
   return RUN_ALL_TESTS();
 }