openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "Base: Add more log macros"

This commit is contained in:
Treehugger Robot 2016-09-22 23:56:48 +00:00 committed by Gerrit Code Review
parent 65a1633ec3 436f5a031f
commit 58af713d8a
2 changed files with 465 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
base/include/android-base/logging.h
View File

@ -120,11 +120,35 @@ class ErrnoRestorer {
DISALLOW_COPY_AND_ASSIGN(ErrnoRestorer);
};
// Defines whether the given severity will be logged or silently swallowed.
#define WOULD_LOG(severity) WOULD_LOG_SEVERITY(::android::base::severity)
#define WOULD_LOG_SEVERITY(severity) \
UNLIKELY((severity) >= ::android::base::GetMinimumLogSeverity())
// Get an ostream that can be used for logging at the given severity and to the default
// destination.
//
// Notes:
// 1) This will not check whether the severity is high enough. One should use WOULD_LOG to filter
// usage manually.
// 2) This does not save and restore errno.
#define LOG_STREAM(severity) LOG_STREAM_S(::android::base::severity)
#define LOG_STREAM_S(severity) LOG_STREAM_TO_S(DEFAULT, severity)
// Get an ostream that can be used for logging at the given severity and to the
// given destination. The same notes as for LOG_STREAM apply.
#define LOG_STREAM_TO(dest, severity) LOG_STREAM_TO_S(dest, ::android::base::severity)
#define LOG_STREAM_TO_S(dest, severity) \
::android::base::LogMessage(__FILE__, __LINE__, \
::android::base::dest, \
severity, -1).stream()
// Logs a message to logcat on Android otherwise to stderr. If the severity is
// FATAL it also causes an abort. For example:
//
// LOG(FATAL) << "We didn't expect to reach here";
#define LOG(severity) LOG_TO(DEFAULT, severity)
#define LOG(severity) LOG_S(::android::base::severity)
#define LOG_S(severity) LOG_TO_S(DEFAULT, severity)
// Logs a message to logcat with the specified log ID on Android otherwise to
// stderr. If the severity is FATAL it also causes an abort.
@ -132,24 +156,25 @@ class ErrnoRestorer {
// else statement after LOG() macro, it won't bind to the if statement in the macro.
// do-while(0) statement doesn't work here. Because we need to support << operator
// following the macro, like "LOG(DEBUG) << xxx;".
#define LOG_TO(dest, severity) \
UNLIKELY(::android::base::severity >= ::android::base::GetMinimumLogSeverity()) && \
::android::base::ErrnoRestorer() && \
::android::base::LogMessage(__FILE__, __LINE__, \
::android::base::dest, \
::android::base::severity, -1).stream()
#define LOG_TO(dest, severity) LOG_TO_S(dest, ::android::base::severity)
#define LOG_TO_S(dest, severity) \
WOULD_LOG_SEVERITY(severity) && \
::android::base::ErrnoRestorer() && \
LOG_STREAM_TO_S(dest, severity) \
// A variant of LOG that also logs the current errno value. To be used when
// library calls fail.
#define PLOG(severity) PLOG_TO(DEFAULT, severity)
#define PLOG(severity) PLOG_S(::android::base::severity)
#define PLOG_S(severity) PLOG_TO_S(DEFAULT, severity)
// Behaves like PLOG, but logs to the specified log ID.
#define PLOG_TO(dest, severity) \
UNLIKELY(::android::base::severity >= ::android::base::GetMinimumLogSeverity()) && \
::android::base::ErrnoRestorer() && \
::android::base::LogMessage(__FILE__, __LINE__, \
::android::base::dest, \
::android::base::severity, errno).stream()
#define PLOG_TO(dest, severity) PLOG_TO_S(dest, ::android::base::severity)
#define PLOG_TO_S(dest, severity) \
WOULD_LOG_SEVERITY(severity) && \
::android::base::ErrnoRestorer() && \
::android::base::LogMessage(__FILE__, __LINE__, \
::android::base::dest, \
severity, errno).stream()
// Marker that code is yet to be implemented.
#define UNIMPLEMENTED(level) \

440
base/logging_test.cpp
View File

@ -142,6 +142,151 @@ TEST(logging, DCHECK) {
// we don't get more bit-rot).
}
#define CHECK_WOULD_LOG_DISABLED(severity) \
static_assert(android::base::severity < android::base::FATAL, "Bad input"); \
for (size_t i = static_cast<size_t>(android::base::severity) + 1; \
i <= static_cast<size_t>(android::base::FATAL); \
++i) { \
android::base::ScopedLogSeverity sls2(static_cast<android::base::LogSeverity>(i)); \
EXPECT_FALSE(WOULD_LOG(severity)) << i; \
}
#define CHECK_WOULD_LOG_ENABLED(severity) \
for (size_t i = static_cast<size_t>(android::base::VERBOSE); \
i <= static_cast<size_t>(android::base::severity); \
++i) { \
android::base::ScopedLogSeverity sls2(static_cast<android::base::LogSeverity>(i)); \
EXPECT_TRUE(WOULD_LOG(severity)) << i; \
}
TEST(logging, WOULD_LOG_FATAL) {
CHECK_WOULD_LOG_ENABLED(FATAL);
}
TEST(logging, WOULD_LOG_FATAL_WITHOUT_ABORT_disabled) {
CHECK_WOULD_LOG_DISABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, WOULD_LOG_FATAL_WITHOUT_ABORT_enabled) {
CHECK_WOULD_LOG_ENABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, WOULD_LOG_ERROR_disabled) {
CHECK_WOULD_LOG_DISABLED(ERROR);
}
TEST(logging, WOULD_LOG_ERROR_enabled) {
CHECK_WOULD_LOG_ENABLED(ERROR);
}
TEST(logging, WOULD_LOG_WARNING_disabled) {
CHECK_WOULD_LOG_DISABLED(WARNING);
}
TEST(logging, WOULD_LOG_WARNING_enabled) {
CHECK_WOULD_LOG_ENABLED(WARNING);
}
TEST(logging, WOULD_LOG_INFO_disabled) {
CHECK_WOULD_LOG_DISABLED(INFO);
}
TEST(logging, WOULD_LOG_INFO_enabled) {
CHECK_WOULD_LOG_ENABLED(INFO);
}
TEST(logging, WOULD_LOG_DEBUG_disabled) {
CHECK_WOULD_LOG_DISABLED(DEBUG);
}
TEST(logging, WOULD_LOG_DEBUG_enabled) {
CHECK_WOULD_LOG_ENABLED(DEBUG);
}
TEST(logging, WOULD_LOG_VERBOSE_disabled) {
CHECK_WOULD_LOG_DISABLED(VERBOSE);
}
TEST(logging, WOULD_LOG_VERBOSE_enabled) {
CHECK_WOULD_LOG_ENABLED(VERBOSE);
}
#undef CHECK_WOULD_LOG_DISABLED
#undef CHECK_WOULD_LOG_ENABLED
#define CHECK_WOULD_LOG_SEVERITY_DISABLED(severity) \
static_assert(android::base::severity < android::base::FATAL, "Bad input"); \
for (size_t i = static_cast<size_t>(android::base::severity) + 1; \
i <= static_cast<size_t>(android::base::FATAL); \
++i) { \
android::base::ScopedLogSeverity sls2(static_cast<android::base::LogSeverity>(i)); \
EXPECT_FALSE(WOULD_LOG_SEVERITY(::android::base::severity)) << i; \
}
#define CHECK_WOULD_LOG_SEVERITY_ENABLED(severity) \
for (size_t i = static_cast<size_t>(android::base::VERBOSE); \
i <= static_cast<size_t>(android::base::severity); \
++i) { \
android::base::ScopedLogSeverity sls2(static_cast<android::base::LogSeverity>(i)); \
EXPECT_TRUE(WOULD_LOG_SEVERITY(::android::base::severity)) << i; \
}
TEST(logging,WOULD_LOG_SEVERITY_FATAL) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(FATAL);
}
TEST(logging,WOULD_LOG_SEVERITY_FATAL_WITHOUT_ABORT_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, WOULD_LOG_SEVERITY_FATAL_WITHOUT_ABORT_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, WOULD_LOG_SEVERITY_ERROR_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(ERROR);
}
TEST(logging, WOULD_LOG_SEVERITY_ERROR_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(ERROR);
}
TEST(logging, WOULD_LOG_SEVERITY_WARNING_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(WARNING);
}
TEST(logging, WOULD_LOG_SEVERITY_WARNING_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(WARNING);
}
TEST(logging, WOULD_LOG_SEVERITY_INFO_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(INFO);
}
TEST(logging, WOULD_LOG_SEVERITY_INFO_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(INFO);
}
TEST(logging, WOULD_LOG_SEVERITY_DEBUG_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(DEBUG);
}
TEST(logging, WOULD_LOG_SEVERITY_DEBUG_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(DEBUG);
}
TEST(logging, WOULD_LOG_SEVERITYVERBOSE_disabled) {
CHECK_WOULD_LOG_SEVERITY_DISABLED(VERBOSE);
}
TEST(logging, WOULD_LOG_SEVERITY_VERBOSE_enabled) {
CHECK_WOULD_LOG_SEVERITY_ENABLED(VERBOSE);
}
#undef CHECK_WOULD_LOG_SEVERITY_DISABLED
#undef CHECK_WOULD_LOG_SEVERITY_ENABLED
static std::string make_log_pattern(android::base::LogSeverity severity,
const char* message) {
static const char log_characters[] = "VDIWEFF";
@ -154,18 +299,6 @@ static std::string make_log_pattern(android::base::LogSeverity severity,
log_char, basename(&holder[0]), message);
}
#define CHECK_LOG_DISABLED(severity) \
android::base::ScopedLogSeverity sls1(android::base::FATAL); \
CapturedStderr cap1; \
LOG(severity) << "foo bar"; \
ASSERT_EQ(0, lseek(cap1.fd(), 0, SEEK_CUR)); \
#define CHECK_LOG_ENABLED(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
LOG(severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar"); \
static void CheckMessage(const CapturedStderr& cap,
android::base::LogSeverity severity, const char* expected) {
std::string output;
@ -184,6 +317,83 @@ static void CheckMessage(const CapturedStderr& cap,
#endif
}
#define CHECK_LOG_STREAM(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
LOG_STREAM(severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar"); \
TEST(logging, LOG_STREAM_FATAL_WITHOUT_ABORT) {
CHECK_LOG_STREAM(FATAL_WITHOUT_ABORT);
}
TEST(logging, LOG_STREAM_ERROR) {
CHECK_LOG_STREAM(ERROR);
}
TEST(logging, LOG_STREAM_WARNING) {
CHECK_LOG_STREAM(WARNING);
}
TEST(logging, LOG_STREAM_INFO) {
CHECK_LOG_STREAM(INFO);
}
TEST(logging, LOG_STREAM_DEBUG) {
CHECK_LOG_STREAM(DEBUG);
}
TEST(logging, LOG_STREAM_VERBOSE) {
CHECK_LOG_STREAM(VERBOSE);
}
#undef CHECK_LOG_STREAM
#define CHECK_LOG_STREAM_S(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
LOG_STREAM_S(android::base::severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar"); \
TEST(logging, LOG_STREAM_S_FATAL_WITHOUT_ABORT) {
CHECK_LOG_STREAM_S(FATAL_WITHOUT_ABORT);
}
TEST(logging, LOG_STREAM_S_ERROR) {
CHECK_LOG_STREAM_S(ERROR);
}
TEST(logging, LOG_STREAM_S_WARNING) {
CHECK_LOG_STREAM_S(WARNING);
}
TEST(logging, LOG_STREAM_S_INFO) {
CHECK_LOG_STREAM_S(INFO);
}
TEST(logging, LOG_STREAM_S_DEBUG) {
CHECK_LOG_STREAM_S(DEBUG);
}
TEST(logging, LOG_STREAM_S_VERBOSE) {
CHECK_LOG_STREAM_S(VERBOSE);
}
#undef CHECK_LOG_STREAM_S
#define CHECK_LOG_DISABLED(severity) \
android::base::ScopedLogSeverity sls1(android::base::FATAL); \
CapturedStderr cap1; \
LOG(severity) << "foo bar"; \
ASSERT_EQ(0, lseek(cap1.fd(), 0, SEEK_CUR)); \
#define CHECK_LOG_ENABLED(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
LOG(severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar"); \
TEST(logging, LOG_FATAL) {
ASSERT_DEATH({SuppressAbortUI(); LOG(FATAL) << "foobar";}, "foobar");
}
@ -236,6 +446,102 @@ TEST(logging, LOG_VERBOSE_enabled) {
CHECK_LOG_ENABLED(VERBOSE);
}
#undef CHECK_LOG_DISABLED
#undef CHECK_LOG_ENABLED
#define CHECK_LOG_S_DISABLED(severity) \
android::base::ScopedLogSeverity sls1(android::base::FATAL); \
CapturedStderr cap1; \
LOG_S(::android::base::severity) << "foo bar"; \
ASSERT_EQ(0, lseek(cap1.fd(), 0, SEEK_CUR)); \
#define CHECK_LOG_S_ENABLED(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
LOG_S(::android::base::severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar"); \
TEST(logging, LOG_S_FATAL) {
ASSERT_DEATH({SuppressAbortUI(); LOG_S(::android::base::FATAL) << "foobar";}, "foobar");
}
TEST(logging, LOG_S_FATAL_WITHOUT_ABORT_disabled) {
CHECK_LOG_S_DISABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, LOG_S_FATAL_WITHOUT_ABORT_enabled) {
CHECK_LOG_S_ENABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, LOG_S_ERROR_disabled) {
CHECK_LOG_S_DISABLED(ERROR);
}
TEST(logging, LOG_S_ERROR_enabled) {
CHECK_LOG_S_ENABLED(ERROR);
}
TEST(logging, LOG_S_WARNING_disabled) {
CHECK_LOG_S_DISABLED(WARNING);
}
TEST(logging, LOG_S_WARNING_enabled) {
CHECK_LOG_S_ENABLED(WARNING);
}
TEST(logging, LOG_S_INFO_disabled) {
CHECK_LOG_S_DISABLED(INFO);
}
TEST(logging, LOG_S_INFO_enabled) {
CHECK_LOG_S_ENABLED(INFO);
}
TEST(logging, LOG_S_DEBUG_disabled) {
CHECK_LOG_S_DISABLED(DEBUG);
}
TEST(logging, LOG_S_DEBUG_enabled) {
CHECK_LOG_S_ENABLED(DEBUG);
}
TEST(logging, LOG_S_VERBOSE_disabled) {
CHECK_LOG_S_DISABLED(VERBOSE);
}
TEST(logging, LOG_S_VERBOSE_enabled) {
CHECK_LOG_S_ENABLED(VERBOSE);
}
#undef CHECK_LOG_S_DISABLED
#undef CHECK_LOG_S_ENABLED
TEST(logging, LOG_S_complex_param) {
#define CHECK_LOG_S_COMBINATION(use_scoped_log_severity_info, use_logging_severity_info) \
{ \
android::base::ScopedLogSeverity sls( \
(use_scoped_log_severity_info) ? ::android::base::INFO : ::android::base::WARNING); \
CapturedStderr cap; \
LOG_S((use_logging_severity_info) ? ::android::base::INFO : ::android::base::WARNING) \
<< "foobar"; \
if ((use_scoped_log_severity_info) || !(use_logging_severity_info)) { \
CheckMessage(cap, \
(use_logging_severity_info) ? ::android::base::INFO : ::android::base::WARNING, \
"foobar"); \
} else { \
ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_CUR)); \
} \
}
CHECK_LOG_S_COMBINATION(false,false);
CHECK_LOG_S_COMBINATION(false,true);
CHECK_LOG_S_COMBINATION(true,false);
CHECK_LOG_S_COMBINATION(true,true);
#undef CHECK_LOG_S_COMBINATION
}
TEST(logging, LOG_does_not_clobber_errno) {
CapturedStderr cap;
errno = 12345;
@ -245,6 +551,15 @@ TEST(logging, LOG_does_not_clobber_errno) {
CheckMessage(cap, android::base::INFO, "67890");
}
TEST(logging, LOG_S_does_not_clobber_errno) {
CapturedStderr cap;
errno = 12345;
LOG_S(::android::base::INFO) << (errno = 67890);
EXPECT_EQ(12345, errno) << "errno was not restored";
CheckMessage(cap, android::base::INFO, "67890");
}
TEST(logging, PLOG_does_not_clobber_errno) {
CapturedStderr cap;
errno = 12345;
@ -254,6 +569,16 @@ TEST(logging, PLOG_does_not_clobber_errno) {
CheckMessage(cap, android::base::INFO, "67890");
}
TEST(logging, PLOG_S_does_not_clobber_errno) {
CapturedStderr cap;
errno = 12345;
PLOG_S(::android::base::INFO) << (errno = 67890);
EXPECT_EQ(12345, errno) << "errno was not restored";
CheckMessage(cap, android::base::INFO, "67890");
}
TEST(logging, LOG_does_not_have_dangling_if) {
CapturedStderr cap; // So the logging below has no side-effects.
@ -275,9 +600,23 @@ TEST(logging, LOG_does_not_have_dangling_if) {
flag = true;
EXPECT_FALSE(flag) << "LOG macro probably has a dangling if with no else";
}
#define CHECK_PLOG(severity) \
flag = false;
if (true)
LOG_S(::android::base::INFO) << "foobar";
else
flag = true;
EXPECT_FALSE(flag) << "LOG_S macro probably has a dangling if with no else";
flag = false;
if (true)
LOG_S(::android::base::VERBOSE) << "foobar";
else
flag = true;
EXPECT_FALSE(flag) << "LOG_S macro probably has a dangling if with no else";
}
#define CHECK_PLOG_DISABLED(severity) \
android::base::ScopedLogSeverity sls1(android::base::FATAL); \
@ -344,6 +683,79 @@ TEST(logging, PLOG_VERBOSE_enabled) {
CHECK_PLOG_ENABLED(VERBOSE);
}
#undef CHECK_PLOG_DISABLED
#undef CHECK_PLOG_ENABLED
#define CHECK_PLOG_S_DISABLED(severity) \
android::base::ScopedLogSeverity sls1(android::base::FATAL); \
CapturedStderr cap1; \
PLOG_S(android::base::severity) << "foo bar"; \
ASSERT_EQ(0, lseek(cap1.fd(), 0, SEEK_CUR)); \
#define CHECK_PLOG_S_ENABLED(severity) \
android::base::ScopedLogSeverity sls2(android::base::severity); \
CapturedStderr cap2; \
errno = ENOENT; \
PLOG_S(android::base::severity) << "foobar"; \
CheckMessage(cap2, android::base::severity, "foobar: No such file or directory"); \
TEST(logging, PLOG_S_FATAL) {
ASSERT_DEATH({SuppressAbortUI(); PLOG_S(::android::base::FATAL) << "foobar";}, "foobar");
}
TEST(logging, PLOG_S_FATAL_WITHOUT_ABORT_disabled) {
CHECK_PLOG_S_DISABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, PLOG_S_FATAL_WITHOUT_ABORT_enabled) {
CHECK_PLOG_S_ENABLED(FATAL_WITHOUT_ABORT);
}
TEST(logging, PLOG_S_ERROR_disabled) {
CHECK_PLOG_S_DISABLED(ERROR);
}
TEST(logging, PLOG_S_ERROR_enabled) {
CHECK_PLOG_S_ENABLED(ERROR);
}
TEST(logging, PLOG_S_WARNING_disabled) {
CHECK_PLOG_S_DISABLED(WARNING);
}
TEST(logging, PLOG_S_WARNING_enabled) {
CHECK_PLOG_S_ENABLED(WARNING);
}
TEST(logging, PLOG_S_INFO_disabled) {
CHECK_PLOG_S_DISABLED(INFO);
}
TEST(logging, PLOG_S_INFO_enabled) {
CHECK_PLOG_S_ENABLED(INFO);
}
TEST(logging, PLOG_S_DEBUG_disabled) {
CHECK_PLOG_S_DISABLED(DEBUG);
}
TEST(logging, PLOG_S_DEBUG_enabled) {
CHECK_PLOG_S_ENABLED(DEBUG);
}
TEST(logging, PLOG_S_VERBOSE_disabled) {
CHECK_PLOG_S_DISABLED(VERBOSE);
}
TEST(logging, PLOG_S_VERBOSE_enabled) {
CHECK_PLOG_S_ENABLED(VERBOSE);
}
#undef CHECK_PLOG_S_DISABLED
#undef CHECK_PLOG_S_ENABLED
TEST(logging, UNIMPLEMENTED) {
std::string expected = android::base::StringPrintf("%s unimplemented ", __PRETTY_FUNCTION__);