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 TEST_F(LoggingTest, CheckStreamsAreLazy) { 170 MockLogSource mock_log_source, uncalled_mock_log_source; 171 EXPECT_CALL(mock_log_source, Log()).Times(8). 172 WillRepeatedly(Return("check message")); 173 EXPECT_CALL(uncalled_mock_log_source, Log()).Times(0); 174 175 SetLogAssertHandler(&LogSink); 176 177 CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log(); 178 PCHECK(!mock_log_source.Log()) << mock_log_source.Log(); 179 CHECK_EQ(mock_log_source.Log(), mock_log_source.Log()) 180 << uncalled_mock_log_source.Log(); 181 CHECK_NE(mock_log_source.Log(), mock_log_source.Log()) 182 << mock_log_source.Log(); 183 } 184 185 TEST_F(LoggingTest, DebugLoggingReleaseBehavior) { 186 #if !defined(NDEBUG) 187 int debug_only_variable = 1; 188 #endif 189 // These should avoid emitting references to |debug_only_variable| 190 // in release mode. 191 DLOG_IF(INFO, debug_only_variable) << "test"; 192 DLOG_ASSERT(debug_only_variable) << "test"; 193 DPLOG_IF(INFO, debug_only_variable) << "test"; 194 DVLOG_IF(1, debug_only_variable) << "test"; 195 } 196 197 TEST_F(LoggingTest, DcheckStreamsAreLazy) { 198 MockLogSource mock_log_source; 199 EXPECT_CALL(mock_log_source, Log()).Times(0); 200 201 #if !defined(LOGGING_IS_OFFICIAL_BUILD) && defined(NDEBUG) 202 // Unofficial release build. 203 g_dcheck_state = DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS; 204 DCHECK(mock_log_source.Log()) << mock_log_source.Log(); 205 DPCHECK(mock_log_source.Log()) << mock_log_source.Log(); 206 DCHECK_EQ(0, 0) << mock_log_source.Log(); 207 DCHECK_EQ(mock_log_source.Log(), static_cast<const char*>(NULL)) 208 << mock_log_source.Log(); 209 #endif // !defined(LOGGING_IS_OFFICIAL_BUILD) && defined(NDEBUG) 210 } 211 212 TEST_F(LoggingTest, Dcheck) { 213 #if defined(LOGGING_IS_OFFICIAL_BUILD) 214 // Official build. 215 EXPECT_FALSE(DCHECK_IS_ON()); 216 EXPECT_FALSE(DLOG_IS_ON(DCHECK)); 217 #elif defined(NDEBUG) 218 // Unofficial release build. 219 g_dcheck_state = ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS; 220 SetLogReportHandler(&LogSink); 221 EXPECT_TRUE(DCHECK_IS_ON()); 222 EXPECT_FALSE(DLOG_IS_ON(DCHECK)); 223 #else 224 // Unofficial debug build. 225 SetLogAssertHandler(&LogSink); 226 EXPECT_TRUE(DCHECK_IS_ON()); 227 EXPECT_TRUE(DLOG_IS_ON(DCHECK)); 228 #endif // defined(LOGGING_IS_OFFICIAL_BUILD) 229 230 EXPECT_EQ(0, log_sink_call_count); 231 DCHECK(false); 232 EXPECT_EQ(DCHECK_IS_ON() ? 1 : 0, log_sink_call_count); 233 DPCHECK(false); 234 EXPECT_EQ(DCHECK_IS_ON() ? 2 : 0, log_sink_call_count); 235 DCHECK_EQ(0, 1); 236 EXPECT_EQ(DCHECK_IS_ON() ? 3 : 0, log_sink_call_count); 237 } 238 239 TEST_F(LoggingTest, DcheckReleaseBehavior) { 240 int some_variable = 1; 241 // These should still reference |some_variable| so we don't get 242 // unused variable warnings. 243 DCHECK(some_variable) << "test"; 244 DPCHECK(some_variable) << "test"; 245 DCHECK_EQ(some_variable, 1) << "test"; 246 } 247 248 } // namespace 249 250 } // namespace logging 251
