Base: Add more log macros
Add WOULD_LOG to determine whether a given severity would be logged.
Add LOG_STREAM to have direct access to a logging stream.
Add LOG_S variants that take a fully qualified severity. This allows
complex expressions as parameters, e.g., ternaries for conditional
severity levels.
Add tests.
Bug: 31338270
Test: m
Test: mmma system/core/base && $ANDROID_HOST_OUT/nativetest64/libbase_test/libbase_test64
Change-Id: I242b960594e68caff6db9cd8aaa4ce8aaf90474c
diff --git a/base/logging_test.cpp b/base/logging_test.cpp
index 8813525..a1ed05b 100644
--- a/base/logging_test.cpp
+++ b/base/logging_test.cpp
@@ -142,6 +142,151 @@
// 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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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__);