clang: update gtest/gmock

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 1765 matching lines @@
   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);
 };
 
+class VerboseFlagPreservingFixture : public testing::Test {
+ protected:
+  // 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 what overload of string constructor to use.
+  // TODO(vladl@google.com): Use internal::string instead of String for
+  // string flags in Google Test.
+  VerboseFlagPreservingFixture()
+      : saved_verbose_flag_(GMOCK_FLAG(verbose).c_str()) {}
+
+  ~VerboseFlagPreservingFixture() { GMOCK_FLAG(verbose) = saved_verbose_flag_; }
+
+ private:
+  const string saved_verbose_flag_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
+};
+
 #if GTEST_HAS_STREAM_REDIRECTION_
 
 // Tests that an uninteresting mock function call generates a warning
 // containing the stack trace.
 TEST(FunctionCallMessageTest, UninterestingCallGeneratesFyiWithStackTrace) {
   MockC c;
   CaptureStdout();
   c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
   const String output = GetCapturedStdout();
   EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
@@ skipping 39 matching lines @@
               ContainsRegex(
                   "Uninteresting mock function call - returning directly\\.\n"
                   "    Function call: VoidMethod"
                   "\\(false, 5, \"Hi\", NULL, @.+ "
                   "Printable, 4-byte object <0000 0000>\\)"));
   // A void function has no return value to print.
 }
 
 // Tests how the --gmock_verbose flag affects Google Mock's output.
 
-class GMockVerboseFlagTest : public testing::Test {
+class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
  public:
   // Verifies that the given Google Mock output is correct.  (When
   // should_print is true, the output should match the given regex and
   // contain the given function name in the stack trace.  When it's
   // false, the output should be empty.)
   void VerifyOutput(const String& output, bool should_print,
                     const string& expected_substring,
                     const string& function_name) {
     if (should_print) {
       EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
@@ skipping 119 matching lines @@
 class LogTestHelper {
  public:
   LogTestHelper() {}
 
   MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
 
  private:
   GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
 };
 
-class GMockLogTest : public ::testing::Test {
+class GMockLogTest : public VerboseFlagPreservingFixture {
  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
-    // ::std::string before being assigned to original_verbose_.
-    original_verbose_ = GMOCK_FLAG(verbose).c_str();
-  }
-
-  virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; }
-
   LogTestHelper helper_;
-  string original_verbose_;
 };
 
 TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
   GMOCK_FLAG(verbose) = kWarningVerbosity;
   EXPECT_CALL(helper_, Foo(_))
       .WillOnce(Return(PrintMeNot()));
   helper_.Foo(PrintMeNot());  // This is an expected call.
 }
 
 TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
@@ skipping 340 matching lines @@
 
   EXPECT_EQ(1, b1.DoB());
   EXPECT_EQ(2, b1.DoB(0));
 }
 
 // Tests that a mock function's action can call a mock function
 // (either the same function or a different one) either as an explicit
 // action or as a default action without causing a dead lock.  It
 // verifies that the action is not performed inside the critical
 // section.
+TEST(SynchronizationTest, CanCallMockMethodInAction) {
+  MockA a;
+  MockC c;
+  ON_CALL(a, DoA(_))
+      .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
+                                                    &MockC::NonVoidMethod)));
+  EXPECT_CALL(a, DoA(1));
+  EXPECT_CALL(a, DoA(1))
+      .WillOnce(Invoke(&a, &MockA::DoA))
+      .RetiresOnSaturation();
+  EXPECT_CALL(c, NonVoidMethod());
 
-void Helper(MockC* c) {
-  c->NonVoidMethod();
+  a.DoA(1);
+  // This will match the second EXPECT_CALL() and trigger another a.DoA(1),
+  // which will in turn match the first EXPECT_CALL() and trigger a call to
+  // c.NonVoidMethod() that was specified by the ON_CALL() since the first
+  // EXPECT_CALL() did not specify an action.
 }
 
 }  // namespace
 
 // Allows the user to define his own main and then invoke gmock_main
 // from it. This might be necessary on some platforms which require
 // specific setup and teardown.
 #if GMOCK_RENAME_MAIN
 int gmock_main(int argc, char **argv) {
 #else
 int main(int argc, char **argv) {
 #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();
 }