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_TRUE(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_TRUE(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_TRUE(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_TRUE(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 set_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 set_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 set_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 262