Report failed expect/assert to test launcher summary output.

base/test/gtest_xml_util.cc

 // Copyright 2013 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_util.h"
 
 #include <stdint.h>
 
+#include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/gtest_util.h"
 #include "base/test/launcher/test_launcher.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace base {
 
 namespace {
 
 // This is used for the xml parser to report errors. This assumes the context
@@ skipping 22 matching lines @@
   ScopedXmlErrorFunc error_func(&xml_errors, &XmlErrorFunc);
 
   XmlReader xml_reader;
   if (!xml_reader.Load(xml_contents))
     return false;
 
   enum {
     STATE_INIT,
     STATE_TESTSUITE,
     STATE_TESTCASE,
+    STATE_TEST_RESULT,
     STATE_FAILURE,
     STATE_END,
   } state = STATE_INIT;
 
   while (xml_reader.Read()) {
     xml_reader.SkipToElement();
     std::string node_name(xml_reader.NodeName());
 
     switch (state) {
       case STATE_INIT:
@@ skipping 75 matching lines @@
           std::string failure_message;
           if (!xml_reader.NodeAttribute("message", &failure_message))
             return false;
 
           DCHECK(!results->empty());
           results->back().status = TestResult::TEST_FAILURE;
 
           state = STATE_FAILURE;
         } else if (node_name == "testcase" && xml_reader.IsClosingElement()) {
           // Deliberately empty.
+        } else if (node_name == "x-test-result-part" &&
+                   !xml_reader.IsClosingElement()) {
+          std::string result_type;
+          if (!xml_reader.NodeAttribute("type", &result_type))
+            return false;
+
+          std::string file_name;
+          if (!xml_reader.NodeAttribute("file", &file_name))
+            return false;
+
+          std::string line_number_str;
+          if (!xml_reader.NodeAttribute("line", &line_number_str))
+            return false;
+
+          int line_number;
+          if (!StringToInt(line_number_str, &line_number))
+            return false;
+
+          TestResultPart::Type type;
+          if (!TestResultPart::TypeFromString(result_type, &type))
+            return false;
+
+          TestResultPart test_result_part;
+          test_result_part.type = type;
+          test_result_part.file_name = file_name,
+          test_result_part.line_number = line_number;
+          DCHECK(!results->empty());
+          results->back().test_result_parts.push_back(test_result_part);
+
+          state = STATE_TEST_RESULT;
         } else {
           return false;
         }
+        break;
+      case STATE_TEST_RESULT:
+        if (node_name == "summary" && !xml_reader.IsClosingElement()) {
+          std::string summary;
+          if (!xml_reader.ReadElementContent(&summary))
+            return false;
+
+          DCHECK(!results->empty());
+          DCHECK(!results->back().test_result_parts.empty());
+          results->back().test_result_parts.back().summary = summary;
+        } else if (node_name == "summary" && xml_reader.IsClosingElement()) {
+        } else if (node_name == "summary-encoded" &&
+                   !xml_reader.IsClosingElement()) {
+          std::string summary;
+          if (!xml_reader.ReadElementContent(&summary))
+            return false;
+
+          if (!Base64Decode(summary, &summary))
+            return false;
+
+          DCHECK(!results->empty());
+          DCHECK(!results->back().test_result_parts.empty());
+          results->back().test_result_parts.back().summary = summary;
+        } else if (node_name == "summary-encoded" &&
+                   xml_reader.IsClosingElement()) {
+        } else if (node_name == "message" && !xml_reader.IsClosingElement()) {
+          std::string message;
+          if (!xml_reader.ReadElementContent(&message))
+            return false;
+
+          DCHECK(!results->empty());
+          DCHECK(!results->back().test_result_parts.empty());
+          results->back().test_result_parts.back().message = message;
+        } else if (node_name == "message" && xml_reader.IsClosingElement()) {
+        } else if (node_name == "message-encoded" &&
+                   !xml_reader.IsClosingElement()) {
+          std::string message;
+          if (!xml_reader.ReadElementContent(&message))
+            return false;
+
+          if (!Base64Decode(message, &message))
+            return false;
+
+          DCHECK(!results->empty());
+          DCHECK(!results->back().test_result_parts.empty());
+          results->back().test_result_parts.back().message = message;
+        } else if (node_name == "message" && xml_reader.IsClosingElement()) {
+        } else if (node_name == "x-test-result-part" &&
+                   xml_reader.IsClosingElement()) {
+          state = STATE_TESTCASE;
+        } else {
+          return false;
+        }
         break;
       case STATE_FAILURE:
         if (node_name == "failure" && xml_reader.IsClosingElement())
           state = STATE_TESTCASE;
         else
           return false;
         break;
       case STATE_END:
         // If we are here and there are still XML elements, the file has wrong
         // format.
         return false;
     }
   }
 
   *crashed = (state != STATE_END);
   return true;
 }
 
 }  // namespace base