Fixes for re-enabling more MSVC level 4 warnings: mojo/ edition

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"
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // A macro, so it can be automatically joined with other string literals. (Not
 // simply __FILE__, since that may contain a path.)
 #define OUR_FILENAME "logging_unittest.cc"
 
 namespace mojo {
 namespace {
 
+class PtrToMemberHelper {
+ public:
+  int member;
+};
+
 class LoggingTest : public testing::Test {
  public:
   LoggingTest() : environment_(NULL, &kMockLogger) {
     minimum_log_level_ = MOJO_LOG_LEVEL_INFO;
     ResetMockLogger();
   }
   virtual ~LoggingTest() {}
 
  protected:
   // Note: Does not reset |minimum_log_level_|.
@@ skipping 130 matching lines @@
       << "hello " << "world";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
   EXPECT_EQ(OUR_FILENAME "(123): hello world", last_message());
 }
 
 TEST_F(LoggingTest, LogStream) {
   MOJO_LOG_STREAM(INFO) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 
   ResetMockLogger();
 
   MOJO_LOG_STREAM(ERROR) << "hi " << 123;
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_ERROR, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hi 123"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hi 123"), last_message());
 }
 
 TEST_F(LoggingTest, LazyLogStream) {
   MOJO_LAZY_LOG_STREAM(INFO, true) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 
   ResetMockLogger();
 
   MOJO_LAZY_LOG_STREAM(ERROR, true) << "hi " << 123;
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_ERROR, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hi 123"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hi 123"), last_message());
 
   ResetMockLogger();
 
   MOJO_LAZY_LOG_STREAM(INFO, false) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_LAZY_LOG_STREAM(FATAL, false) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
-  bool x = false;
+  PtrToMemberHelper helper;
+  helper.member = 1;
+  int PtrToMemberHelper::*member_ptr = &PtrToMemberHelper::member;
+
   // This probably fails to compile if we forget to parenthesize the condition
-  // in the macro (= has low precedence, and needs an lvalue on the LHS).
-  MOJO_LAZY_LOG_STREAM(ERROR, x = true) << "hello";
+  // in the macro (.* has lower precedence than !, which can't apply to
+  // |helper|).
+  MOJO_LAZY_LOG_STREAM(ERROR, helper.*member_ptr == 1) << "hello";
   EXPECT_TRUE(log_message_was_called());
 
   ResetMockLogger();
 
-  MOJO_LAZY_LOG_STREAM(WARNING, x = false) << "hello";
+  MOJO_LAZY_LOG_STREAM(WARNING, helper.*member_ptr == 0) << "hello";
   EXPECT_FALSE(log_message_was_called());
 }
 
 TEST_F(LoggingTest, ShouldLog) {
   // We start at |MOJO_LOG_LEVEL_INFO|.
   EXPECT_FALSE(MOJO_SHOULD_LOG(VERBOSE));
   EXPECT_TRUE(MOJO_SHOULD_LOG(INFO));
   EXPECT_TRUE(MOJO_SHOULD_LOG(WARNING));
   EXPECT_TRUE(MOJO_SHOULD_LOG(ERROR));
   EXPECT_TRUE(MOJO_SHOULD_LOG(FATAL));
@@ skipping 16 matching lines @@
 TEST_F(LoggingTest, Log) {
   // We start at |MOJO_LOG_LEVEL_INFO|.
   MOJO_LOG(VERBOSE) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_LOG(INFO) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 
   ResetMockLogger();
 
   MOJO_LOG(ERROR) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_ERROR, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 
   ResetMockLogger();
 
   Environment::GetDefaultLogger()->SetMinimumLogLevel(MOJO_LOG_LEVEL_ERROR);
 
   MOJO_LOG(VERBOSE) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_LOG(INFO) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_LOG(ERROR) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_ERROR, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 }
 
 TEST_F(LoggingTest, LogIf) {
   // We start at |MOJO_LOG_LEVEL_INFO|.
   MOJO_LOG_IF(VERBOSE, true) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_LOG_IF(VERBOSE, false) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
+  Environment::GetDefaultLogger()->SetMinimumLogLevel(MOJO_LOG_LEVEL_ERROR);
 
-  bool x = false;
+  bool x = true;
   // Also try to make sure that we parenthesize the condition properly.
-  MOJO_LOG_IF(INFO, x = true) << "hello";
-  EXPECT_TRUE(log_message_was_called());
-  EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
-
-  ResetMockLogger();
-
-  MOJO_LOG_IF(INFO, x = false) << "hello";
+  MOJO_LOG_IF(INFO, false || x) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
-  Environment::GetDefaultLogger()->SetMinimumLogLevel(MOJO_LOG_LEVEL_ERROR);
-
-  ResetMockLogger();
-
   MOJO_LOG_IF(INFO, 0 != 1) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
-  MOJO_LOG_IF(WARNING, 1+1 == 2) << "hello";
+  MOJO_LOG_IF(WARNING, 1 + 1 == 2) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
-  MOJO_LOG_IF(ERROR, 1*2 == 2) << "hello";
+  MOJO_LOG_IF(ERROR, 1 * 2 == 2) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_ERROR, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-3, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 3, "hello"), last_message());
 
   ResetMockLogger();
 
-  MOJO_LOG_IF(FATAL, 1*2 == 3) << "hello";
+  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";
   EXPECT_FALSE(log_message_was_called());
 }
 
 TEST_F(LoggingTest, Check) {
   MOJO_CHECK(true) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
-  bool x = true;
+  PtrToMemberHelper helper;
+  helper.member = 0;
+  int PtrToMemberHelper::*member_ptr = &PtrToMemberHelper::member;
+
   // Also try to make sure that we parenthesize the condition properly.
-  MOJO_CHECK(x = false) << "hello";
+  MOJO_CHECK(helper.*member_ptr == 1) << "hello";
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_FATAL, last_log_level());
   // Different compilers have different ideas about the line number of a split
   // line.
   int line = __LINE__;
-  EXPECT_EQ(ExpectedLogMessage(line-5, "Check failed: x = false. hello"),
+  EXPECT_EQ(ExpectedLogMessage(line - 5,
+                               "Check failed: helper.*member_ptr == 1. hello"),
             last_message());
 
   ResetMockLogger();
 
   // Also test a "naked" |MOJO_CHECK()|s.
-  MOJO_CHECK(1+2 == 3);
+  MOJO_CHECK(1 + 2 == 3);
   EXPECT_FALSE(log_message_was_called());
 }
 
 TEST_F(LoggingTest, Dlog) {
   // We start at |MOJO_LOG_LEVEL_INFO|.
   MOJO_DLOG(VERBOSE) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_DLOG(INFO) << "hello";
 #ifdef NDEBUG
   EXPECT_FALSE(log_message_was_called());
 #else
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-6, "hello"), last_message());
+  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";
   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";
 #ifdef NDEBUG
   EXPECT_FALSE(log_message_was_called());
 #else
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_INFO, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-6, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 6, "hello"), last_message());
 #endif
 
   ResetMockLogger();
 
   // |MOJO_DLOG_IF()| shouldn't compile its condition for non-debug builds.
 #ifndef NDEBUG
   bool debug_only = true;
 #endif
   MOJO_DLOG_IF(WARNING, debug_only) << "hello";
 #ifdef NDEBUG
   EXPECT_FALSE(log_message_was_called());
 #else
   EXPECT_TRUE(log_message_was_called());
   EXPECT_EQ(MOJO_LOG_LEVEL_WARNING, last_log_level());
-  EXPECT_EQ(ExpectedLogMessage(__LINE__-6, "hello"), last_message());
+  EXPECT_EQ(ExpectedLogMessage(__LINE__ - 6, "hello"), last_message());
 #endif
 }
 
 TEST_F(LoggingTest, Dcheck) {
   MOJO_DCHECK(true);
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   MOJO_DCHECK(true) << "hello";
   EXPECT_FALSE(log_message_was_called());
 
   ResetMockLogger();
 
   // |MOJO_DCHECK()| should compile (but not evaluate) its condition even for

[viettrungluu, 2014/07/08 23:16:04]

So for this, it's intentionally divergent between debug and non-debug builds. I
somehow managed to forget the EXPECT_TRUE(x); in the NDEBUG case and the
EXPECT_FALSE(x); in the !NDEBUG case. :/

For release builds, you want to know that what's inside is not evaluated
(whereas for debug builds it is evaluated).

You could do this cleanly with something like:

bool DcheckTestHelper(bool* was_called) {
  *was_called = true;
  return false;
}

...

  bool was_called = false;
  MOJO_DCHECK(DcheckTestHelper(&was_called)) << "hello";
  ...

[Peter Kasting, 2014/07/08 23:59:54]

Done.

   // non-debug builds. (Hopefully, we'll get an unused variable error if it
   // fails to compile the condition.)
+  // Also try to make sure that we parenthesize the condition properly.
   bool x = true;
-  MOJO_DCHECK(x = false) << "hello";
-#ifdef NDEBUG
+  MOJO_DCHECK(false || x) << "hello";
   EXPECT_FALSE(log_message_was_called());
-#else
-  EXPECT_TRUE(log_message_was_called());
-  EXPECT_EQ(MOJO_LOG_LEVEL_FATAL, last_log_level());
-  // Different compilers have different ideas about the line number of a split
-  // line.
-  int line = __LINE__;
-  EXPECT_EQ(ExpectedLogMessage(line-8, "Check failed: x = false. hello"),
-            last_message());
-#endif
 }
 
 }  // namespace
 }  // namespace mojo