Allow multiple logging::LogMessage{Handler,Listener}s

base/logging_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace logging {
 
 namespace {
 
+using ::testing::HasSubstr;
 using ::testing::Return;
+using ::testing::_;
 
 // Needs to be global since log assert handlers can't maintain state.
 int log_sink_call_count = 0;
 
 #if !defined(OFFICIAL_BUILD) || defined(DCHECK_ALWAYS_ON) || !defined(NDEBUG)
 void LogSink(const std::string& str) {
   ++log_sink_call_count;
 }
 #endif
 
@@ skipping 259 matching lines @@
   if (false)
     CHECK_EQ(false, true);           // Unreached.
   else
     CHECK_EQ(true, reached = true);  // Reached, passed.
   ASSERT_TRUE(reached);
 
   if (false)
     CHECK_EQ(false, true);           // Unreached.
 }
 
+class MockLogMessageHandler : logging::LogMessageHandler {
+ public:
+  MOCK_METHOD5(OnMessage,
+               bool(int severity,
+                    const char* file,
+                    int line,
+                    size_t message_start,
+                    const std::string& str));
+};
+
+TEST_F(LoggingTest, LogHandlerSink) {
+  unsigned count = LogMessageHandlerCountForTesting();
+  {
+    MockLogMessageHandler log, log2, log3;
+    EXPECT_EQ(count + 3, LogMessageHandlerCountForTesting());
+
+    testing::InSequence s;
+    EXPECT_CALL(log3, OnMessage(_, _, _, _, HasSubstr("testing1")))
+        .WillOnce(::testing::Return(false));
+    EXPECT_CALL(log2, OnMessage(_, _, _, _, HasSubstr("testing1")))
+        .WillOnce(::testing::Return(true));
+    EXPECT_CALL(log, OnMessage(_, _, _, _, HasSubstr("testing1")))
+        .Times(0);
+
+    EXPECT_CALL(log3, OnMessage(_, _, _, _, HasSubstr("testing2")))
+        .WillOnce(::testing::Return(false));
+    EXPECT_CALL(log2, OnMessage(_, _, _, _, HasSubstr("testing2")))
+        .WillOnce(::testing::Return(false));
+    EXPECT_CALL(log, OnMessage(_, _, _, _, HasSubstr("testing2")))
+        .Times(1);
+
+    LOG(WARNING) << "testing1";
+    LOG(WARNING) << "testing2";
+  }
+  EXPECT_EQ(count, LogMessageHandlerCountForTesting());
+}
+
+class MockLogMessageListener : logging::LogMessageListener {
+ public:
+  MockLogMessageListener(std::string &buffer): buffer_(buffer) {}
+  void OnMessage(int severity, const char* file, int line,
+                 size_t message_start, const std::string& str) override {
+    buffer_.append(str);
+  }
+ private:
+  std::string& buffer_;
+};
+
+TEST_F(LoggingTest, LogListenerBasic) {
+  std::string buffer;
+  MockLogMessageListener log(buffer);
+
+  LOG(INFO) << "testing1";
+  LOG(WARNING) << "testing2";
+
+  EXPECT_NE(std::string::npos, buffer.find("testing1"));
+  EXPECT_NE(std::string::npos, buffer.find("testing2"));
+}
+
+TEST_F(LoggingTest, LogListenerLifespan) {
+  unsigned count = LogMessageListenerCountForTesting();
+  std::string buf1, buf2;
+  MockLogMessageListener* log1 = nullptr;
+  {
+    MockLogMessageListener log2(buf2);
+    EXPECT_EQ(count + 1, LogMessageListenerCountForTesting());
+
+    LOG(WARNING) << "testing1";
+    log1 = new MockLogMessageListener(buf1);
+    EXPECT_EQ(count + 2, LogMessageListenerCountForTesting());
+    LOG(WARNING) << "testing2";
+  }
+  EXPECT_EQ(count + 1, LogMessageListenerCountForTesting());
+  LOG(WARNING) << "testing3";
+  delete log1;
+  EXPECT_EQ(count, LogMessageListenerCountForTesting());
+
+  EXPECT_EQ(std::string::npos, buf1.find("testing1"));
+  EXPECT_NE(std::string::npos, buf1.find("testing2"));
+  EXPECT_NE(std::string::npos, buf1.find("testing3"));
+  EXPECT_NE(std::string::npos, buf2.find("testing1"));
+  EXPECT_NE(std::string::npos, buf2.find("testing2"));
+  EXPECT_EQ(std::string::npos, buf2.find("testing3"));
+}
+
 // Test that defining an operator<< for a type in a namespace doesn't prevent
 // other code in that namespace from calling the operator<<(ostream, wstring)
 // defined by logging.h. This can fail if operator<<(ostream, wstring) can't be
 // found by ADL, since defining another operator<< prevents name lookup from
 // looking in the global namespace.
 namespace nested_test {
   class Streamable {};
   ALLOW_UNUSED_TYPE std::ostream& operator<<(std::ostream& out,
                                              const Streamable&) {
     return out << "Streamable";
   }
   TEST_F(LoggingTest, StreamingWstringFindsCorrectOperator) {
     std::wstring wstr = L"Hello World";
     std::ostringstream ostr;
     ostr << wstr;
     EXPECT_EQ("Hello World", ostr.str());
   }
 }  // namespace nested_test
 
 }  // namespace
 
 }  // namespace logging