diff options
| -rw-r--r-- | base/base.gyp | 1 | ||||
| -rw-r--r-- | base/leak_tracker.h | 2 | ||||
| -rw-r--r-- | base/logging.cc | 5 | ||||
| -rw-r--r-- | base/logging.h | 334 | ||||
| -rw-r--r-- | base/logging_unittest.cc | 132 |
5 files changed, 286 insertions, 188 deletions
diff --git a/base/base.gyp b/base/base.gyp index 3655bda..b919d6e 100644 --- a/base/base.gyp +++ b/base/base.gyp @@ -103,6 +103,7 @@ 'linked_list_unittest.cc', 'linked_ptr_unittest.cc', 'lock_unittest.cc', + 'logging_unittest.cc', 'mac_util_unittest.mm', 'message_loop_proxy_impl_unittest.cc', 'message_loop_unittest.cc', diff --git a/base/leak_tracker.h b/base/leak_tracker.h index dd85ff6..96d8773 100644 --- a/base/leak_tracker.h +++ b/base/leak_tracker.h @@ -91,7 +91,7 @@ class LeakTracker : public LinkNode<LeakTracker<T> > { ++count; LOG(ERROR) << "Leaked " << node << " which was allocated by:"; - allocation_stack.OutputToStream(&LOG(ERROR)); + allocation_stack.OutputToStream(&LOG_STREAM(ERROR)); } CHECK_EQ(0u, count); diff --git a/base/logging.cc b/base/logging.cc index f0c6217..ce05d21 100644 --- a/base/logging.cc +++ b/base/logging.cc @@ -561,8 +561,9 @@ void LogMessage::Init(const char* file, int line) { } LogMessage::~LogMessage() { - // TODO(brettw) modify the macros so that nothing is executed when the log - // level is too high. + // The macros in logging.h should already avoid creating LogMessages + // when this holds, but it's possible that users create LogMessages + // directly (e.g., using LOG_STREAM() directly). if (severity_ < min_log_level) return; diff --git a/base/logging.h b/base/logging.h index 386b8ba..4c7421f 100644 --- a/base/logging.h +++ b/base/logging.h @@ -261,11 +261,11 @@ const LogSeverity LOG_ERROR_REPORT = 3; const LogSeverity LOG_FATAL = 4; const LogSeverity LOG_NUM_SEVERITIES = 5; -// LOG_DFATAL_LEVEL is LOG_FATAL in debug mode, ERROR in normal mode +// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode #ifdef NDEBUG -const LogSeverity LOG_DFATAL_LEVEL = LOG_ERROR; +const LogSeverity LOG_DFATAL = LOG_ERROR; #else -const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL; +const LogSeverity LOG_DFATAL = LOG_FATAL; #endif // A few definitions of macros that don't generate much code. These are used @@ -283,8 +283,7 @@ const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL; #define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \ logging::ClassName(__FILE__, __LINE__, logging::LOG_FATAL , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \ - logging::ClassName(__FILE__, __LINE__, \ - logging::LOG_DFATAL_LEVEL , ##__VA_ARGS__) + logging::ClassName(__FILE__, __LINE__, logging::LOG_DFATAL , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_INFO \ COMPACT_GOOGLE_LOG_EX_INFO(LogMessage) @@ -308,6 +307,23 @@ const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL; #define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \ COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__) #define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR +// Needed for LOG_IS_ON(ERROR). +const LogSeverity LOG_0 = LOG_ERROR; + +#define LOG_IS_ON(severity) \ + ((::logging::LOG_ ## severity) >= ::logging::GetMinLogLevel()) + +// We can't do any caching tricks with VLOG_IS_ON() like the +// google-glog version since it requires GCC extensions. This means +// that using the v-logging functions in conjunction with --vmodule +// may be slow. +#define VLOG_IS_ON(verboselevel) \ + ((verboselevel) <= ::logging::GetVlogLevel(__FILE__)) + +// Helper macro which avoids evaluating the arguments to a stream if +// the condition doesn't hold. +#define LAZY_STREAM(stream, condition) \ + !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream) // We use the preprocessor's merging operator, "##", so that, e.g., // LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO. There's some funny @@ -317,62 +333,75 @@ const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL; // impossible to stream something like a string directly to an unnamed // ostream. We employ a neat hack by calling the stream() member // function of LogMessage which seems to avoid the problem. -// -// We can't do any caching tricks with VLOG_IS_ON() like the -// google-glog version since it requires GCC extensions. This means -// that using the v-logging functions in conjunction with --vmodule -// may be slow. -#define VLOG_IS_ON(verboselevel) \ - (logging::GetVlogLevel(__FILE__) >= (verboselevel)) +#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream() + +#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity)) +#define LOG_IF(severity, condition) \ + LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) -#define LOG(severity) COMPACT_GOOGLE_LOG_ ## severity.stream() #define SYSLOG(severity) LOG(severity) +#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition) + #define VLOG(verboselevel) LOG_IF(INFO, VLOG_IS_ON(verboselevel)) +#define VLOG_IF(verboselevel, condition) \ + LOG_IF(INFO, VLOG_IS_ON(verboselevel) && (condition)) // TODO(akalin): Add more VLOG variants, e.g. VPLOG. -#define LOG_IF(severity, condition) \ - !(condition) ? (void) 0 : logging::LogMessageVoidify() & LOG(severity) -#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition) -#define VLOG_IF(verboselevel, condition) \ - LOG_IF(INFO, (condition) && VLOG_IS_ON(verboselevel)) - #define LOG_ASSERT(condition) \ LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " #define SYSLOG_ASSERT(condition) \ SYSLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " #if defined(OS_WIN) -#define LOG_GETLASTERROR(severity) \ +#define LOG_GETLASTERROR_STREAM(severity) \ COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \ ::logging::GetLastSystemErrorCode()).stream() -#define LOG_GETLASTERROR_MODULE(severity, module) \ +#define LOG_GETLASTERROR(severity) \ + LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity), LOG_IS_ON(severity)) +#define LOG_GETLASTERROR_MODULE_STREAM(severity, module) \ COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \ ::logging::GetLastSystemErrorCode(), module).stream() -// PLOG is the usual error logging macro for each platform. -#define PLOG(severity) LOG_GETLASTERROR(severity) -#define DPLOG(severity) DLOG_GETLASTERROR(severity) +#define LOG_GETLASTERROR_MODULE(severity, module) \ + LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity, module), \ + LOG_IS_ON(severity)) +// PLOG_STREAM is used by PLOG, which is the usual error logging macro +// for each platform. +#define PLOG_STREAM(severity) LOG_GETLASTERROR_STREAM(severity) #elif defined(OS_POSIX) -#define LOG_ERRNO(severity) \ +#define LOG_ERRNO_STREAM(severity) \ COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \ ::logging::GetLastSystemErrorCode()).stream() -// PLOG is the usual error logging macro for each platform. -#define PLOG(severity) LOG_ERRNO(severity) -#define DPLOG(severity) DLOG_ERRNO(severity) +#define LOG_ERRNO(severity) \ + LAZY_STREAM(LOG_ERRNO_STREAM(severity), LOG_IS_ON(severity)) +// PLOG_STREAM is used by PLOG, which is the usual error logging macro +// for each platform. +#define PLOG_STREAM(severity) LOG_ERRNO_STREAM(severity) // TODO(tschmelcher): Should we add OSStatus logging for Mac? #endif +#define PLOG(severity) \ + LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity)) + #define PLOG_IF(severity, condition) \ - !(condition) ? (void) 0 : logging::LogMessageVoidify() & PLOG(severity) + LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition)) // CHECK dies with a fatal error if condition is not true. It is *not* // controlled by NDEBUG, so the check will be executed regardless of // compilation mode. -#define CHECK(condition) \ - LOG_IF(FATAL, !(condition)) << "Check failed: " #condition ". " +// +// We make sure CHECK et al. always evaluates their arguments, as +// doing CHECK(FunctionWithSideEffect()) is a common idiom. +// +// TODO(akalin): Fix the problem where if the min log level is > +// FATAL, CHECK() et al. won't terminate the program. +#define CHECK(condition) \ + LAZY_STREAM(LOG_STREAM(FATAL), !(condition)) \ + << "Check failed: " #condition ". " #define PCHECK(condition) \ - PLOG_IF(FATAL, !(condition)) << "Check failed: " #condition ". " + LAZY_STREAM(PLOG_STREAM(FATAL), !(condition)) \ + << "Check failed: " #condition ". " // A container for a string pointer which can be evaluated to a bool - // true iff the pointer is NULL. @@ -413,13 +442,20 @@ extern template std::string* MakeCheckOpString<std::string, std::string>( // Helper macro for binary operators. // Don't use this macro directly in your code, use CHECK_EQ et al below. -#define CHECK_OP(name, op, val1, val2) \ - if (logging::CheckOpString _result = \ - logging::Check##name##Impl((val1), (val2), #val1 " " #op " " #val2)) \ +// +// TODO(akalin): Rewrite this so that constructs like if (...) +// CHECK_EQ(...) else { ... } work properly. +#define CHECK_OP(name, op, val1, val2) \ + if (logging::CheckOpString _result = \ + logging::Check##name##Impl((val1), (val2), \ + #val1 " " #op " " #val2)) \ logging::LogMessage(__FILE__, __LINE__, _result).stream() // Helper functions for string comparisons. // To avoid bloat, the definitions are in logging.cc. +// +// TODO(akalin): Actually have the implementations in logging.cc, or +// remove these. #define DECLARE_CHECK_STROP_IMPL(func, expected) \ std::string* Check##func##expected##Impl(const char* s1, \ const char* s2, \ @@ -484,49 +520,6 @@ DECLARE_CHECK_STROP_IMPL(_stricmp, false) // Definitions for DLOG et al. -#if ENABLE_DLOG - -#define DLOG(severity) LOG(severity) -#define DLOG_IF(severity, condition) LOG_IF(severity, condition) -#define DLOG_ASSERT(condition) LOG_ASSERT(condition) - -#if defined(OS_WIN) -#define DLOG_GETLASTERROR(severity) LOG_GETLASTERROR(severity) -#define DLOG_GETLASTERROR_MODULE(severity, module) \ - LOG_GETLASTERROR_MODULE(severity, module) -#elif defined(OS_POSIX) -#define DLOG_ERRNO(severity) LOG_ERRNO(severity) -#endif - -#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition) - -#else // ENABLE_DLOG - -#define DLOG(severity) \ - true ? (void) 0 : logging::LogMessageVoidify() & LOG(severity) - -#define DLOG_IF(severity, condition) \ - true ? (void) 0 : logging::LogMessageVoidify() & LOG(severity) - -#define DLOG_ASSERT(condition) \ - true ? (void) 0 : LOG_ASSERT(condition) - -#if defined(OS_WIN) -#define DLOG_GETLASTERROR(severity) \ - true ? (void) 0 : logging::LogMessageVoidify() & LOG_GETLASTERROR(severity) -#define DLOG_GETLASTERROR_MODULE(severity, module) \ - true ? (void) 0 : logging::LogMessageVoidify() & \ - LOG_GETLASTERROR_MODULE(severity, module) -#elif defined(OS_POSIX) -#define DLOG_ERRNO(severity) \ - true ? (void) 0 : logging::LogMessageVoidify() & LOG_ERRNO(severity) -#endif - -#define DPLOG_IF(severity, condition) \ - true ? (void) 0 : logging::LogMessageVoidify() & PLOG(severity) - -#endif // ENABLE_DLOG - // DEBUG_MODE is for uses like // if (DEBUG_MODE) foo.CheckThatFoo(); // instead of @@ -539,89 +532,86 @@ enum { DEBUG_MODE = ENABLE_DLOG }; #undef ENABLE_DLOG -// Definitions for DCHECK et al. +#define DLOG_IS_ON(severity) (::logging::DEBUG_MODE && LOG_IS_ON(severity)) -// This macro can be followed by a sequence of stream parameters in -// non-debug mode. The DCHECK and friends macros use this so that -// the expanded expression DCHECK(foo) << "asdf" is still syntactically -// valid, even though the expression will get optimized away. -#define DCHECK_EAT_STREAM_PARAMETERS \ - logging::LogMessage(__FILE__, __LINE__).stream() +#define DLOG(severity) \ + LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity)) +#define DLOG_IF(severity, condition) \ + LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity) && (condition)) -#if ENABLE_DCHECK +#define DLOG_ASSERT(condition) \ + DLOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". " -#ifndef NDEBUG -// On a regular debug build, we want to have DCHECKS enabled. - -#define DCHECK(condition) CHECK(condition) -#define DPCHECK(condition) PCHECK(condition) - -// Helper macro for binary operators. -// Don't use this macro directly in your code, use DCHECK_EQ et al below. -#define DCHECK_OP(name, op, val1, val2) \ - if (logging::CheckOpString _result = \ - logging::Check##name##Impl((val1), (val2), #val1 " " #op " " #val2)) \ - logging::LogMessage(__FILE__, __LINE__, _result).stream() +#if defined(OS_WIN) +#define DLOG_GETLASTERROR(severity) \ + LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity), DLOG_IS_ON(severity)) +#define DLOG_GETLASTERROR_MODULE(severity, module) \ + LAZY_STREAM(LOG_GETLASTERROR_STREAM(severity, module), \ + DLOG_IS_ON(severity)) +#elif defined(OS_POSIX) +#define DLOG_ERRNO(severity) \ + LAZY_STREAM(LOG_ERRNO_STREAM(severity), DLOG_IS_ON(severity)) +#endif -// Helper macro for string comparisons. -// Don't use this macro directly in your code, use CHECK_STREQ et al below. -#define DCHECK_STROP(func, op, expected, s1, s2) \ - while (CheckOpString _result = \ - logging::Check##func##expected##Impl((s1), (s2), \ - #s1 " " #op " " #s2)) \ - LOG(FATAL) << *_result.str_ +#define DPLOG(severity) \ + LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity)) +#define DPLOG_IF(severity, condition) \ + LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity) && (condition)) -// String (char*) equality/inequality checks. -// CASE versions are case-insensitive. -// -// Note that "s1" and "s2" may be temporary strings which are destroyed -// by the compiler at the end of the current "full expression" -// (e.g. DCHECK_STREQ(Foo().c_str(), Bar().c_str())). +#define DVLOG(verboselevel) DLOG_IF(INFO, VLOG_IS_ON(verboselevel)) +#define DVLOG_IF(verboselevel, condition) \ + DLOG_IF(INFO, VLOG_IS_ON(verboselevel) && (condition)) -#define DCHECK_STREQ(s1, s2) DCHECK_STROP(strcmp, ==, true, s1, s2) -#define DCHECK_STRNE(s1, s2) DCHECK_STROP(strcmp, !=, false, s1, s2) -#define DCHECK_STRCASEEQ(s1, s2) DCHECK_STROP(_stricmp, ==, true, s1, s2) -#define DCHECK_STRCASENE(s1, s2) DCHECK_STROP(_stricmp, !=, false, s1, s2) +// Definitions for DCHECK et al. -#define DCHECK_INDEX(I,A) DCHECK(I < (sizeof(A)/sizeof(A[0]))) -#define DCHECK_BOUND(B,A) DCHECK(B <= (sizeof(A)/sizeof(A[0]))) +#if ENABLE_DCHECK -#else // NDEBUG -// On a regular release build we want to be able to enable DCHECKS through the -// command line. +#if defined(NDEBUG) // Set to true in InitLogging when we want to enable the dchecks in release. extern bool g_enable_dcheck; -#define DCHECK(condition) \ - !logging::g_enable_dcheck ? void (0) : \ - LOG_IF(ERROR_REPORT, !(condition)) << "Check failed: " #condition ". " +#define DCHECK_IS_ON() (::logging::g_enable_dcheck) +#define DCHECK_SEVERITY ERROR_REPORT +const LogSeverity LOG_DCHECK = LOG_ERROR_REPORT; -#define DPCHECK(condition) \ - !logging::g_enable_dcheck ? void (0) : \ - PLOG_IF(ERROR_REPORT, !(condition)) << "Check failed: " #condition ". " +#else // defined(NDEBUG) -// Helper macro for binary operators. -// Don't use this macro directly in your code, use DCHECK_EQ et al below. -#define DCHECK_OP(name, op, val1, val2) \ - if (logging::g_enable_dcheck) \ - if (logging::CheckOpString _result = \ - logging::Check##name##Impl((val1), (val2), #val1 " " #op " " #val2)) \ - logging::LogMessage(__FILE__, __LINE__, logging::LOG_ERROR_REPORT, \ - _result).stream() +// On a regular debug build, we want to have DCHECKS enabled. +#define DCHECK_IS_ON() (true) +#define DCHECK_SEVERITY FATAL +const LogSeverity LOG_DCHECK = LOG_FATAL; -#define DCHECK_STREQ(str1, str2) \ - while (false) DCHECK_EAT_STREAM_PARAMETERS +#endif // defined(NDEBUG) -#define DCHECK_STRCASEEQ(str1, str2) \ - while (false) DCHECK_EAT_STREAM_PARAMETERS +#else // ENABLE_DCHECK + +#define DCHECK_IS_ON() (false) +#define DCHECK_SEVERITY FATAL +const LogSeverity LOG_DCHECK = LOG_FATAL; + +#endif // ENABLE_DCHECK -#define DCHECK_STRNE(str1, str2) \ - while (false) DCHECK_EAT_STREAM_PARAMETERS +// Unlike CHECK et al., DCHECK et al. *does* evaluate their arguments +// lazily. -#define DCHECK_STRCASENE(str1, str2) \ - while (false) DCHECK_EAT_STREAM_PARAMETERS +#define DCHECK(condition) \ + DLOG_IF(DCHECK_SEVERITY, DCHECK_IS_ON() && !(condition)) \ + << "Check failed: " #condition ". " -#endif // NDEBUG +#define DPCHECK(condition) \ + DPLOG_IF(DCHECK_SEVERITY, DCHECK_IS_ON() && !(condition)) \ + << "Check failed: " #condition ". " + +// Helper macro for binary operators. +// Don't use this macro directly in your code, use DCHECK_EQ et al below. +#define DCHECK_OP(name, op, val1, val2) \ + if (DLOG_IS_ON(DCHECK_SEVERITY)) \ + if (logging::CheckOpString _result = \ + logging::Check##name##Impl((val1), (val2), \ + #val1 " " #op " " #val2)) \ + logging::LogMessage( \ + __FILE__, __LINE__, ::logging::LOG_DCHECK, \ + _result).stream() // Equality/Inequality checks - compare two values, and log a LOG_FATAL message // including the two values when the result is not as expected. The values @@ -648,51 +638,25 @@ extern bool g_enable_dcheck; #define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2) #define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2) -#else // ENABLE_DCHECK - -// In order to avoid variable unused warnings for code that only uses a -// variable in a CHECK, we make sure to use the macro arguments. - -#define DCHECK(condition) \ - while (false && (condition)) DCHECK_EAT_STREAM_PARAMETERS - -#define DPCHECK(condition) \ - while (false && (condition)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_EQ(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_NE(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_LE(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_LT(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_GE(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_GT(val1, val2) \ - while (false && (val1) == (val2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_STREQ(str1, str2) \ - while (false && (str1) == (str2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_STRCASEEQ(str1, str2) \ - while (false && (str1) == (str2)) DCHECK_EAT_STREAM_PARAMETERS - -#define DCHECK_STRNE(str1, str2) \ - while (false && (str1) == (str2)) DCHECK_EAT_STREAM_PARAMETERS +// Helper macro for string comparisons. +// Don't use this macro directly in your code, use DCHECK_STREQ et al below. +#define DCHECK_STROP(func, op, expected, s1, s2) \ + if (DCHECK_IS_ON()) CHECK_STROP(func, op, expected, s1, s2) -#define DCHECK_STRCASENE(str1, str2) \ - while (false && (str1) == (str2)) DCHECK_EAT_STREAM_PARAMETERS +// String (char*) equality/inequality checks. +// CASE versions are case-insensitive. +// +// Note that "s1" and "s2" may be temporary strings which are destroyed +// by the compiler at the end of the current "full expression" +// (e.g. DCHECK_STREQ(Foo().c_str(), Bar().c_str())). -#endif // ENABLE_DCHECK -#undef ENABLE_DCHECK +#define DCHECK_STREQ(s1, s2) DCHECK_STROP(strcmp, ==, true, s1, s2) +#define DCHECK_STRNE(s1, s2) DCHECK_STROP(strcmp, !=, false, s1, s2) +#define DCHECK_STRCASEEQ(s1, s2) DCHECK_STROP(_stricmp, ==, true, s1, s2) +#define DCHECK_STRCASENE(s1, s2) DCHECK_STROP(_stricmp, !=, false, s1, s2) -#undef DCHECK_EAT_STREAM_PARAMETERS +#define DCHECK_INDEX(I,A) DCHECK(I < (sizeof(A)/sizeof(A[0]))) +#define DCHECK_BOUND(B,A) DCHECK(B <= (sizeof(A)/sizeof(A[0]))) // Helper functions for CHECK_OP macro. // The (int, int) specialization works around the issue that the compiler diff --git a/base/logging_unittest.cc b/base/logging_unittest.cc new file mode 100644 index 0000000..8a4e7c1 --- /dev/null +++ b/base/logging_unittest.cc @@ -0,0 +1,132 @@ +// Copyright (c) 2010 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/basictypes.h" +#include "base/logging.h" + +#include "testing/gmock/include/gmock/gmock.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace logging { + +namespace { + +using ::testing::Return; + +// Class to make sure any manipulations we do to the min log level are +// contained (i.e., do not affect other unit tests). +class MinLogLevelSaver { + public: + MinLogLevelSaver() : old_min_log_level_(GetMinLogLevel()) {} + + ~MinLogLevelSaver() { SetMinLogLevel(old_min_log_level_); } + + private: + int old_min_log_level_; + + DISALLOW_COPY_AND_ASSIGN(MinLogLevelSaver); +}; + +class LoggingTest : public testing::Test { + private: + MinLogLevelSaver min_log_level_saver_; +}; + +class MockLogSource { + public: + MOCK_METHOD0(Log, const char*()); +}; + +TEST_F(LoggingTest, BasicLogging) { + MockLogSource mock_log_source; + const int kExpectedDebugOrReleaseCalls = 6; + const int kExpectedDebugCalls = 6; + const int kExpectedCalls = + kExpectedDebugOrReleaseCalls + (DEBUG_MODE ? kExpectedDebugCalls : 0); + EXPECT_CALL(mock_log_source, Log()).Times(kExpectedCalls). + WillRepeatedly(Return("log message")); + + SetMinLogLevel(LOG_INFO); + + EXPECT_TRUE(LOG_IS_ON(INFO)); + EXPECT_EQ(DEBUG_MODE != 0, DLOG_IS_ON(INFO)); + EXPECT_TRUE(VLOG_IS_ON(0)); + + LOG(INFO) << mock_log_source.Log(); + LOG_IF(INFO, true) << mock_log_source.Log(); + PLOG(INFO) << mock_log_source.Log(); + PLOG_IF(INFO, true) << mock_log_source.Log(); + VLOG(0) << mock_log_source.Log(); + VLOG_IF(0, true) << mock_log_source.Log(); + + DLOG(INFO) << mock_log_source.Log(); + DLOG_IF(INFO, true) << mock_log_source.Log(); + DPLOG(INFO) << mock_log_source.Log(); + DPLOG_IF(INFO, true) << mock_log_source.Log(); + DVLOG(0) << mock_log_source.Log(); + DVLOG_IF(0, true) << mock_log_source.Log(); +} + +TEST_F(LoggingTest, LoggingIsLazy) { + MockLogSource mock_log_source; + EXPECT_CALL(mock_log_source, Log()).Times(0); + + SetMinLogLevel(LOG_WARNING); + + EXPECT_FALSE(LOG_IS_ON(INFO)); + EXPECT_FALSE(DLOG_IS_ON(INFO)); + EXPECT_FALSE(VLOG_IS_ON(1)); + + LOG(INFO) << mock_log_source.Log(); + LOG_IF(INFO, false) << mock_log_source.Log(); + PLOG(INFO) << mock_log_source.Log(); + PLOG_IF(INFO, false) << mock_log_source.Log(); + VLOG(1) << mock_log_source.Log(); + VLOG_IF(1, true) << mock_log_source.Log(); + + DLOG(INFO) << mock_log_source.Log(); + DLOG_IF(INFO, true) << mock_log_source.Log(); + DPLOG(INFO) << mock_log_source.Log(); + DPLOG_IF(INFO, true) << mock_log_source.Log(); + DVLOG(1) << mock_log_source.Log(); + DVLOG_IF(1, true) << mock_log_source.Log(); +} + +TEST_F(LoggingTest, ChecksAreNotLazy) { + MockLogSource mock_log_source, uncalled_mock_log_source; + EXPECT_CALL(mock_log_source, Log()).Times(8). + WillRepeatedly(Return("check message")); + EXPECT_CALL(uncalled_mock_log_source, Log()).Times(0); + + SetMinLogLevel(LOG_FATAL + 1); + EXPECT_FALSE(LOG_IS_ON(FATAL)); + + CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log(); + PCHECK(!mock_log_source.Log()) << mock_log_source.Log(); + CHECK_EQ(mock_log_source.Log(), mock_log_source.Log()) + << uncalled_mock_log_source.Log(); + CHECK_NE(mock_log_source.Log(), mock_log_source.Log()) + << mock_log_source.Log(); +} + +TEST_F(LoggingTest, DchecksAreLazy) { + MockLogSource mock_log_source; + EXPECT_CALL(mock_log_source, Log()).Times(0); + +#if defined(NDEBUG) + logging::g_enable_dcheck = false; +#else + SetMinLogLevel(LOG_FATAL + 1); + EXPECT_FALSE(LOG_IS_ON(FATAL)); +#endif + DCHECK(mock_log_source.Log()) << mock_log_source.Log(); + DPCHECK(mock_log_source.Log()) << mock_log_source.Log(); + DCHECK_EQ(0, 0) << mock_log_source.Log(); + DCHECK_EQ(mock_log_source.Log(), static_cast<const char*>(NULL)) + << mock_log_source.Log(); +} + +} // namespace + +} // namespace logging |