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

base/logging_unittest.cc

Index: base/logging_unittest.cc
diff --git a/base/logging_unittest.cc b/base/logging_unittest.cc
index 8a20c54fb4c605734bf45c4b8bb582a76276e104..84dbdd335658173d513e8b36576c384bad6feae2 100644
--- a/base/logging_unittest.cc
+++ b/base/logging_unittest.cc
@@ -13,7 +13,9 @@ 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;
@@ -293,6 +295,93 @@ TEST_F(LoggingTest, CheckEqStatements) {
     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) {
+  size_t 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) {
+  size_t 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"));
+}
+

[wychen, 2016/08/17 17:08:54]

Note to self: generate message inside OnMessage().

 // 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