base/logging_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/logging.h"
   7
   8 #include "testing/gmock/include/gmock/gmock.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace logging {
  12
  13 namespace {
  14
  15 using ::testing::Return;
  16
  17 // Needs to be global since log assert handlers can't maintain state.
  18 int log_sink_call_count = 0;
  19
  20 void LogSink(const std::string& str) {
  21   ++log_sink_call_count;
  22 }
  23
  24 // Class to make sure any manipulations we do to the min log level are
  25 // contained (i.e., do not affect other unit tests).
  26 class LogStateSaver {
  27  public:
  28   LogStateSaver() : old_min_log_level_(GetMinLogLevel()) {}
  29
  30   ~LogStateSaver() {
  31     SetMinLogLevel(old_min_log_level_);
  32     SetLogAssertHandler(NULL);
  33     SetLogReportHandler(NULL);
  34     log_sink_call_count = 0;
  35   }
  36
  37  private:
  38   int old_min_log_level_;
  39
  40   DISALLOW_COPY_AND_ASSIGN(LogStateSaver);
  41 };
  42
  43 class LoggingTest : public testing::Test {
  44  private:
  45   LogStateSaver log_state_saver_;
  46 };
  47
  48 class MockLogSource {
  49  public:
  50   MOCK_METHOD0(Log, const char*());
  51 };
  52
  53 TEST_F(LoggingTest, BasicLogging) {
  54   MockLogSource mock_log_source;
  55   const int kExpectedDebugOrReleaseCalls = 6;
  56   const int kExpectedDebugCalls = 6;
  57   const int kExpectedCalls =
  58       kExpectedDebugOrReleaseCalls + (DEBUG_MODE ? kExpectedDebugCalls : 0);
  59   EXPECT_CALL(mock_log_source, Log()).Times(kExpectedCalls).
  60       WillRepeatedly(Return("log message"));
  61
  62   SetMinLogLevel(LOG_INFO);
  63
  64   EXPECT_TRUE(LOG_IS_ON(INFO));
  65   // As of g++-4.5, the first argument to EXPECT_EQ cannot be a
  66   // constant expression.
  67   const bool kIsDebugMode = (DEBUG_MODE != 0);
  68   EXPECT_EQ(kIsDebugMode, DLOG_IS_ON(INFO));
  69   EXPECT_TRUE(VLOG_IS_ON(0));
  70
  71   LOG(INFO) << mock_log_source.Log();
  72   LOG_IF(INFO, true) << mock_log_source.Log();
  73   PLOG(INFO) << mock_log_source.Log();
  74   PLOG_IF(INFO, true) << mock_log_source.Log();
  75   VLOG(0) << mock_log_source.Log();
  76   VLOG_IF(0, true) << mock_log_source.Log();
  77
  78   DLOG(INFO) << mock_log_source.Log();
  79   DLOG_IF(INFO, true) << mock_log_source.Log();
  80   DPLOG(INFO) << mock_log_source.Log();
  81   DPLOG_IF(INFO, true) << mock_log_source.Log();
  82   DVLOG(0) << mock_log_source.Log();
  83   DVLOG_IF(0, true) << mock_log_source.Log();
  84 }
  85
  86 TEST_F(LoggingTest, LogIsOn) {
  87 #if defined(NDEBUG)
  88   const bool kDfatalIsFatal = false;
  89 #else  // defined(NDEBUG)
  90   const bool kDfatalIsFatal = true;
  91 #endif  // defined(NDEBUG)
  92
  93   SetMinLogLevel(LOG_INFO);
  94   EXPECT_TRUE(LOG_IS_ON(INFO));
  95   EXPECT_TRUE(LOG_IS_ON(WARNING));
  96   EXPECT_TRUE(LOG_IS_ON(ERROR));
  97   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
  98   EXPECT_TRUE(LOG_IS_ON(FATAL));
  99   EXPECT_TRUE(LOG_IS_ON(DFATAL));
 100
 101   SetMinLogLevel(LOG_WARNING);
 102   EXPECT_FALSE(LOG_IS_ON(INFO));
 103   EXPECT_TRUE(LOG_IS_ON(WARNING));
 104   EXPECT_TRUE(LOG_IS_ON(ERROR));
 105   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
 106   EXPECT_TRUE(LOG_IS_ON(FATAL));
 107   EXPECT_TRUE(LOG_IS_ON(DFATAL));
 108
 109   SetMinLogLevel(LOG_ERROR);
 110   EXPECT_FALSE(LOG_IS_ON(INFO));
 111   EXPECT_FALSE(LOG_IS_ON(WARNING));
 112   EXPECT_TRUE(LOG_IS_ON(ERROR));
 113   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
 114   EXPECT_TRUE(LOG_IS_ON(FATAL));
 115   EXPECT_TRUE(LOG_IS_ON(DFATAL));
 116
 117   SetMinLogLevel(LOG_ERROR_REPORT);
 118   EXPECT_FALSE(LOG_IS_ON(INFO));
 119   EXPECT_FALSE(LOG_IS_ON(WARNING));
 120   EXPECT_FALSE(LOG_IS_ON(ERROR));
 121   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
 122   EXPECT_TRUE(LOG_IS_ON(FATAL));
 123   EXPECT_EQ(kDfatalIsFatal, LOG_IS_ON(DFATAL));
 124
 125   // LOG_IS_ON(ERROR_REPORT) should always be true.
 126   SetMinLogLevel(LOG_FATAL);
 127   EXPECT_FALSE(LOG_IS_ON(INFO));
 128   EXPECT_FALSE(LOG_IS_ON(WARNING));
 129   EXPECT_FALSE(LOG_IS_ON(ERROR));
 130   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
 131   EXPECT_TRUE(LOG_IS_ON(FATAL));
 132   EXPECT_EQ(kDfatalIsFatal, LOG_IS_ON(DFATAL));
 133
 134   // So should LOG_IS_ON(FATAL).
 135   SetMinLogLevel(LOG_FATAL + 1);
 136   EXPECT_FALSE(LOG_IS_ON(INFO));
 137   EXPECT_FALSE(LOG_IS_ON(WARNING));
 138   EXPECT_FALSE(LOG_IS_ON(ERROR));
 139   EXPECT_TRUE(LOG_IS_ON(ERROR_REPORT));
 140   EXPECT_TRUE(LOG_IS_ON(FATAL));
 141   EXPECT_EQ(kDfatalIsFatal, LOG_IS_ON(DFATAL));
 142 }
 143
 144 TEST_F(LoggingTest, LoggingIsLazy) {
 145   MockLogSource mock_log_source;
 146   EXPECT_CALL(mock_log_source, Log()).Times(0);
 147
 148   SetMinLogLevel(LOG_WARNING);
 149
 150   EXPECT_FALSE(LOG_IS_ON(INFO));
 151   EXPECT_FALSE(DLOG_IS_ON(INFO));
 152   EXPECT_FALSE(VLOG_IS_ON(1));
 153
 154   LOG(INFO) << mock_log_source.Log();
 155   LOG_IF(INFO, false) << mock_log_source.Log();
 156   PLOG(INFO) << mock_log_source.Log();
 157   PLOG_IF(INFO, false) << mock_log_source.Log();
 158   VLOG(1) << mock_log_source.Log();
 159   VLOG_IF(1, true) << mock_log_source.Log();
 160
 161   DLOG(INFO) << mock_log_source.Log();
 162   DLOG_IF(INFO, true) << mock_log_source.Log();
 163   DPLOG(INFO) << mock_log_source.Log();
 164   DPLOG_IF(INFO, true) << mock_log_source.Log();
 165   DVLOG(1) << mock_log_source.Log();
 166   DVLOG_IF(1, true) << mock_log_source.Log();
 167 }
 168
 169 // Official builds have CHECKs directly call BreakDebugger.
 170 #if !defined(LOGGING_IS_OFFICIAL_BUILD)
 171
 172 TEST_F(LoggingTest, CheckStreamsAreLazy) {
 173   MockLogSource mock_log_source, uncalled_mock_log_source;
 174   EXPECT_CALL(mock_log_source, Log()).Times(8).
 175       WillRepeatedly(Return("check message"));
 176   EXPECT_CALL(uncalled_mock_log_source, Log()).Times(0);
 177
 178   SetLogAssertHandler(&LogSink);
 179
 180   CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log();
 181   PCHECK(!mock_log_source.Log()) << mock_log_source.Log();
 182   CHECK_EQ(mock_log_source.Log(), mock_log_source.Log())
 183       << uncalled_mock_log_source.Log();
 184   CHECK_NE(mock_log_source.Log(), mock_log_source.Log())
 185       << mock_log_source.Log();
 186 }
 187
 188 #endif
 189
 190 TEST_F(LoggingTest, DebugLoggingReleaseBehavior) {
 191 #if !defined(NDEBUG)
 192   int debug_only_variable = 1;
 193 #endif
 194   // These should avoid emitting references to |debug_only_variable|
 195   // in release mode.
 196   DLOG_IF(INFO, debug_only_variable) << "test";
 197   DLOG_ASSERT(debug_only_variable) << "test";
 198   DPLOG_IF(INFO, debug_only_variable) << "test";
 199   DVLOG_IF(1, debug_only_variable) << "test";
 200 }
 201
 202 TEST_F(LoggingTest, DcheckStreamsAreLazy) {
 203   MockLogSource mock_log_source;
 204   EXPECT_CALL(mock_log_source, Log()).Times(0);
 205 #if !defined(LOGGING_IS_OFFICIAL_BUILD) && defined(NDEBUG) && \
 206     !defined(DCHECK_ALWAYS_ON)
 207   // Unofficial release build without dcheck enabled.
 208   g_dcheck_state = DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 209   DCHECK(mock_log_source.Log()) << mock_log_source.Log();
 210   DPCHECK(mock_log_source.Log()) << mock_log_source.Log();
 211   DCHECK_EQ(0, 0) << mock_log_source.Log();
 212   DCHECK_EQ(mock_log_source.Log(), static_cast<const char*>(NULL))
 213       << mock_log_source.Log();
 214 #endif
 215 }
 216
 217 TEST_F(LoggingTest, Dcheck) {
 218 #if LOGGING_IS_OFFICIAL_BUILD
 219   // Official build.
 220   EXPECT_FALSE(DCHECK_IS_ON());
 221   EXPECT_FALSE(DLOG_IS_ON(DCHECK));
 222 #elif defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 223   // Unofficial release build.
 224   g_dcheck_state = ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 225   SetLogReportHandler(&LogSink);
 226   EXPECT_TRUE(DCHECK_IS_ON());
 227   EXPECT_FALSE(DLOG_IS_ON(DCHECK));
 228 #elif defined(NDEBUG) && defined(DCHECK_ALWAYS_ON)
 229   // Unofficial release build with real DCHECKS.
 230   g_dcheck_state = ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 231   SetLogAssertHandler(&LogSink);
 232   EXPECT_TRUE(DCHECK_IS_ON());
 233   EXPECT_FALSE(DLOG_IS_ON(DCHECK));
 234 #else
 235   // Unofficial debug build.
 236   SetLogAssertHandler(&LogSink);
 237   EXPECT_TRUE(DCHECK_IS_ON());
 238   EXPECT_TRUE(DLOG_IS_ON(DCHECK));
 239 #endif  // defined(LOGGING_IS_OFFICIAL_BUILD)
 240
 241   EXPECT_EQ(0, log_sink_call_count);
 242   DCHECK(false);
 243   EXPECT_EQ(DCHECK_IS_ON() ? 1 : 0, log_sink_call_count);
 244   DPCHECK(false);
 245   EXPECT_EQ(DCHECK_IS_ON() ? 2 : 0, log_sink_call_count);
 246   DCHECK_EQ(0, 1);
 247   EXPECT_EQ(DCHECK_IS_ON() ? 3 : 0, log_sink_call_count);
 248 }
 249
 250 TEST_F(LoggingTest, DcheckReleaseBehavior) {
 251   int some_variable = 1;
 252   // These should still reference |some_variable| so we don't get
 253   // unused variable warnings.
 254   DCHECK(some_variable) << "test";
 255   DPCHECK(some_variable) << "test";
 256   DCHECK_EQ(some_variable, 1) << "test";
 257 }
 258
 259 }  // namespace
 260
 261 }  // namespace logging