Merge "Base: Add more log macros" am: 58af713d8a (4939e193) · Commits · e / os / android_system_core

base/include/android-base/logging.h

+39 −14

Original line number	Original line	Diff line number	Diff line
	@@ -120,11 +120,35 @@ class ErrnoRestorer {
	DISALLOW_COPY_AND_ASSIGN(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		// Logs a message to logcat on Android otherwise to stderr. If the severity is
	// FATAL it also causes an abort. For example:		// FATAL it also causes an abort. For example:
	//		//
	// LOG(FATAL) << "We didn't expect to reach here";		// 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		// 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.		// 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.		// 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		// do-while(0) statement doesn't work here. Because we need to support << operator
	// following the macro, like "LOG(DEBUG) << xxx;".		// following the macro, like "LOG(DEBUG) << xxx;".
	#define LOG_TO(dest, severity) \		#define LOG_TO(dest, severity) LOG_TO_S(dest, ::android::base::severity)
	UNLIKELY(::android::base::severity >= ::android::base::GetMinimumLogSeverity()) && \		#define LOG_TO_S(dest, severity) \
			WOULD_LOG_SEVERITY(severity) && \
	::android::base::ErrnoRestorer() && \		::android::base::ErrnoRestorer() && \
	::android::base::LogMessage(__FILE__, __LINE__, \		LOG_STREAM_TO_S(dest, severity) \
	::android::base::dest, \
	::android::base::severity, -1).stream()

	// A variant of LOG that also logs the current errno value. To be used when		// A variant of LOG that also logs the current errno value. To be used when
	// library calls fail.		// 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.		// Behaves like PLOG, but logs to the specified log ID.
	#define PLOG_TO(dest, severity) \		#define PLOG_TO(dest, severity) PLOG_TO_S(dest, ::android::base::severity)
	UNLIKELY(::android::base::severity >= ::android::base::GetMinimumLogSeverity()) && \		#define PLOG_TO_S(dest, severity) \
			WOULD_LOG_SEVERITY(severity) && \
	::android::base::ErrnoRestorer() && \		::android::base::ErrnoRestorer() && \
	::android::base::LogMessage(__FILE__, __LINE__, \		::android::base::LogMessage(__FILE__, __LINE__, \
	::android::base::dest, \		::android::base::dest, \
	::android::base::severity, errno).stream()		severity, errno).stream()

	// Marker that code is yet to be implemented.		// Marker that code is yet to be implemented.
	#define UNIMPLEMENTED(level) \		#define UNIMPLEMENTED(level) \

base/logging_test.cpp

+426 −14

Original line number	Original line	Diff line number	Diff line
	@@ -142,6 +142,151 @@ TEST(logging, DCHECK) {
	// we don't get more bit-rot).		// 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,		static std::string make_log_pattern(android::base::LogSeverity severity,
	const char* message) {		const char* message) {
	static const char log_characters[] = "VDIWEFF";		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);		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,		static void CheckMessage(const CapturedStderr& cap,
	android::base::LogSeverity severity, const char* expected) {		android::base::LogSeverity severity, const char* expected) {
	std::string output;		std::string output;
	@@ -184,6 +317,83 @@ static void CheckMessage(const CapturedStderr& cap,
	#endif		#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) {		TEST(logging, LOG_FATAL) {
	ASSERT_DEATH({SuppressAbortUI(); LOG(FATAL) << "foobar";}, "foobar");		ASSERT_DEATH({SuppressAbortUI(); LOG(FATAL) << "foobar";}, "foobar");
	}		}
	@@ -236,6 +446,102 @@ TEST(logging, LOG_VERBOSE_enabled) {
	CHECK_LOG_ENABLED(VERBOSE);		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) {		TEST(logging, LOG_does_not_clobber_errno) {
	CapturedStderr cap;		CapturedStderr cap;
	errno = 12345;		errno = 12345;
	@@ -245,6 +551,15 @@ TEST(logging, LOG_does_not_clobber_errno) {
	CheckMessage(cap, android::base::INFO, "67890");		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) {		TEST(logging, PLOG_does_not_clobber_errno) {
	CapturedStderr cap;		CapturedStderr cap;
	errno = 12345;		errno = 12345;
	@@ -254,6 +569,16 @@ TEST(logging, PLOG_does_not_clobber_errno) {
	CheckMessage(cap, android::base::INFO, "67890");		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) {		TEST(logging, LOG_does_not_have_dangling_if) {
	CapturedStderr cap; // So the logging below has no side-effects.		CapturedStderr cap; // So the logging below has no side-effects.

	@@ -275,9 +600,23 @@ TEST(logging, LOG_does_not_have_dangling_if) {
	flag = true;		flag = true;

	EXPECT_FALSE(flag) << "LOG macro probably has a dangling if with no else";		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) \		#define CHECK_PLOG_DISABLED(severity) \
	android::base::ScopedLogSeverity sls1(android::base::FATAL); \		android::base::ScopedLogSeverity sls1(android::base::FATAL); \
	@@ -344,6 +683,79 @@ TEST(logging, PLOG_VERBOSE_enabled) {
	CHECK_PLOG_ENABLED(VERBOSE);		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) {		TEST(logging, UNIMPLEMENTED) {
	std::string expected = android::base::StringPrintf("%s unimplemented ", __PRETTY_FUNCTION__);		std::string expected = android::base::StringPrintf("%s unimplemented ", __PRETTY_FUNCTION__);