Make CHECK int 3 on Windows, rather than crash

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/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/rand_util.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include <excpt.h>
+#endif  // OS_WIN
+
 namespace logging {
 
 namespace {
 
 using ::testing::Return;
 
 // Needs to be global since log assert handlers can't maintain state.
 int log_sink_call_count = 0;
 
 #if !defined(OFFICIAL_BUILD) || defined(DCHECK_ALWAYS_ON) || !defined(NDEBUG)
@@ skipping 161 matching lines @@
   CHECK(mock_log_source.Log()) << uncalled_mock_log_source.Log();
   PCHECK(!mock_log_source.Log()) << mock_log_source.Log();
   CHECK_EQ(mock_log_source.Log(), mock_log_source.Log())
       << uncalled_mock_log_source.Log();
   CHECK_NE(mock_log_source.Log(), mock_log_source.Log())
       << mock_log_source.Log();
 }
 
 #endif
 
+#if defined(OFFICIAL_BUILD) && defined(OS_WIN)
+__declspec(noinline) void CheckContainingFunc(uint64_t x, uint64_t y, int z) {

[Will Harris, 2017/02/02 01:21:06]

not sure here (base owner might know) but I think convention here is to use
NOINLINE rather than __declspec(noinline)

[scottmg, 2017/02/02 01:41:23]

Done.

+  if (z == 1)
+    CHECK(!x);
+  if (z == 2)
+    CHECK(!y);
+  if (z == 3)
+    CHECK(false);
+}
+
+int GetCheckExceptionData(EXCEPTION_POINTERS* p, DWORD* code, void** addr) {
+  *code = p->ExceptionRecord->ExceptionCode;
+  *addr = p->ExceptionRecord->ExceptionAddress;
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+TEST_F(LoggingTest, CheckCausesDistinctBreakpoints) {
+  uint64_t x = base::RandUint64();

[Will Harris, 2017/02/02 01:21:06]

this can return 0, so the test can fail with a very very low likelyhood...

[scottmg, 2017/02/02 01:41:24]

Meh. Done.

+  uint64_t y = base::RandUint64();
+  DWORD code1 = 0;
+  DWORD code2 = 0;
+  DWORD code3 = 0;
+  void* addr1 = nullptr;
+  void* addr2 = nullptr;
+  void* addr3 = nullptr;
+
+  // Record the exception code and addresses.
+  __try {
+    CheckContainingFunc(x, y, 1);
+  } __except (
+      GetCheckExceptionData(GetExceptionInformation(), &code1, &addr1)) {
+  }
+
+  __try {
+    CheckContainingFunc(x, y, 2);
+  } __except (
+      GetCheckExceptionData(GetExceptionInformation(), &code2, &addr2)) {
+  }
+
+  __try {
+    CheckContainingFunc(x, y, 3);
+  } __except (
+      GetCheckExceptionData(GetExceptionInformation(), &code3, &addr3)) {
+  }
+
+  // Ensure that the exception codes are correct (in particular, breakpoints,
+  // not access violations).
+  EXPECT_EQ(STATUS_BREAKPOINT, code1);
+  EXPECT_EQ(STATUS_BREAKPOINT, code2);
+  EXPECT_EQ(STATUS_BREAKPOINT, code3);
+
+  // Ensure that none of the CHECKs are colocated.
+  EXPECT_NE(addr1, addr2);
+  EXPECT_NE(addr1, addr3);
+  EXPECT_NE(addr2, addr3);
+}
+#endif  // OFFICIAL_BUILD && OS_WIN
+
 TEST_F(LoggingTest, DebugLoggingReleaseBehavior) {
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   int debug_only_variable = 1;
 #endif
   // These should avoid emitting references to |debug_only_variable|
   // in release mode.
   DLOG_IF(INFO, debug_only_variable) << "test";
   DLOG_ASSERT(debug_only_variable) << "test";
   DPLOG_IF(INFO, debug_only_variable) << "test";
   DVLOG_IF(1, debug_only_variable) << "test";
@@ skipping 138 matching lines @@
     std::wstring wstr = L"Hello World";
     std::ostringstream ostr;
     ostr << wstr;
     EXPECT_EQ("Hello World", ostr.str());
   }
 }  // namespace nested_test
 
 }  // namespace
 
 }  // namespace logging