Report CHECK/DCHECK to test launcher summary output.

base/test/test_suite.cc

 // Copyright (c) 2012 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/test/test_suite.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
@@ skipping 47 matching lines @@
 #endif
 
 #if defined(OS_IOS)
 #include "base/test/test_support_ios.h"
 #endif
 
 namespace base {
 
 namespace {
 
+TestSuite* g_test_suite = nullptr;
+
 class MaybeTestDisabler : public testing::EmptyTestEventListener {
  public:
   void OnTestStart(const testing::TestInfo& test_info) override {
     ASSERT_FALSE(TestSuite::IsMarkedMaybe(test_info))
         << "Probably the OS #ifdefs don't include all of the necessary "
            "platforms.\nPlease ensure that no tests have the MAYBE_ prefix "
            "after the code is preprocessed.";
   }
 };
 
@@ skipping 73 matching lines @@
   InitializeFromCommandLine(argc, argv);
   // Logging must be initialized before any thread has a chance to call logging
   // functions.
   InitializeLogging();
 }
 #endif  // defined(OS_WIN)
 
 TestSuite::~TestSuite() {
   if (initialized_command_line_)
     CommandLine::Reset();
+
+  g_test_suite = nullptr;
 }
 
 void TestSuite::InitializeFromCommandLine(int argc, char** argv) {
   initialized_command_line_ = CommandLine::Init(argc, argv);
   testing::InitGoogleTest(&argc, argv);
   testing::InitGoogleMock(&argc, argv);
 
 #if defined(OS_IOS)
   InitIOSRunHook(this, argc, argv);
 #endif
 }
 
 #if defined(OS_WIN)
 void TestSuite::InitializeFromCommandLine(int argc, wchar_t** argv) {
   // Windows CommandLine::Init ignores argv anyway.
   initialized_command_line_ = CommandLine::Init(argc, NULL);
   testing::InitGoogleTest(&argc, argv);
   testing::InitGoogleMock(&argc, argv);
 }
 #endif  // defined(OS_WIN)
 
 void TestSuite::PreInitialize() {
+  g_test_suite = this;
 #if defined(OS_WIN)
   testing::GTEST_FLAG(catch_exceptions) = false;
 #endif
   EnableTerminationOnHeapCorruption();
 #if defined(OS_LINUX) && defined(USE_AURA)
   // When calling native char conversion functions (e.g wrctomb) we need to
   // have the locale set. In the absence of such a call the "C" locale is the
   // default. In the gtk code (below) gtk_init() implicitly sets a locale.
   setlocale(LC_ALL, "");
 #endif  // defined(OS_LINUX) && defined(USE_AURA)
@@ skipping 38 matching lines @@
 
   // Do not add the result printer if output path already exists. It's an
   // indicator there is a process printing to that file, and we're likely
   // its child. Do not clobber the results in that case.
   if (PathExists(output_path)) {
     LOG(WARNING) << "Test launcher output path " << output_path.AsUTF8Unsafe()
                  << " exists. Not adding test launcher result printer.";
     return;
   }
 
-  XmlUnitTestResultPrinter* printer = new XmlUnitTestResultPrinter;
-  CHECK(printer->Initialize(output_path));
+  printer_ = new XmlUnitTestResultPrinter;
+  CHECK(printer_->Initialize(output_path));
   testing::TestEventListeners& listeners =
       testing::UnitTest::GetInstance()->listeners();
-  listeners.Append(printer);
+  listeners.Append(printer_);
+
+  logging::SetLogMessageHandler(UnitTestLogMessageHandler);

[Paweł Hajdan Jr., 2017/01/23 16:55:06]

Is this composable with any other possibly installed log message handlers?

Should we assert on teardown that the installed log message handler at that
point is what we expect?

[alex-ac, 2017/01/27 12:55:45]

I've changed the way of setting LogAssertMessageHandler. I don't think that we
should assert about correct handler.

 }
 
 // Don't add additional code to this method.  Instead add it to
 // Initialize().  See bug 6436.
 int TestSuite::Run() {
 #if defined(OS_IOS)
   RunTestsFromIOSApp();
 #endif
 
 #if defined(OS_MACOSX)
@@ skipping 40 matching lines @@
                << test_info->name();
     fflush(stderr);
   }
 #endif  // defined(OS_ANDROID)
 
   // The logging system actually prints the message before calling the assert
   // handler. Just exit now to avoid printing too many stack traces.
   _exit(1);
 }
 
+// static
+bool TestSuite::UnitTestLogMessageHandler(int severity,
+                                          const char* file,
+                                          int line,
+                                          size_t message_start,
+                                          const std::string& str) {
+  if (severity == logging::LOG_FATAL && g_test_suite &&
+      g_test_suite->printer_) {
+    std::string message = str.substr(message_start);
+    std::string summary;
+
+    size_t marker_pos = message.find(logging::kStackTraceMarker);
+    if (marker_pos == std::string::npos) {
+      summary = message;
+    } else {
+      summary = message.substr(0, marker_pos);
+    }
+    g_test_suite->printer_->OnAssert(file, line, summary, message);

[Paweł Hajdan Jr., 2017/01/23 16:55:06]

This entire thing seems hacky. We use globals, and then do some text scraping.

What's the intended goal of this CL? Are there better alternatives, such as
creating logging handler API that would allow the callback to go to specific
object's method instead of a static method?

[alex-ac, 2017/01/27 12:55:45]

I've changed logging handler API to use base::Callback. There are no globals and
text scraping now.

+  }
+  return false;
+}
+
 void TestSuite::SuppressErrorDialogs() {
 #if defined(OS_WIN)
   UINT new_flags = SEM_FAILCRITICALERRORS |
                    SEM_NOGPFAULTERRORBOX |
                    SEM_NOOPENFILEERRORBOX;
 
   // Preserve existing error mode, as discussed at
   // http://blogs.msdn.com/oldnewthing/archive/2004/07/27/198410.aspx
   UINT existing_flags = SetErrorMode(new_flags);
   SetErrorMode(existing_flags | new_flags);
@@ skipping 83 matching lines @@
 
 void TestSuite::Shutdown() {
   base::debug::StopProfiling();
 
   // Clear the FeatureList that was created by Initialize().
   if (created_feature_list_)
     FeatureList::ClearInstanceForTesting();
 }
 
 }  // namespace base