Make CHECK_EQ and friends work properly in an if/else structure without braces.

base/logging_unittest.cc

 // Copyright (c) 2011 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/compiler_specific.h"
 #include "base/logging.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 24 matching lines @@
     SetLogAssertHandler(NULL);
     log_sink_call_count = 0;
   }
 
  private:
   int old_min_log_level_;
 
   DISALLOW_COPY_AND_ASSIGN(LogStateSaver);
 };
 
+// Validates that exactly N log messages are received during its lifetime.
+template <int N>
+class ExpectNLogs {
+ public:
+  ExpectNLogs() {
+    SetLogAssertHandler(&LogSink);
+    log_sink_call_count = 0;
+  }
+
+  ~ExpectNLogs() {
+    SetLogAssertHandler(NULL);
+    EXPECT_EQ(N, log_sink_call_count);
+  }
+
+ private:
+  LogStateSaver log_state_saver_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExpectNLogs);
+};
+
+using ExpectNoLogs = ExpectNLogs<0>;
+using ExpectOneLog = ExpectNLogs<1>;
+using ExpectOneLogIfDCheckIsOn = ExpectNLogs<DCHECK_IS_ON() ? 1 : 0>;
+
+// A convenience function to aid in test readability.
+bool UnreachedBoolExpr() {
+  ADD_FAILURE() << "Unexpectedly evaluated.";
+  return false;
+}
+
+// Validates that operator()() is invoked exactly N times.
+template<int N>
+class EvaluatedNTimes {
+  public:
+   EvaluatedNTimes() {}
+   ~EvaluatedNTimes() {
+     EXPECT_EQ(N, evaluations_) << "Expected to be evaluated exactly " << N
+                                << " times.";
+   }
+
+   bool operator()() {
+     EXPECT_GT(N, evaluations_) << "Evaluated more than the expected " << N
+                                << " times.";
+     ++evaluations_;
+     return true;
+   };
+
+  private:
+   int evaluations_ = 0;
+   DISALLOW_COPY_AND_ASSIGN(EvaluatedNTimes);
+};
+
+using EvaluatedOnce = EvaluatedNTimes<1>;
+using EvaluatedOnceIfDCheckIsOn = EvaluatedNTimes<DCHECK_IS_ON() ? 1 : 0>;
+
 class LoggingTest : public testing::Test {
  private:
   LogStateSaver log_state_saver_;
 };
 
 class MockLogSource {
  public:
   MOCK_METHOD0(Log, const char*());
 };
 
@@ skipping 172 matching lines @@
 
 TEST_F(LoggingTest, DcheckReleaseBehavior) {
   int some_variable = 1;
   // These should still reference |some_variable| so we don't get
   // unused variable warnings.
   DCHECK(some_variable) << "test";
   DPCHECK(some_variable) << "test";
   DCHECK_EQ(some_variable, 1) << "test";
 }
 
+// Test that DCHECK acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, DCheckStatements) {
+  // The next three blocks validate that the DCHECK is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached DCHECK.
+    if (false)
+      DCHECK(UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;

[Sigurður Ásgeirsson, 2015/07/16 10:51:28]

nit: IMHO the use of this would be marginally more readable if this were named
eval_once or some such. No biggie.

+    ExpectNoLogs expect_no_logs;
+
+    // Reached, successful DCHECK.
+    if (true)
+      DCHECK(bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Reached, failed DCHECK.
+    if (true)
+      DCHECK(!bool_expr());
+  }
+
+  // The following four cases validate that the DCHECK is correctly bound in an
+  // 'if/else' statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, successful else.
+    if (false)
+      DCHECK(UnreachedBoolExpr());
+    else
+      DCHECK(bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Successful if, unreached else.
+    if (true)
+      DCHECK(bool_expr());
+    else
+      DCHECK(UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Unreached if, failed else.
+    if (false)
+      DCHECK(UnreachedBoolExpr());
+    else
+      DCHECK(!bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Failed if, unreached else.
+    if (true)
+      DCHECK(!bool_expr());
+    else
+      DCHECK(UnreachedBoolExpr());
+  }
+
+  // These cases validate that a DCHECK may appear in a switch statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        DCHECK(UnreachedBoolExpr());
+      case 2:
+        DCHECK(bool_expr());
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+    switch (2) {
+      case 1:
+        DCHECK(UnreachedBoolExpr());
+      case 2:
+        DCHECK(!bool_expr());
+      default:
+        break;
+    }
+  }
+}
+
+// Test that CHECK acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, CheckStatements) {
+  // The next three blocks validate that the CHECK is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached CHECK.
+    if (false)
+      CHECK(UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Reached, successful CHECK.
+    if (true)
+      CHECK(bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Reached, failed CHECK.
+    if (true)
+      CHECK(!bool_expr());
+  }
+
+  // The following four cases validate that the CHECK is correctly bound in an
+  // 'if/else' statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, successful else.
+    if (false)
+      CHECK(UnreachedBoolExpr());
+    else
+      CHECK(bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Successful if, unreached else.
+    if (true)
+      CHECK(bool_expr());
+    else
+      CHECK(UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Unreached if, failed else.
+    if (false)
+      CHECK(UnreachedBoolExpr());
+    else
+      CHECK(!bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Failed if, unreached else.
+    if (true)
+      CHECK(!bool_expr());
+    else
+      CHECK(UnreachedBoolExpr());
+  }
+
+  // These cases validate that a CHECK may appear in a switch statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        CHECK(UnreachedBoolExpr());
+      case 2:
+        CHECK(bool_expr());
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+    switch (2) {
+      case 1:
+        CHECK(UnreachedBoolExpr());
+      case 2:
+        CHECK(!bool_expr());
+      default:
+        break;
+    }
+  }
+}
+
+// Test that DCHECK_EQ acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, DCheckEqStatements) {
+  // The next three blocks validate that the DCHECK_EQ is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached DCHECK_EQ.
+    if (false)
+      DCHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Reached, successful DCHECK_EQ.
+    if (true)
+      DCHECK_EQ(true, bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Reached, failed DCHECK_EQ.
+    if (true)
+      DCHECK_EQ(false, bool_expr());
+  }
+
+  // The following four cases validate that the DCHECK_EQ is correctly bound in
+  // an 'if/else' statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, successful else.
+    if (false)
+      DCHECK_EQ(false, UnreachedBoolExpr());
+    else
+      DCHECK_EQ(true, bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Successful if, unreached else.
+    if (true)
+      DCHECK_EQ(true, bool_expr());
+    else
+      DCHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Unreached if, failed else.
+    if (false)
+      DCHECK_EQ(false, UnreachedBoolExpr());
+    else
+      DCHECK_EQ(false, bool_expr());
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Failed if, unreached else.
+    if (true)
+      DCHECK_EQ(false, bool_expr());
+    else
+      DCHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  // These cases validate that a DCHECK_EQ may appear in a switch statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        DCHECK_EQ(false, UnreachedBoolExpr());
+      case 2:
+        DCHECK_EQ(true, bool_expr());
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+    switch (2) {
+      case 1:
+        DCHECK_EQ(false, UnreachedBoolExpr());
+      case 2:
+        DCHECK_EQ(false, bool_expr());
+      default:
+        break;
+    }
+  }
+}
+
+// Test that CHECK_EQ acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, CheckEqStatements) {
+  // The next three blocks validate that the CHECK_EQ is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached CHECK_EQ.
+    if (false)
+      CHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Reached, successful CHECK_EQ.
+    if (true)
+      CHECK_EQ(true, bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Reached, failed CHECK_EQ.
+    if (true)
+      CHECK_EQ(false, bool_expr());
+  }
+
+  // The following four cases validate that the CHECK_EQ is correctly bound in
+  // an 'if/else' statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, successful else.
+    if (false)
+      CHECK_EQ(false, UnreachedBoolExpr());
+    else
+      CHECK_EQ(true, bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Successful if, unreached else.
+    if (true)
+      CHECK_EQ(true, bool_expr());
+    else
+      CHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Unreached if, failed else.
+    if (false)
+      CHECK_EQ(false, UnreachedBoolExpr());
+    else
+      CHECK_EQ(false, bool_expr());
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Failed if, unreached else.
+    if (true)
+      CHECK_EQ(false, bool_expr());
+    else
+      CHECK_EQ(false, UnreachedBoolExpr());
+  }
+
+  // These cases validate that a CHECK_EQ may appear in a switch statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        CHECK_EQ(false, UnreachedBoolExpr());
+      case 2:
+        CHECK_EQ(true, bool_expr());
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+    switch (2) {
+      case 1:
+        CHECK_EQ(false, UnreachedBoolExpr());
+      case 2:
+        CHECK_EQ(false, bool_expr());
+      default:
+        break;
+    }
+  }
+}
+
+// Test that DLOG_IF acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, DLogIfStatements) {
+  // The next three blocks validate that the DLOG_IF is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached DLOG_IF.
+    if (false)
+      DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Reached, negative DLOG_IF.
+    if (true)
+      DLOG_IF(FATAL, !bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Reached, positive DLOG_IF.
+    if (true)
+      DLOG_IF(FATAL, bool_expr()) << "message";
+  }
+
+  // The following four cases validate that the DLOG_IF is correctly bound in an
+  // 'if/else' statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, negative else.
+    if (false)
+      DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+    else
+      DLOG_IF(FATAL, !bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Negative if, unreached else.
+    if (true)
+      DLOG_IF(FATAL, !bool_expr()) << "message";
+    else
+      DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Unreached if, positive else.
+    if (false)
+      DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+    else
+      DLOG_IF(FATAL, bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+
+    // Positive if, unreached else.
+    if (true)
+      DLOG_IF(FATAL, bool_expr()) << "message";
+    else
+      DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  // These cases validate that a DLOG_IF may appear in a switch statement.
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+      case 2:
+        DLOG_IF(FATAL, !bool_expr()) << "message";
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnceIfDCheckIsOn bool_expr;
+    ExpectOneLogIfDCheckIsOn expect_one_dlog;
+    switch (2) {
+      case 1:
+        DLOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+      case 2:
+        DLOG_IF(FATAL, bool_expr()) << "message";
+      default:
+        break;
+    }
+  }
+}
+
+// Test that LOG_IF acts as a single statement in variety of syntactic
+// situations.
+TEST_F(LoggingTest, LogIfStatements) {
+  // The next three blocks validate that the LOG_IF is correctly bound to the
+  // 'if' statement.
+  {
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached LOG_IF.
+    if (false)
+      LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Reached, negative LOG_IF.
+    if (true)
+      LOG_IF(FATAL, !bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Reached, positive LOG_IF.
+    if (true)
+      LOG_IF(FATAL, bool_expr()) << "message";
+  }
+
+  // The following four cases validate that the LOG_IF is correctly bound in an
+  // 'if/else' statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Unreached if, negative else.
+    if (false)
+      LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+    else
+      LOG_IF(FATAL, !bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+
+    // Negative if, unreached else.
+    if (true)
+      LOG_IF(FATAL, !bool_expr()) << "message";
+    else
+      LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Unreached if, positive else.
+    if (false)
+      LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+    else
+      LOG_IF(FATAL, bool_expr()) << "message";
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+
+    // Positive if, unreached else.
+    if (true)
+      LOG_IF(FATAL, bool_expr()) << "message";
+    else
+      LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+  }
+
+  // These cases validate that a LOG_IF may appear in a switch statement.
+  {
+    EvaluatedOnce bool_expr;
+    ExpectNoLogs expect_no_logs;
+    switch (2) {
+      case 1:
+        LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+      case 2:
+        LOG_IF(FATAL, !bool_expr()) << "message";
+      default:
+        break;
+    }
+  }
+
+  {
+    EvaluatedOnce bool_expr;
+    ExpectOneLog expect_one_log;
+    switch (2) {
+      case 1:
+        LOG_IF(FATAL, UnreachedBoolExpr()) << "message";
+      case 2:
+        LOG_IF(FATAL, bool_expr()) << "message";
+      default:
+        break;
+    }
+  }
+}
+
 // Test that defining an operator<< for a type in a namespace doesn't prevent
 // other code in that namespace from calling the operator<<(ostream, wstring)
 // defined by logging.h. This can fail if operator<<(ostream, wstring) can't be
 // found by ADL, since defining another operator<< prevents name lookup from
 // looking in the global namespace.
 namespace nested_test {
   class Streamable {};
   ALLOW_UNUSED_TYPE std::ostream& operator<<(std::ostream& out,
                                              const Streamable&) {
     return out << "Streamable";
   }
   TEST_F(LoggingTest, StreamingWstringFindsCorrectOperator) {
     std::wstring wstr = L"Hello World";
     std::ostringstream ostr;
     ostr << wstr;
     EXPECT_EQ("Hello World", ostr.str());
   }
 }  // namespace nested_test
 
 }  // namespace
 
 }  // namespace logging