base/check_unittest.cc - chromium/src - Git at Google

 // Copyright (c) 2020 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 <tuple>

 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/test/gtest_util.h"
 #include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {

 // Helper class which expects a check to fire with a certain location and
 // message before the end of the current scope.
 class ScopedCheckExpectation {
  public:
   ScopedCheckExpectation(const char* file, int line, std::string msg)
       : file_(file),
         line_(line),
         msg_(msg),
         assert_handler_(base::BindRepeating(&ScopedCheckExpectation::Check,
                                             base::Unretained(this))),
         fired_(false) {}
   ~ScopedCheckExpectation() {
     EXPECT_TRUE(fired_) << "CHECK at " << file_ << ":" << line_
                         << " never fired!";
   }

  private:
   void Check(const char* file,
              int line,
              const base::StringPiece msg,
              const base::StringPiece stack) {
     fired_ = true;
     EXPECT_EQ(file, file_);
     EXPECT_EQ(line, line_);
     if (msg_.find("=~") == 0) {
       EXPECT_THAT(std::string(msg), testing::MatchesRegex(msg_.substr(2)));
     } else {
       EXPECT_EQ(std::string(msg), msg_);
     }
   }

   std::string file_;
   int line_;
   std::string msg_;
   logging::ScopedLogAssertHandler assert_handler_;
   bool fired_;
 };

 // Macro which expects a CHECK to fire with a certain message. If msg starts
 // with "=~", it's interpreted as a regular expression.
 // Example: EXPECT_CHECK("Check failed: false.", CHECK(false));
 #if defined(OFFICIAL_BUILD) && defined(NDEBUG)
 #define EXPECT_CHECK(msg, check_expr) \
   do {                                \
     EXPECT_CHECK_DEATH(check_expr);   \
   } while (0)
 #else
 #define EXPECT_CHECK(msg, check_expr)                          \
   do {                                                         \
     ScopedCheckExpectation check_exp(__FILE__, __LINE__, msg); \
     check_expr;                                                \
   } while (0)
 #endif

 // Macro which expects a DCHECK to fire if DCHECKs are enabled.
 #define EXPECT_DCHECK(msg, check_expr)                                         \
   do {                                                                         \
     if (DCHECK_IS_ON() && logging::LOGGING_DCHECK == logging::LOGGING_FATAL) { \
       ScopedCheckExpectation check_exp(__FILE__, __LINE__, msg);               \
       check_expr;                                                              \
     } else {                                                                   \
       check_expr;                                                              \
     }                                                                          \
   } while (0)

 class CheckTest : public testing::Test {};

 TEST_F(CheckTest, Basics) {
   EXPECT_CHECK("Check failed: false. ", CHECK(false));

   EXPECT_CHECK("Check failed: false. foo", CHECK(false) << "foo");

   double a = 2, b = 1;
   EXPECT_CHECK("Check failed: a < b (2.000000 vs. 1.000000)", CHECK_LT(a, b));

   EXPECT_CHECK("Check failed: a < b (2.000000 vs. 1.000000)foo",
                CHECK_LT(a, b) << "foo");
 }

 TEST_F(CheckTest, PCheck) {
   const char file[] = "/nonexistentfile123";
   std::ignore = fopen(file, "r");
   std::string err =
       logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());

   EXPECT_CHECK(
       "Check failed: fopen(file, \"r\") != nullptr."
       " : " +
           err,
       PCHECK(fopen(file, "r") != nullptr));

   EXPECT_CHECK(
       "Check failed: fopen(file, \"r\") != nullptr."
       " foo: " +
           err,
       PCHECK(fopen(file, "r") != nullptr) << "foo");

   EXPECT_DCHECK(
       "Check failed: fopen(file, \"r\") != nullptr."
       " : " +
           err,
       DPCHECK(fopen(file, "r") != nullptr));

   EXPECT_DCHECK(
       "Check failed: fopen(file, \"r\") != nullptr."
       " foo: " +
           err,
       DPCHECK(fopen(file, "r") != nullptr) << "foo");
 }

 TEST_F(CheckTest, CheckOp) {
   int a = 1, b = 2;
   // clang-format off
   EXPECT_CHECK("Check failed: a == b (1 vs. 2)", CHECK_EQ(a, b));
   EXPECT_CHECK("Check failed: a != a (1 vs. 1)", CHECK_NE(a, a));
   EXPECT_CHECK("Check failed: b <= a (2 vs. 1)", CHECK_LE(b, a));
   EXPECT_CHECK("Check failed: b < a (2 vs. 1)",  CHECK_LT(b, a));
   EXPECT_CHECK("Check failed: a >= b (1 vs. 2)", CHECK_GE(a, b));
   EXPECT_CHECK("Check failed: a > b (1 vs. 2)",  CHECK_GT(a, b));

   EXPECT_DCHECK("Check failed: a == b (1 vs. 2)", DCHECK_EQ(a, b));
   EXPECT_DCHECK("Check failed: a != a (1 vs. 1)", DCHECK_NE(a, a));
   EXPECT_DCHECK("Check failed: b <= a (2 vs. 1)", DCHECK_LE(b, a));
   EXPECT_DCHECK("Check failed: b < a (2 vs. 1)",  DCHECK_LT(b, a));
   EXPECT_DCHECK("Check failed: a >= b (1 vs. 2)", DCHECK_GE(a, b));
   EXPECT_DCHECK("Check failed: a > b (1 vs. 2)",  DCHECK_GT(a, b));
   // clang-format on
 }

 TEST_F(CheckTest, CheckStreamsAreLazy) {
   int called_count = 0;
   int not_called_count = 0;

   auto Called = [&]() {
     ++called_count;
     return 42;
   };
   auto NotCalled = [&]() {
     ++not_called_count;
     return 42;
   };

   CHECK(Called()) << NotCalled();
   CHECK_EQ(Called(), Called()) << NotCalled();
   PCHECK(Called()) << NotCalled();

   DCHECK(Called()) << NotCalled();
   DCHECK_EQ(Called(), Called()) << NotCalled();
   DPCHECK(Called()) << NotCalled();

   EXPECT_EQ(not_called_count, 0);
 #if DCHECK_IS_ON()
   EXPECT_EQ(called_count, 8);
 #else
   EXPECT_EQ(called_count, 4);
 #endif
 }

 void DcheckEmptyFunction1() {
   // Provide a body so that Release builds do not cause the compiler to
   // optimize DcheckEmptyFunction1 and DcheckEmptyFunction2 as a single
   // function, which breaks the Dcheck tests below.
   LOG(INFO) << "DcheckEmptyFunction1";
 }
 void DcheckEmptyFunction2() {}

 #if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
 class ScopedDcheckSeverity {
  public:
   ScopedDcheckSeverity(logging::LogSeverity new_severity)
       : old_severity_(logging::LOGGING_DCHECK) {
     logging::LOGGING_DCHECK = new_severity;
   }

   ~ScopedDcheckSeverity() { logging::LOGGING_DCHECK = old_severity_; }

  private:
   logging::LogSeverity old_severity_;
 };
 #endif  // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

 // https://crbug.com/709067 tracks test flakiness on iOS.
 #if BUILDFLAG(IS_IOS)
 #define MAYBE_Dcheck DISABLED_Dcheck
 #else
 #define MAYBE_Dcheck Dcheck
 #endif
 TEST_F(CheckTest, MAYBE_Dcheck) {
 #if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
   // DCHECKs are enabled, and LOGGING_DCHECK is mutable, but defaults to
   // non-fatal. Set it to LOGGING_FATAL to get the expected behavior from the
   // rest of this test.
   ScopedDcheckSeverity dcheck_severity(logging::LOGGING_FATAL);
 #endif  // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
   // Release build.
   EXPECT_FALSE(DCHECK_IS_ON());
   EXPECT_FALSE(DLOG_IS_ON(DCHECK));
 #elif defined(NDEBUG) && defined(DCHECK_ALWAYS_ON)
   // Release build with real DCHECKS.
   EXPECT_TRUE(DCHECK_IS_ON());
   EXPECT_TRUE(DLOG_IS_ON(DCHECK));
 #else
   // Debug build.
   EXPECT_TRUE(DCHECK_IS_ON());
   EXPECT_TRUE(DLOG_IS_ON(DCHECK));
 #endif

   EXPECT_DCHECK("Check failed: false. ", DCHECK(false));
   std::string err =
       logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());
   EXPECT_DCHECK("Check failed: false. : " + err, DPCHECK(false));
   EXPECT_DCHECK("Check failed: 0 == 1 (0 vs. 1)", DCHECK_EQ(0, 1));

   // Test DCHECK on std::nullptr_t
   const void* p_null = nullptr;
   const void* p_not_null = &p_null;
   DCHECK_EQ(p_null, nullptr);
   DCHECK_EQ(nullptr, p_null);
   DCHECK_NE(p_not_null, nullptr);
   DCHECK_NE(nullptr, p_not_null);

   // Test DCHECK on a scoped enum.
   enum class Animal { DOG, CAT };
   DCHECK_EQ(Animal::DOG, Animal::DOG);
   EXPECT_DCHECK("Check failed: Animal::DOG == Animal::CAT (0 vs. 1)",
                 DCHECK_EQ(Animal::DOG, Animal::CAT));

   // Test DCHECK on functions and function pointers.
   struct MemberFunctions {
     void MemberFunction1() {
       // See the comment in DcheckEmptyFunction1().
       LOG(INFO) << "Do not merge with MemberFunction2.";
     }
     void MemberFunction2() {}
   };
   void (MemberFunctions::*mp1)() = &MemberFunctions::MemberFunction1;
   void (MemberFunctions::*mp2)() = &MemberFunctions::MemberFunction2;
   void (*fp1)() = DcheckEmptyFunction1;
   void (*fp2)() = DcheckEmptyFunction2;
   void (*fp3)() = DcheckEmptyFunction1;
   DCHECK_EQ(fp1, fp3);
   DCHECK_EQ(mp1, &MemberFunctions::MemberFunction1);
   DCHECK_EQ(mp2, &MemberFunctions::MemberFunction2);
   EXPECT_DCHECK("=~Check failed: fp1 == fp2 \\(\\w+ vs. \\w+\\)",
                 DCHECK_EQ(fp1, fp2));
   EXPECT_DCHECK(
       "Check failed: mp2 == &MemberFunctions::MemberFunction1 (1 vs. 1)",
       DCHECK_EQ(mp2, &MemberFunctions::MemberFunction1));
 }

 TEST_F(CheckTest, DcheckReleaseBehavior) {
   int var1 = 1;
   int var2 = 2;
   int var3 = 3;
   int var4 = 4;

   // No warnings about unused variables even though no check fires and DCHECK
   // may or may not be enabled.
   DCHECK(var1) << var2;
   DPCHECK(var1) << var3;
   DCHECK_EQ(var1, 1) << var4;
 }

 TEST_F(CheckTest, DCheckEqStatements) {
   bool reached = false;
   if (false)
     DCHECK_EQ(false, true);  // Unreached.
   else
     DCHECK_EQ(true, reached = true);  // Reached, passed.
   ASSERT_EQ(DCHECK_IS_ON() ? true : false, reached);

   if (false)
     DCHECK_EQ(false, true);  // Unreached.
 }

 TEST_F(CheckTest, CheckEqStatements) {
   bool reached = false;
   if (false)
     CHECK_EQ(false, true);  // Unreached.
   else
     CHECK_EQ(true, reached = true);  // Reached, passed.
   ASSERT_TRUE(reached);

   if (false)
     CHECK_EQ(false, true);  // Unreached.
 }

 #if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
 TEST_F(CheckTest, ConfigurableDCheck) {
   // Verify that DCHECKs default to non-fatal in configurable-DCHECK builds.
   // Note that we require only that DCHECK is non-fatal by default, rather
   // than requiring that it be exactly INFO, ERROR, etc level.
   EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
   DCHECK(false);

   // Verify that DCHECK* aren't hard-wired to crash on failure.
   logging::LOGGING_DCHECK = logging::LOG_INFO;
   DCHECK(false);
   DCHECK_EQ(1, 2);

   // Verify that DCHECK does crash if LOGGING_DCHECK is set to LOGGING_FATAL.
   logging::LOGGING_DCHECK = logging::LOGGING_FATAL;
   EXPECT_CHECK("Check failed: false. ", DCHECK(false));
   EXPECT_CHECK("Check failed: 1 == 2 (1 vs. 2)", DCHECK_EQ(1, 2));
 }

 TEST_F(CheckTest, ConfigurableDCheckFeature) {
   // Initialize FeatureList with and without DcheckIsFatal, and verify the
   // value of LOGGING_DCHECK. Note that we don't require that DCHECK take a
   // specific value when the feature is off, only that it is non-fatal.

   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine("DcheckIsFatal", "");
     EXPECT_EQ(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
   }

   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine("", "DcheckIsFatal");
     EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
   }

   // The default case is last, so we leave LOGGING_DCHECK in the default state.
   {
     base::test::ScopedFeatureList feature_list;
     feature_list.InitFromCommandLine("", "");
     EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
   }
 }
 #endif  // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

 struct StructWithOstream {
   bool operator==(const StructWithOstream& o) const { return &o == this; }
 };
 #if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
 std::ostream& operator<<(std::ostream& out, const StructWithOstream&) {
   return out << "ostream";
 }
 #endif

 struct StructWithToString {
   bool operator==(const StructWithToString& o) const { return &o == this; }
   std::string ToString() const { return "ToString"; }
 };

 struct StructWithToStringAndOstream {
   bool operator==(const StructWithToStringAndOstream& o) const {
     return &o == this;
   }
   std::string ToString() const { return "ToString"; }
 };
 #if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
 std::ostream& operator<<(std::ostream& out,
                          const StructWithToStringAndOstream&) {
   return out << "ostream";
 }
 #endif

 struct StructWithToStringNotStdString {
   struct PseudoString {};

   bool operator==(const StructWithToStringNotStdString& o) const {
     return &o == this;
   }
   PseudoString ToString() const { return PseudoString(); }
 };
 #if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
 std::ostream& operator<<(std::ostream& out,
                          const StructWithToStringNotStdString::PseudoString&) {
   return out << "ToString+ostream";
 }
 #endif

 TEST_F(CheckTest, OstreamVsToString) {
   StructWithOstream a, b;
   EXPECT_CHECK("Check failed: a == b (ostream vs. ostream)", CHECK_EQ(a, b));

   StructWithToString c, d;
   EXPECT_CHECK("Check failed: c == d (ToString vs. ToString)", CHECK_EQ(c, d));

   StructWithToStringAndOstream e, f;
   EXPECT_CHECK("Check failed: e == f (ostream vs. ostream)", CHECK_EQ(e, f));

   StructWithToStringNotStdString g, h;
   EXPECT_CHECK("Check failed: g == h (ToString+ostream vs. ToString+ostream)",
                CHECK_EQ(g, h));
 }

 #define EXPECT_LOG_ERROR(expected_line, expr, msg)                             \
   do {                                                                         \
     static bool got_log_message = false;                                       \
     ASSERT_EQ(logging::GetLogMessageHandler(), nullptr);                       \
     logging::SetLogMessageHandler([](int severity, const char* file, int line, \
                                      size_t message_start,                     \
                                      const std::string& str) {                 \
       EXPECT_FALSE(got_log_message);                                           \
       got_log_message = true;                                                  \
       EXPECT_EQ(severity, logging::LOG_ERROR);                                 \
       EXPECT_EQ(str.substr(message_start), (msg));                             \
       EXPECT_STREQ(__FILE__, file);                                            \
       EXPECT_EQ(expected_line, line);                                          \
       return true;                                                             \
     });                                                                        \
     expr;                                                                      \
     EXPECT_TRUE(got_log_message);                                              \
     logging::SetLogMessageHandler(nullptr);                                    \
   } while (0)

 #define EXPECT_NO_LOG(expr)                                                    \
   do {                                                                         \
     ASSERT_EQ(logging::GetLogMessageHandler(), nullptr);                       \
     logging::SetLogMessageHandler([](int severity, const char* file, int line, \
                                      size_t message_start,                     \
                                      const std::string& str) {                 \
       EXPECT_TRUE(false) << "Unexpected log: " << str;                         \
       return true;                                                             \
     });                                                                        \
     expr;                                                                      \
     logging::SetLogMessageHandler(nullptr);                                    \
   } while (0)

 TEST_F(CheckTest, NotReached) {
 #if BUILDFLAG(ENABLE_LOG_ERROR_NOT_REACHED) && !DCHECK_IS_ON()
   // Expect LOG(ERROR) that looks like CHECK(false) with streamed params intact.
   EXPECT_LOG_ERROR(__LINE__, NOTREACHED() << "foo",
                    "Check failed: false. foo\n");
 #else
   // Expect a DCHECK with streamed params intact.
   EXPECT_DCHECK("Check failed: false. foo", NOTREACHED() << "foo");
 #endif
 }

 TEST_F(CheckTest, NotImplemented) {
   static const std::string expected_msg =
       std::string("Not implemented reached in ") + __PRETTY_FUNCTION__;

 #if DCHECK_IS_ON()
   // Expect LOG(ERROR) with streamed params intact.
   EXPECT_LOG_ERROR(__LINE__, NOTIMPLEMENTED() << "foo", expected_msg + "foo\n");
 #else
   // Expect nothing.
   EXPECT_NO_LOG(NOTIMPLEMENTED() << "foo");
 #endif
 }

 void NiLogOnce() {
   // Note: The stream param is not logged.
   NOTIMPLEMENTED_LOG_ONCE() << "foo";
 }

 TEST_F(CheckTest, NotImplementedLogOnce) {
   static const std::string expected_msg =
       "Not implemented reached in void (anonymous namespace)::NiLogOnce()\n";

 #if DCHECK_IS_ON()
   EXPECT_LOG_ERROR(__LINE__ - 8, NiLogOnce(), expected_msg);
   EXPECT_NO_LOG(NiLogOnce());
 #else
   EXPECT_NO_LOG(NiLogOnce());
   EXPECT_NO_LOG(NiLogOnce());
 #endif
 }

 }  // namespace
	// Copyright (c) 2020 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 <tuple>

	#include "base/bind.h"
	#include "base/callback.h"
	#include "base/logging.h"
	#include "base/strings/string_piece.h"
	#include "base/test/gtest_util.h"
	#include "base/test/scoped_feature_list.h"
	#include "build/build_config.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {

	// Helper class which expects a check to fire with a certain location and
	// message before the end of the current scope.
	class ScopedCheckExpectation {
	public:
	ScopedCheckExpectation(const char* file, int line, std::string msg)
	: file_(file),
	line_(line),
	msg_(msg),
	assert_handler_(base::BindRepeating(&ScopedCheckExpectation::Check,
	base::Unretained(this))),
	fired_(false) {}
	~ScopedCheckExpectation() {
	EXPECT_TRUE(fired_) << "CHECK at " << file_ << ":" << line_
	<< " never fired!";
	}

	private:
	void Check(const char* file,
	int line,
	const base::StringPiece msg,
	const base::StringPiece stack) {
	fired_ = true;
	EXPECT_EQ(file, file_);
	EXPECT_EQ(line, line_);
	if (msg_.find("=~") == 0) {
	EXPECT_THAT(std::string(msg), testing::MatchesRegex(msg_.substr(2)));
	} else {
	EXPECT_EQ(std::string(msg), msg_);
	}
	}

	std::string file_;
	int line_;
	std::string msg_;
	logging::ScopedLogAssertHandler assert_handler_;
	bool fired_;
	};

	// Macro which expects a CHECK to fire with a certain message. If msg starts
	// with "=~", it's interpreted as a regular expression.
	// Example: EXPECT_CHECK("Check failed: false.", CHECK(false));
	#if defined(OFFICIAL_BUILD) && defined(NDEBUG)
	#define EXPECT_CHECK(msg, check_expr) \
	do { \
	EXPECT_CHECK_DEATH(check_expr); \
	} while (0)
	#else
	#define EXPECT_CHECK(msg, check_expr) \
	do { \
	ScopedCheckExpectation check_exp(__FILE__, __LINE__, msg); \
	check_expr; \
	} while (0)
	#endif

	// Macro which expects a DCHECK to fire if DCHECKs are enabled.
	#define EXPECT_DCHECK(msg, check_expr) \
	do { \
	if (DCHECK_IS_ON() && logging::LOGGING_DCHECK == logging::LOGGING_FATAL) { \
	ScopedCheckExpectation check_exp(__FILE__, __LINE__, msg); \
	check_expr; \
	} else { \
	check_expr; \
	} \
	} while (0)

	class CheckTest : public testing::Test {};

	TEST_F(CheckTest, Basics) {
	EXPECT_CHECK("Check failed: false. ", CHECK(false));

	EXPECT_CHECK("Check failed: false. foo", CHECK(false) << "foo");

	double a = 2, b = 1;
	EXPECT_CHECK("Check failed: a < b (2.000000 vs. 1.000000)", CHECK_LT(a, b));

	EXPECT_CHECK("Check failed: a < b (2.000000 vs. 1.000000)foo",
	CHECK_LT(a, b) << "foo");
	}

	TEST_F(CheckTest, PCheck) {
	const char file[] = "/nonexistentfile123";
	std::ignore = fopen(file, "r");
	std::string err =
	logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());

	EXPECT_CHECK(
	"Check failed: fopen(file, \"r\") != nullptr."
	" : " +
	err,
	PCHECK(fopen(file, "r") != nullptr));

	EXPECT_CHECK(
	"Check failed: fopen(file, \"r\") != nullptr."
	" foo: " +
	err,
	PCHECK(fopen(file, "r") != nullptr) << "foo");

	EXPECT_DCHECK(
	"Check failed: fopen(file, \"r\") != nullptr."
	" : " +
	err,
	DPCHECK(fopen(file, "r") != nullptr));

	EXPECT_DCHECK(
	"Check failed: fopen(file, \"r\") != nullptr."
	" foo: " +
	err,
	DPCHECK(fopen(file, "r") != nullptr) << "foo");
	}

	TEST_F(CheckTest, CheckOp) {
	int a = 1, b = 2;
	// clang-format off
	EXPECT_CHECK("Check failed: a == b (1 vs. 2)", CHECK_EQ(a, b));
	EXPECT_CHECK("Check failed: a != a (1 vs. 1)", CHECK_NE(a, a));
	EXPECT_CHECK("Check failed: b <= a (2 vs. 1)", CHECK_LE(b, a));
	EXPECT_CHECK("Check failed: b < a (2 vs. 1)", CHECK_LT(b, a));
	EXPECT_CHECK("Check failed: a >= b (1 vs. 2)", CHECK_GE(a, b));
	EXPECT_CHECK("Check failed: a > b (1 vs. 2)", CHECK_GT(a, b));

	EXPECT_DCHECK("Check failed: a == b (1 vs. 2)", DCHECK_EQ(a, b));
	EXPECT_DCHECK("Check failed: a != a (1 vs. 1)", DCHECK_NE(a, a));
	EXPECT_DCHECK("Check failed: b <= a (2 vs. 1)", DCHECK_LE(b, a));
	EXPECT_DCHECK("Check failed: b < a (2 vs. 1)", DCHECK_LT(b, a));
	EXPECT_DCHECK("Check failed: a >= b (1 vs. 2)", DCHECK_GE(a, b));
	EXPECT_DCHECK("Check failed: a > b (1 vs. 2)", DCHECK_GT(a, b));
	// clang-format on
	}

	TEST_F(CheckTest, CheckStreamsAreLazy) {
	int called_count = 0;
	int not_called_count = 0;

	auto Called = [&]() {
	++called_count;
	return 42;
	};
	auto NotCalled = [&]() {
	++not_called_count;
	return 42;
	};

	CHECK(Called()) << NotCalled();
	CHECK_EQ(Called(), Called()) << NotCalled();
	PCHECK(Called()) << NotCalled();

	DCHECK(Called()) << NotCalled();
	DCHECK_EQ(Called(), Called()) << NotCalled();
	DPCHECK(Called()) << NotCalled();

	EXPECT_EQ(not_called_count, 0);
	#if DCHECK_IS_ON()
	EXPECT_EQ(called_count, 8);
	#else
	EXPECT_EQ(called_count, 4);
	#endif
	}

	void DcheckEmptyFunction1() {
	// Provide a body so that Release builds do not cause the compiler to
	// optimize DcheckEmptyFunction1 and DcheckEmptyFunction2 as a single
	// function, which breaks the Dcheck tests below.
	LOG(INFO) << "DcheckEmptyFunction1";
	}
	void DcheckEmptyFunction2() {}

	#if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
	class ScopedDcheckSeverity {
	public:
	ScopedDcheckSeverity(logging::LogSeverity new_severity)
	: old_severity_(logging::LOGGING_DCHECK) {
	logging::LOGGING_DCHECK = new_severity;
	}

	~ScopedDcheckSeverity() { logging::LOGGING_DCHECK = old_severity_; }

	private:
	logging::LogSeverity old_severity_;
	};
	#endif // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

	// https://crbug.com/709067 tracks test flakiness on iOS.
	#if BUILDFLAG(IS_IOS)
	#define MAYBE_Dcheck DISABLED_Dcheck
	#else
	#define MAYBE_Dcheck Dcheck
	#endif
	TEST_F(CheckTest, MAYBE_Dcheck) {
	#if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
	// DCHECKs are enabled, and LOGGING_DCHECK is mutable, but defaults to
	// non-fatal. Set it to LOGGING_FATAL to get the expected behavior from the
	// rest of this test.
	ScopedDcheckSeverity dcheck_severity(logging::LOGGING_FATAL);
	#endif // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

	#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
	// Release build.
	EXPECT_FALSE(DCHECK_IS_ON());
	EXPECT_FALSE(DLOG_IS_ON(DCHECK));
	#elif defined(NDEBUG) && defined(DCHECK_ALWAYS_ON)
	// Release build with real DCHECKS.
	EXPECT_TRUE(DCHECK_IS_ON());
	EXPECT_TRUE(DLOG_IS_ON(DCHECK));
	#else
	// Debug build.
	EXPECT_TRUE(DCHECK_IS_ON());
	EXPECT_TRUE(DLOG_IS_ON(DCHECK));
	#endif

	EXPECT_DCHECK("Check failed: false. ", DCHECK(false));
	std::string err =
	logging::SystemErrorCodeToString(logging::GetLastSystemErrorCode());
	EXPECT_DCHECK("Check failed: false. : " + err, DPCHECK(false));
	EXPECT_DCHECK("Check failed: 0 == 1 (0 vs. 1)", DCHECK_EQ(0, 1));

	// Test DCHECK on std::nullptr_t
	const void* p_null = nullptr;
	const void* p_not_null = &p_null;
	DCHECK_EQ(p_null, nullptr);
	DCHECK_EQ(nullptr, p_null);
	DCHECK_NE(p_not_null, nullptr);
	DCHECK_NE(nullptr, p_not_null);

	// Test DCHECK on a scoped enum.
	enum class Animal { DOG, CAT };
	DCHECK_EQ(Animal::DOG, Animal::DOG);
	EXPECT_DCHECK("Check failed: Animal::DOG == Animal::CAT (0 vs. 1)",
	DCHECK_EQ(Animal::DOG, Animal::CAT));

	// Test DCHECK on functions and function pointers.
	struct MemberFunctions {
	void MemberFunction1() {
	// See the comment in DcheckEmptyFunction1().
	LOG(INFO) << "Do not merge with MemberFunction2.";
	}
	void MemberFunction2() {}
	};
	void (MemberFunctions::*mp1)() = &MemberFunctions::MemberFunction1;
	void (MemberFunctions::*mp2)() = &MemberFunctions::MemberFunction2;
	void (*fp1)() = DcheckEmptyFunction1;
	void (*fp2)() = DcheckEmptyFunction2;
	void (*fp3)() = DcheckEmptyFunction1;
	DCHECK_EQ(fp1, fp3);
	DCHECK_EQ(mp1, &MemberFunctions::MemberFunction1);
	DCHECK_EQ(mp2, &MemberFunctions::MemberFunction2);
	EXPECT_DCHECK("=~Check failed: fp1 == fp2 \\(\\w+ vs. \\w+\\)",
	DCHECK_EQ(fp1, fp2));
	EXPECT_DCHECK(
	"Check failed: mp2 == &MemberFunctions::MemberFunction1 (1 vs. 1)",
	DCHECK_EQ(mp2, &MemberFunctions::MemberFunction1));
	}

	TEST_F(CheckTest, DcheckReleaseBehavior) {
	int var1 = 1;
	int var2 = 2;
	int var3 = 3;
	int var4 = 4;

	// No warnings about unused variables even though no check fires and DCHECK
	// may or may not be enabled.
	DCHECK(var1) << var2;
	DPCHECK(var1) << var3;
	DCHECK_EQ(var1, 1) << var4;
	}

	TEST_F(CheckTest, DCheckEqStatements) {
	bool reached = false;
	if (false)
	DCHECK_EQ(false, true); // Unreached.
	else
	DCHECK_EQ(true, reached = true); // Reached, passed.
	ASSERT_EQ(DCHECK_IS_ON() ? true : false, reached);

	if (false)
	DCHECK_EQ(false, true); // Unreached.
	}

	TEST_F(CheckTest, CheckEqStatements) {
	bool reached = false;
	if (false)
	CHECK_EQ(false, true); // Unreached.
	else
	CHECK_EQ(true, reached = true); // Reached, passed.
	ASSERT_TRUE(reached);

	if (false)
	CHECK_EQ(false, true); // Unreached.
	}

	#if BUILDFLAG(DCHECK_IS_CONFIGURABLE)
	TEST_F(CheckTest, ConfigurableDCheck) {
	// Verify that DCHECKs default to non-fatal in configurable-DCHECK builds.
	// Note that we require only that DCHECK is non-fatal by default, rather
	// than requiring that it be exactly INFO, ERROR, etc level.
	EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
	DCHECK(false);

	// Verify that DCHECK* aren't hard-wired to crash on failure.
	logging::LOGGING_DCHECK = logging::LOG_INFO;
	DCHECK(false);
	DCHECK_EQ(1, 2);

	// Verify that DCHECK does crash if LOGGING_DCHECK is set to LOGGING_FATAL.
	logging::LOGGING_DCHECK = logging::LOGGING_FATAL;
	EXPECT_CHECK("Check failed: false. ", DCHECK(false));
	EXPECT_CHECK("Check failed: 1 == 2 (1 vs. 2)", DCHECK_EQ(1, 2));
	}

	TEST_F(CheckTest, ConfigurableDCheckFeature) {
	// Initialize FeatureList with and without DcheckIsFatal, and verify the
	// value of LOGGING_DCHECK. Note that we don't require that DCHECK take a
	// specific value when the feature is off, only that it is non-fatal.

	{
	base::test::ScopedFeatureList feature_list;
	feature_list.InitFromCommandLine("DcheckIsFatal", "");
	EXPECT_EQ(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
	}

	{
	base::test::ScopedFeatureList feature_list;
	feature_list.InitFromCommandLine("", "DcheckIsFatal");
	EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
	}

	// The default case is last, so we leave LOGGING_DCHECK in the default state.
	{
	base::test::ScopedFeatureList feature_list;
	feature_list.InitFromCommandLine("", "");
	EXPECT_LT(logging::LOGGING_DCHECK, logging::LOGGING_FATAL);
	}
	}
	#endif // BUILDFLAG(DCHECK_IS_CONFIGURABLE)

	struct StructWithOstream {
	bool operator==(const StructWithOstream& o) const { return &o == this; }
	};
	#if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
	std::ostream& operator<<(std::ostream& out, const StructWithOstream&) {
	return out << "ostream";
	}
	#endif

	struct StructWithToString {
	bool operator==(const StructWithToString& o) const { return &o == this; }
	std::string ToString() const { return "ToString"; }
	};

	struct StructWithToStringAndOstream {
	bool operator==(const StructWithToStringAndOstream& o) const {
	return &o == this;
	}
	std::string ToString() const { return "ToString"; }
	};
	#if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
	std::ostream& operator<<(std::ostream& out,
	const StructWithToStringAndOstream&) {
	return out << "ostream";
	}
	#endif

	struct StructWithToStringNotStdString {
	struct PseudoString {};

	bool operator==(const StructWithToStringNotStdString& o) const {
	return &o == this;
	}
	PseudoString ToString() const { return PseudoString(); }
	};
	#if !(defined(OFFICIAL_BUILD) && defined(NDEBUG))
	std::ostream& operator<<(std::ostream& out,
	const StructWithToStringNotStdString::PseudoString&) {
	return out << "ToString+ostream";
	}
	#endif

	TEST_F(CheckTest, OstreamVsToString) {
	StructWithOstream a, b;
	EXPECT_CHECK("Check failed: a == b (ostream vs. ostream)", CHECK_EQ(a, b));

	StructWithToString c, d;
	EXPECT_CHECK("Check failed: c == d (ToString vs. ToString)", CHECK_EQ(c, d));

	StructWithToStringAndOstream e, f;
	EXPECT_CHECK("Check failed: e == f (ostream vs. ostream)", CHECK_EQ(e, f));

	StructWithToStringNotStdString g, h;
	EXPECT_CHECK("Check failed: g == h (ToString+ostream vs. ToString+ostream)",
	CHECK_EQ(g, h));
	}

	#define EXPECT_LOG_ERROR(expected_line, expr, msg) \
	do { \
	static bool got_log_message = false; \
	ASSERT_EQ(logging::GetLogMessageHandler(), nullptr); \
	logging::SetLogMessageHandler([](int severity, const char* file, int line, \
	size_t message_start, \
	const std::string& str) { \
	EXPECT_FALSE(got_log_message); \
	got_log_message = true; \
	EXPECT_EQ(severity, logging::LOG_ERROR); \
	EXPECT_EQ(str.substr(message_start), (msg)); \
	EXPECT_STREQ(__FILE__, file); \
	EXPECT_EQ(expected_line, line); \
	return true; \
	}); \
	expr; \
	EXPECT_TRUE(got_log_message); \
	logging::SetLogMessageHandler(nullptr); \
	} while (0)

	#define EXPECT_NO_LOG(expr) \
	do { \
	ASSERT_EQ(logging::GetLogMessageHandler(), nullptr); \
	logging::SetLogMessageHandler([](int severity, const char* file, int line, \
	size_t message_start, \
	const std::string& str) { \
	EXPECT_TRUE(false) << "Unexpected log: " << str; \
	return true; \
	}); \
	expr; \
	logging::SetLogMessageHandler(nullptr); \
	} while (0)

	TEST_F(CheckTest, NotReached) {
	#if BUILDFLAG(ENABLE_LOG_ERROR_NOT_REACHED) && !DCHECK_IS_ON()
	// Expect LOG(ERROR) that looks like CHECK(false) with streamed params intact.
	EXPECT_LOG_ERROR(__LINE__, NOTREACHED() << "foo",
	"Check failed: false. foo\n");
	#else
	// Expect a DCHECK with streamed params intact.
	EXPECT_DCHECK("Check failed: false. foo", NOTREACHED() << "foo");
	#endif
	}

	TEST_F(CheckTest, NotImplemented) {
	static const std::string expected_msg =
	std::string("Not implemented reached in ") + __PRETTY_FUNCTION__;

	#if DCHECK_IS_ON()
	// Expect LOG(ERROR) with streamed params intact.
	EXPECT_LOG_ERROR(__LINE__, NOTIMPLEMENTED() << "foo", expected_msg + "foo\n");
	#else
	// Expect nothing.
	EXPECT_NO_LOG(NOTIMPLEMENTED() << "foo");
	#endif
	}

	void NiLogOnce() {
	// Note: The stream param is not logged.
	NOTIMPLEMENTED_LOG_ONCE() << "foo";
	}

	TEST_F(CheckTest, NotImplementedLogOnce) {
	static const std::string expected_msg =
	"Not implemented reached in void (anonymous namespace)::NiLogOnce()\n";

	#if DCHECK_IS_ON()
	EXPECT_LOG_ERROR(__LINE__ - 8, NiLogOnce(), expected_msg);
	EXPECT_NO_LOG(NiLogOnce());
	#else
	EXPECT_NO_LOG(NiLogOnce());
	EXPECT_NO_LOG(NiLogOnce());
	#endif
	}

	} // namespace