Make Mojo's LoggingTest.LogIf resilient to MSVC's unreachable code warning

mojo/public/cpp/environment/tests/logging_unittest.cc

 // Copyright 2014 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 <stdlib.h>
 
 #include <sstream>
 #include <string>
 
 #include "mojo/public/cpp/environment/environment.h"
@@ skipping 27 matching lines @@
   virtual ~LoggingTest() {}
 
  protected:
   // Note: Does not reset |minimum_log_level_|.
   static void ResetMockLogger() {
     log_message_was_called_ = false;
     last_log_level_ = MOJO_LOG_LEVEL_INFO;
     last_message_.clear();
   }
 
+  // A function returning |bool| that shouldn't be called.
+  static bool NotCalledCondition() {
+    not_called_condition_was_called_ = true;
+    return false;
+  }
+
   static bool log_message_was_called() { return log_message_was_called_; }
   static MojoLogLevel last_log_level() { return last_log_level_; }
   static const std::string& last_message() { return last_message_; }
+  static bool not_called_condition_was_called() {
+    return not_called_condition_was_called_;
+  }
 
  private:
   // Note: We record calls even if |log_level| is below |minimum_log_level_|
   // (since the macros should mostly avoid this, and we want to be able to check
   // that they do).
   static void MockLogMessage(MojoLogLevel log_level, const char* message) {
     log_message_was_called_ = true;
     last_log_level_ = log_level;
     last_message_ = message;
   }
 
   static MojoLogLevel MockGetMinimumLogLevel() {
     return minimum_log_level_;
   }
 
   static void MockSetMinimumLogLevel(MojoLogLevel minimum_log_level) {
     minimum_log_level_ = minimum_log_level;
   }
 
   Environment environment_;
 
   static const MojoLogger kMockLogger;
   static MojoLogLevel minimum_log_level_;
   static bool log_message_was_called_;
   static MojoLogLevel last_log_level_;
   static std::string last_message_;
+  static bool not_called_condition_was_called_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(LoggingTest);
 };
 
 // static
 const MojoLogger LoggingTest::kMockLogger = {
   &LoggingTest::MockLogMessage,
   &LoggingTest::MockGetMinimumLogLevel,
   &LoggingTest::MockSetMinimumLogLevel
 };
 
 // static
 MojoLogLevel LoggingTest::minimum_log_level_ = MOJO_LOG_LEVEL_INFO;
 
 // static
 bool LoggingTest::log_message_was_called_ = MOJO_LOG_LEVEL_INFO;
 
 // static
 MojoLogLevel LoggingTest::last_log_level_ = MOJO_LOG_LEVEL_INFO;
 
 // static
 std::string LoggingTest::last_message_;
 
+// static
+bool LoggingTest::not_called_condition_was_called_ = false;
+
 std::string ExpectedLogMessage(int line, const char* message) {
   std::ostringstream s;
   s << OUR_FILENAME "(" << line << "): " << message;
   return s.str();
 }
 
-// A function returning |bool| that shouldn't be called.
-bool NotCalled() {
-  abort();
-  // I think all compilers are smart enough to recognize that nothing is run
-  // after |abort()|. (Some definitely complain that things after it are
-  // unreachable.)
-}
-
 TEST_F(LoggingTest, InternalLogMessage) {
   internal::LogMessage("foo.cc", 123, MOJO_LOG_LEVEL_INFO).stream()
       << "hello " << "world";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
   EXPECT_EQ("foo.cc(123): hello world", last_message());
 
   ResetMockLogger();
 
   internal::LogMessage("./path/to/foo.cc", 123, MOJO_LOG_LEVEL_WARNING).stream()
@@ skipping 205 matching lines @@
 
   ResetMockLogger();
 
   MOJO_LOG_IF(FATAL, 1 * 2 == 3) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   // |MOJO_LOG_IF()| shouldn't evaluate its condition if the level is below the
   // minimum.
-  MOJO_LOG_IF(INFO, NotCalled()) << "hello";
+  MOJO_LOG_IF(INFO, NotCalledCondition()) << "hello";
+  EXPECT_FALSE(not_called_condition_was_called());
   EXPECT_FALSE(log_message_was_called());
 }
 
 TEST_F(LoggingTest, Check) {
   MOJO_CHECK(true) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   PtrToMemberHelper helper;
@@ skipping 31 matching lines @@
 #else
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
   EXPECT_EQ(ExpectedLogMessage(__LINE__ - 6, "hello"), last_message());
 #endif
 }
 
 TEST_F(LoggingTest, DlogIf) {
   // We start at |MOJO_LOG_LEVEL_INFO|. It shouldn't evaluate the condition in
   // this case.
-  MOJO_DLOG_IF(VERBOSE, NotCalled()) << "hello";
+  MOJO_DLOG_IF(VERBOSE, NotCalledCondition()) << "hello";
+  EXPECT_FALSE(not_called_condition_was_called());
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_DLOG_IF(INFO, 1 == 0) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_DLOG_IF(INFO, 1 == 1) << "hello";
@@ skipping 56 matching lines @@
   ResetMockLogger();
 
   // Also try to make sure that we parenthesize the condition properly.
   bool x = true;
   MOJO_DCHECK(false || x) << "hello";
   EXPECT_FALSE(log_message_was_called());
 }
 
 }  // namespace
 }  // namespace mojo