catch3
Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.
Clonegit clone https://git.progmasoft.com/catch3
develroot / src / Progmasoft / Runner / ResultImportXml.cpp
// Copyright (c) 2026 Progmasoft.
// SPDX-License-Identifier: LGPL-3.0-or-later
// The XML reports: JUnit, xUnit.net v2 and Visual Studio's TRX.
#include <Progmasoft/Runner/ResultImport.hpp>
#include <cstdlib>
#include <map>
#include <string_view>
#include <utility>
#include "../PugiXml.inl"
namespace Progmasoft::Catch3::Runner
{
namespace
{
namespace ImportXml
{
Expected<bool>
Load(pugi::xml_document &document, std::string_view text)
{
const pugi::xml_parse_result parsed
= document.load_buffer(text.data(), text.size());
if (!parsed)
{
return Error{ std::string{ "it is not valid XML: " }
+ parsed.description() + " at byte "
+ std::to_string(parsed.offset) };
}
return true;
}
double
NumberOf(const char *text)
{
std::string digits;
for (; *text != '\0'; ++text)
{
if (*text != ',')
{
digits.push_back(*text);
}
}
return std::strtod(digits.c_str(), nullptr);
}
std::string
TextOf(pugi::xml_node node)
{
return node.text().get();
}
/// `error` and `failure` of JUnit and what Surefire writes for
/// retries, which have the same shape.
Attempt
JUnitFailure(pugi::xml_node node, FailureCategory category)
{
std::string details = TextOf(node);
if (const auto trace = node.child("stackTrace"))
{
details = TextOf(trace);
}
Attempt attempt
= ImportedAttempt(Outcome::kFailed,
ImportedMicroseconds(NumberOf(
node.attribute("time").value())),
node.attribute("message").value(),
std::move(details),
category);
attempt.assertions.front().macro
= node.attribute("type").value();
attempt.standardOutput = TextOf(node.child("system-out"));
attempt.standardError = TextOf(node.child("system-err"));
return attempt;
}
bool
NameIs(pugi::xml_node node, std::string_view name)
{
return name == node.name();
}
bool
NameEndsWithError(pugi::xml_node node)
{
return NameIs(node, "flakyError") || NameIs(node, "rerunError");
}
bool
NotRunStatus(pugi::xml_node testCase)
{
const std::string_view status
= testCase.attribute("status").value();
const std::string_view result
= testCase.attribute("result").value();
return status == "notrun" || status == "skipped"
|| status == "disabled" || result == "skipped"
|| result == "suppressed";
}
void
ReadJUnitCase(pugi::xml_node testCase,
pugi::xml_node suite,
std::vector<TestResult> &tests)
{
TestResult test
= ImportedTest(testCase.attribute("name").value(),
testCase.attribute("classname").value());
test.file = testCase.attribute("file").value();
for (auto outer = suite; test.file.empty() && outer;
outer = outer.parent())
{
test.file = outer.attribute("file").value();
}
test.line = testCase.attribute("line").as_ullong();
std::vector<Attempt> failures;
std::optional<Attempt> skipped;
for (const auto child : testCase.children())
{
if (NameIs(child, "flakyFailure")
|| NameIs(child, "rerunFailure")
|| NameEndsWithError(child))
{
test.attempts.push_back(JUnitFailure(
child,
NameEndsWithError(child)
? FailureCategory::kUnexpectedException
: FailureCategory::kAssertion));
}
else if (NameIs(child, "failure"))
{
failures.push_back(
JUnitFailure(child, FailureCategory::kAssertion));
}
else if (NameIs(child, "error"))
{
failures.push_back(JUnitFailure(
child,
FailureCategory::kUnexpectedException));
}
else if (NameIs(child, "skipped"))
{
std::string reason = child.attribute("message").value();
skipped = ImportedAttempt(
Outcome::kSkipped,
0,
reason.empty() ? TextOf(child) : std::move(reason));
}
}
const std::int64_t duration = ImportedMicroseconds(
NumberOf(testCase.attribute("time").value()));
Attempt verdict;
if (!failures.empty())
{
// Several failures are one attempt with several findings.
verdict = std::move(failures.front());
for (std::size_t index = 1; index < failures.size();
++index)
{
auto &record = failures[index].assertions.front();
verdict.assertions.push_back(std::move(record));
++verdict.assertionsFailed;
}
verdict.durationMicroseconds = duration;
}
else if (skipped)
{
verdict = std::move(*skipped);
}
else if (NotRunStatus(testCase))
{
verdict = ImportedAttempt(Outcome::kSkipped, 0);
}
else
{
verdict = ImportedAttempt(Outcome::kPassed, duration);
}
if (verdict.standardOutput.empty())
{
verdict.standardOutput
= TextOf(testCase.child("system-out"));
}
if (verdict.standardError.empty())
{
verdict.standardError
= TextOf(testCase.child("system-err"));
}
test.attempts.push_back(std::move(verdict));
tests.push_back(std::move(test));
}
void
ReadJUnitSuite(pugi::xml_node suite, std::vector<TestResult> &tests)
{
for (const auto child : suite.children())
{
if (NameIs(child, "testcase"))
{
ReadJUnitCase(child, suite, tests);
}
else if (NameIs(child, "testsuite"))
{
ReadJUnitSuite(child, tests);
}
}
}
void
ReadXUnitTest(pugi::xml_node node, std::vector<TestResult> &tests)
{
TestResult test = ImportedTest(node.attribute("name").value(),
node.attribute("type").value());
test.file = node.attribute("source-file").value();
test.line = node.attribute("source-line").as_ullong();
for (const auto trait : node.child("traits").children("trait"))
{
test.tags.push_back(
std::string{ trait.attribute("name").value() } + "="
+ trait.attribute("value").value());
}
const std::string_view result
= node.attribute("result").value();
const std::int64_t duration = ImportedMicroseconds(
NumberOf(node.attribute("time").value()));
Attempt attempt;
if (result == "Pass")
{
attempt = ImportedAttempt(Outcome::kPassed, duration);
}
else if (result == "Fail")
{
const auto failure = node.child("failure");
attempt
= ImportedAttempt(Outcome::kFailed,
duration,
TextOf(failure.child("message")),
TextOf(failure.child("stack-trace")));
attempt.assertions.front().macro
= failure.attribute("exception-type").value();
}
else if (result == "Skip")
{
attempt = ImportedAttempt(Outcome::kSkipped,
0,
TextOf(node.child("reason")));
}
else
{
attempt = ImportedAttempt(Outcome::kNotRun, 0);
}
if (attempt.standardOutput.empty())
{
attempt.standardOutput = TextOf(node.child("output"));
}
test.attempts.push_back(std::move(attempt));
tests.push_back(std::move(test));
}
/// A failure outside any test, such as in a fixture.
void
ReadXUnitErrors(pugi::xml_node assembly,
std::vector<TestResult> &tests)
{
for (const auto error :
assembly.child("errors").children("error"))
{
const auto failure = error.child("failure");
TestResult test = ImportedTest(
std::string{ error.attribute("type").value() } + " "
+ error.attribute("name").value(),
assembly.attribute("name").value());
test.attempts.push_back(
ImportedAttempt(Outcome::kFailed,
0,
TextOf(failure.child("message")),
TextOf(failure.child("stack-trace")),
FailureCategory::kInfrastructure));
tests.push_back(std::move(test));
}
}
void
ReadXUnitAssembly(pugi::xml_node assembly,
std::vector<TestResult> &tests)
{
ReadXUnitErrors(assembly, tests);
for (const auto child : assembly.children())
{
if (NameIs(child, "test"))
{
ReadXUnitTest(child, tests);
}
else if (NameIs(child, "collection"))
{
for (const auto test : child.children("test"))
{
ReadXUnitTest(test, tests);
}
}
}
}
/// `[days.]hours:minutes:seconds[.fraction]`.
std::int64_t
TrxDuration(std::string_view text)
{
double seconds = 0.0;
std::string field;
const auto addField = [&] {
seconds = seconds * 60.0 + NumberOf(field.c_str());
field.clear();
};
double days = 0.0;
for (std::size_t index = 0; index < text.size(); ++index)
{
if (text[index] == ':')
{
addField();
}
else if (text[index] == '.'
&& text.find(':', index) != std::string_view::npos)
{
days = NumberOf(field.c_str());
field.clear();
}
else
{
field.push_back(text[index]);
}
}
addField();
return ImportedMicroseconds(seconds + days * 86400.0);
}
struct TrxOutcome final
{
Outcome outcome = Outcome::kNotRun;
FailureCategory category = FailureCategory::kNone;
};
TrxOutcome
TrxOutcomeOf(std::string_view outcome)
{
if (outcome == "Passed" || outcome == "PassedButRunAborted"
|| outcome == "Warning" || outcome == "Completed")
{
return { Outcome::kPassed, FailureCategory::kNone };
}
if (outcome == "Failed")
{
return { Outcome::kFailed, FailureCategory::kAssertion };
}
if (outcome == "Error")
{
return { Outcome::kFailed,
FailureCategory::kUnexpectedException };
}
if (outcome == "Timeout")
{
return { Outcome::kTimedOut, FailureCategory::kTimeout };
}
if (outcome == "Aborted")
{
return { Outcome::kCrashed, FailureCategory::kCrash };
}
if (outcome == "Disconnected")
{
return { Outcome::kCrashed,
FailureCategory::kInfrastructure };
}
if (outcome == "NotExecuted" || outcome == "Inconclusive"
|| outcome == "NotRunnable")
{
return { Outcome::kSkipped, FailureCategory::kNone };
}
return {};
}
/// The class of a test: the type without its assembly.
std::string
TrxClass(std::string_view className)
{
return std::string{ className.substr(0, className.find(',')) };
}
void
ReadTrxResult(pugi::xml_node result,
const std::map<std::string, std::string> &classes,
std::vector<TestResult> &tests)
{
// A data-driven test: the rows are what ran.
if (const auto inner = result.child("InnerResults"))
{
for (const auto row : inner.children())
{
ReadTrxResult(row, classes, tests);
}
return;
}
const auto found
= classes.find(result.attribute("testId").value());
TestResult test = ImportedTest(
result.attribute("testName").value(),
found == classes.end() ? std::string{} : found->second);
const auto [outcome, category]
= TrxOutcomeOf(result.attribute("outcome").value());
const auto output = result.child("Output");
const auto error = output.child("ErrorInfo");
std::string message = TextOf(error.child("Message"));
Attempt attempt = ImportedAttempt(
outcome,
TrxDuration(result.attribute("duration").value()),
outcome == Outcome::kSkipped
? TextOf(output.child("StdOut"))
: std::move(message),
TextOf(error.child("StackTrace")),
category);
if (outcome != Outcome::kSkipped)
{
attempt.standardOutput = TextOf(output.child("StdOut"));
}
attempt.standardError = TextOf(output.child("StdErr"));
test.attempts.push_back(std::move(attempt));
tests.push_back(std::move(test));
}
} // namespace ImportXml
} // namespace
Expected<std::vector<TestResult>>
ParseJUnit(std::string_view text)
{
pugi::xml_document document;
if (auto loaded = ImportXml::Load(document, text); !loaded)
{
return loaded.GetError();
}
const pugi::xml_node root = document.document_element();
std::vector<TestResult> tests;
if (ImportXml::NameIs(root, "testsuites")
|| ImportXml::NameIs(root, "testsuite"))
{
ImportXml::ReadJUnitSuite(root, tests);
return tests;
}
return Error{ "a JUnit report has testsuites or testsuite as its root, "
"not "
+ std::string{ root.name() } };
}
Expected<std::vector<TestResult>>
ParseXUnit(std::string_view text)
{
pugi::xml_document document;
if (auto loaded = ImportXml::Load(document, text); !loaded)
{
return loaded.GetError();
}
const pugi::xml_node root = document.document_element();
std::vector<TestResult> tests;
if (ImportXml::NameIs(root, "assembly"))
{
ImportXml::ReadXUnitAssembly(root, tests);
return tests;
}
if (ImportXml::NameIs(root, "assemblies"))
{
for (const auto assembly : root.children("assembly"))
{
ImportXml::ReadXUnitAssembly(assembly, tests);
}
return tests;
}
return Error{ "an xUnit report has assemblies or assembly as its root, "
"not "
+ std::string{ root.name() } };
}
Expected<std::vector<TestResult>>
ParseTrx(std::string_view text)
{
pugi::xml_document document;
if (auto loaded = ImportXml::Load(document, text); !loaded)
{
return loaded.GetError();
}
const pugi::xml_node root = document.document_element();
if (!ImportXml::NameIs(root, "TestRun"))
{
return Error{ "a TRX report has TestRun as its root, not "
+ std::string{ root.name() } };
}
std::map<std::string, std::string> classes;
for (const auto definition : root.child("TestDefinitions").children())
{
classes[definition.attribute("id").value()] = ImportXml::TrxClass(
definition.child("TestMethod").attribute("className").value());
}
std::vector<TestResult> tests;
for (const auto result : root.child("Results").children())
{
ImportXml::ReadTrxResult(result, classes, tests);
}
return tests;
}
} // namespace Progmasoft::Catch3::Runner