Report failed expect/assert to test launcher summary output.

base/test/gtest_xml_unittest_result_printer.cc

 // Copyright 2015 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/gtest_xml_unittest_result_printer.h"
 
+#include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/strings/string_util.h"
 #include "base/time/time.h"
 
 namespace base {
 
+namespace {
+
+bool NeedsEscaping(const std::string& text) {
+  return !IsStringUTF8(text) || text.find('<') != std::string::npos ||
+         text.find('>') != std::string::npos;
+}
+
+}  // namespace
+
 XmlUnitTestResultPrinter::XmlUnitTestResultPrinter() : output_file_(NULL) {
 }
 
 XmlUnitTestResultPrinter::~XmlUnitTestResultPrinter() {
   if (output_file_) {
     fprintf(output_file_, "</testsuites>\n");
     fflush(output_file_);
     CloseFile(output_file_);
   }
 }
@@ skipping 34 matching lines @@
           "    <testcase name=\"%s\" status=\"run\" time=\"%.3f\""
           " classname=\"%s\">\n",
           test_info.name(),
           static_cast<double>(test_info.result()->elapsed_time()) /
               Time::kMillisecondsPerSecond,
           test_info.test_case_name());
   if (test_info.result()->Failed()) {
     fprintf(output_file_,
             "      <failure message=\"\" type=\"\"></failure>\n");
   }
+  for (int i = 0; i < test_info.result()->total_part_count(); ++i) {
+    WriteTestPartResult(test_info.result()->GetTestPartResult(i));
+  }
   fprintf(output_file_, "    </testcase>\n");
   fflush(output_file_);
 }
 
 void XmlUnitTestResultPrinter::OnTestCaseEnd(
     const testing::TestCase& test_case) {
   fprintf(output_file_, "  </testsuite>\n");
   fflush(output_file_);
 }
 
+void XmlUnitTestResultPrinter::WriteTestPartResult(
+    const testing::TestPartResult& test_part_result) {
+  const char* type = "unknown";
+  switch (test_part_result.type()) {
+    case testing::TestPartResult::kSuccess:
+      type = "success";
+      break;
+    case testing::TestPartResult::kNonFatalFailure:
+      type = "failure";
+      break;
+    case testing::TestPartResult::kFatalFailure:
+      type = "fatal_failure";
+      break;
+  }
+  std::string summary = test_part_result.summary();
+  std::string summary_tag("summary");
+  if (!NeedsEscaping(summary)) {

[Paweł Hajdan Jr., 2016/12/30 19:02:39]

Shouldn't the condition be reversed?

By the way, it may be weird for clients to look for summary or summary-encoded.
Why not do proper XML escaping?

Actually, since this is internal, why not always base64-encode for simplicity?

[alex-ac, 2016/12/30 22:10:20]

I've deleted condition and now text is encoded in base64 always.

There are too hard to make proper XML escaping here, because there is no ready
to use escaping code either in base or in libxml. There is xml writer in the
libxml chromium utilities, but it can't be used here, because it uses buffering
and file will be empty if one of tests will crash.

+    Base64Encode(summary, &summary);
+    summary_tag = "summary-encoded";
+  }
+  std::string message = test_part_result.message();
+  std::string message_tag("message");
+  if (!NeedsEscaping(message)) {
+    Base64Encode(message, &message);
+    message_tag = "message-encoded";
+  }
+  fprintf(output_file_,
+          "      <x-test-result-part type=\"%s\" file=\"%s\" line=\"%d\">\n"
+          "        <%s>%s</%s>\n"
+          "        <%s>%s</%s>\n"
+          "      </x-test-result-part>\n",
+          type, test_part_result.file_name(), test_part_result.line_number(),
+          summary_tag.c_str(), summary.c_str(), summary_tag.c_str(),
+          message_tag.c_str(), message.c_str(), message_tag.c_str());
+  fflush(output_file_);
+}
+
 }  // namespace base