base / test / gtest_xml_util.cc [blame]

// Copyright 2013 The Chromium Authors
// 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/check.h"
#include "base/files/file_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/gtest_util.h"
#include "base/test/launcher/test_launcher.h"
#include "third_party/libxml/chromium/libxml_utils.h"
#include "third_party/libxml/chromium/xml_reader.h"

namespace base {

namespace {

// No-op error handler that replaces libxml's default, which writes to stderr.
// The test launcher's worker threads speculatively parse results XML to detect
// timeouts in the processes they manage, so logging parsing errors could be
// noisy (e.g., crbug.com/1466897).
void NullXmlErrorFunc(void* context, const char* message, ...) {}

}  // namespace

struct Link {
  // The name of the test case.
  std::string name;
  // The name of the classname of the test.
  std::string classname;
  // The name of the link.
  std::string link_name;
  // The actual link.
  std::string link;
};

struct Property {
  // The name of the property.
  std::string name;
  // The value of the property.
  std::string value;
};

struct Tag {
  // The name of the test case.
  std::string name;
  // The name of the classname of the test.
  std::string classname;
  // The name of the tag.
  std::string tag_name;
  // The value of the tag.
  std::string tag_value;
};

bool ProcessGTestOutput(const base::FilePath& output_file,
                        std::vector<TestResult>* results,
                        bool* crashed) {
  DCHECK(results);

  std::string xml_contents;
  if (!ReadFileToString(output_file, &xml_contents))
    return false;

  // Silence XML errors - otherwise they go to stderr.
  ScopedXmlErrorFunc error_func(nullptr, &NullXmlErrorFunc);

  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;

  std::vector<Link> links;

  std::vector<Property> properties;

  std::vector<Tag> tags;

  while (xml_reader.Read()) {
    xml_reader.SkipToElement();
    std::string node_name(xml_reader.NodeName());

    switch (state) {
      case STATE_INIT:
        if (node_name == "testsuites" && !xml_reader.IsClosingElement())
          state = STATE_TESTSUITE;
        else
          return false;
        break;
      case STATE_TESTSUITE:
        if (node_name == "testsuites" && xml_reader.IsClosingElement())
          state = STATE_END;
        else if (node_name == "testsuite" && !xml_reader.IsClosingElement())
          state = STATE_TESTCASE;
        else
          return false;
        break;
      case STATE_TESTCASE:
        if (node_name == "testsuite" && xml_reader.IsClosingElement()) {
          state = STATE_TESTSUITE;
        } else if (node_name == "x-teststart" &&
                   !xml_reader.IsClosingElement()) {
          // This is our custom extension that helps recognize which test was
          // running when the test binary crashed.
          TestResult result;

          std::string test_case_name;
          if (!xml_reader.NodeAttribute("classname", &test_case_name))
            return false;
          std::string test_name;
          if (!xml_reader.NodeAttribute("name", &test_name))
            return false;
          result.full_name = FormatFullTestName(test_case_name, test_name);

          result.elapsed_time = TimeDelta();

          std::string test_timestamp_str;
          Time test_timestamp;
          if (xml_reader.NodeAttribute("timestamp", &test_timestamp_str) &&
              Time::FromString(test_timestamp_str.c_str(), &test_timestamp)) {
            result.timestamp = test_timestamp;
          }

          // Assume the test crashed - we can correct that later.
          result.status = TestResult::TEST_CRASH;

          results->push_back(result);
        } else if (node_name == "testcase" && !xml_reader.IsClosingElement()) {
          std::string test_status;
          if (!xml_reader.NodeAttribute("status", &test_status))
            return false;

          if (test_status != "run" && test_status != "notrun")
            return false;
          if (test_status != "run")
            break;

          TestResult result;

          std::string test_case_name;
          if (!xml_reader.NodeAttribute("classname", &test_case_name))
            return false;
          std::string test_name;
          if (!xml_reader.NodeAttribute("name", &test_name))
            return false;
          result.full_name = test_case_name + "." + test_name;

          std::string test_time_str;
          if (!xml_reader.NodeAttribute("time", &test_time_str))
            return false;
          result.elapsed_time = Microseconds(
              static_cast<int64_t>(strtod(test_time_str.c_str(), nullptr) *
                                   Time::kMicrosecondsPerSecond));

          // The timestamp attribute records the local date and time of the test
          // execution. It might be missing in the xml generated by older
          // version of test launcher or gtest.
          // https://github.com/google/googletest/blob/main/docs/advanced.md#generating-an-xml-report
          std::string test_timestamp_str;
          Time test_timestamp;
          if (xml_reader.NodeAttribute("timestamp", &test_timestamp_str) &&
              Time::FromString(test_timestamp_str.c_str(), &test_timestamp)) {
            result.timestamp = test_timestamp;
          }

          result.status = TestResult::TEST_SUCCESS;

          if (!results->empty() &&
              results->back().full_name == result.full_name &&
              results->back().status == TestResult::TEST_CRASH) {
            // Erase the fail-safe "crashed" result - now we know the test did
            // not crash.
            results->pop_back();
          }

          for (const Link& link : links) {
            if (link.name == test_name && link.classname == test_case_name) {
              result.AddLink(link.link_name, link.link);
            }
          }
          links.clear();
          for (const Property& property : properties) {
            result.AddProperty(property.name, property.value);
          }
          properties.clear();
          for (const Tag& tag : tags) {
            if (tag.name == test_name && tag.classname == test_case_name) {
              result.AddTag(tag.tag_name, tag.tag_value);
            }
          }
          tags.clear();
          results->push_back(result);
        } else if (node_name == "link" && !xml_reader.IsClosingElement()) {
          Link link;
          if (!xml_reader.NodeAttribute("name", &link.name))
            return false;
          if (!xml_reader.NodeAttribute("classname", &link.classname))
            return false;
          if (!xml_reader.NodeAttribute("link_name", &link.link_name))
            return false;
          if (!xml_reader.ReadElementContent(&link.link))
            return false;
          links.push_back(link);
        } else if (node_name == "link" && xml_reader.IsClosingElement()) {
          // Deliberately empty.
        } else if (node_name == "tag" && !xml_reader.IsClosingElement()) {
          Tag tag;
          if (!xml_reader.NodeAttribute("name", &tag.name))
            return false;
          if (!xml_reader.NodeAttribute("classname", &tag.classname))
            return false;
          if (!xml_reader.NodeAttribute("tag_name", &tag.tag_name))
            return false;
          if (!xml_reader.ReadElementContent(&tag.tag_value))
            return false;
          tags.push_back(tag);
        } else if (node_name == "tag" && xml_reader.IsClosingElement()) {
          // Deliberately empty.
        } else if (node_name == "properties" &&
                   !xml_reader.IsClosingElement()) {
          // Deliberately empty, begin of the test properties.
        } else if (node_name == "property" && !xml_reader.IsClosingElement()) {
          Property property;
          if (!xml_reader.NodeAttribute("name", &property.name))
            return false;
          if (!xml_reader.NodeAttribute("value", &property.value))
            return false;
          properties.push_back(property);
        } else if (node_name == "properties" && xml_reader.IsClosingElement()) {
          // Deliberately empty, end of the test properties.
        } else if (node_name == "failure" && !xml_reader.IsClosingElement()) {
          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;

          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" && xml_reader.IsClosingElement()) {
        } else if (node_name == "message" && !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;
    }
  }

  if (crashed) {
    *crashed = (state != STATE_END);
  }
  return true;
}

}  // namespace base