Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorLeitwolf112026-11-13 19:29:35 +0300
committerLeitwolf112026-11-13 19:29:35 +0300
commit55dab34729c14c9019b7062fccd11fc22372e805 (patch)
treea36e7ef58c8d2161ec929c578f29ca12876eab9e
parent17248837a78462596809f902dd47cf113a39670b (diff)
downloadcatch3-55dab34729c14c9019b7062fccd11fc22372e805.tar.gz
Convert LCOV line numbers explicitly and refresh the amalgamation
- The 32-bit MSVC jobs failed on C4244: ParseLcov used the uint64_t it read as a std::size_t map key. The line number is now converted once, explicitly, before it is used. - extras/catch_amalgamated.cpp is regenerated with bazelisk run //tools:amalgamate, so it holds CoverageReport and the scheduler changes; bazel run //tools:check passes locally.
-rw-r--r--extras/catch_amalgamated.cpp759
-rw-r--r--src/Progmasoft/Runner/CoverageReport.cpp13
2 files changed, 763 insertions, 9 deletions
diff --git a/extras/catch_amalgamated.cpp b/extras/catch_amalgamated.cpp
index 737af11a..76fab4f2 100644
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
@@ -371,6 +371,9 @@ namespace Progmasoft::Catch3
/// The directory the test had for its temporary files; kept when the
/// attempt failed, so its contents can be inspected.
std::string temporaryDirectory;
+ /// In a coverage run, where the profile of this attempt went,
+ /// without its extension (`.profraw` or `.gcov`).
+ std::string coverageProfile;
};
/// One test of the run and everything the runner learned about it.
@@ -1133,6 +1136,10 @@ namespace Progmasoft::Catch3::Runner
std::string junitPath;
std::string jsonPath;
std::string tracePath;
+ /// Per-test coverage: every attempt runs in a process of its own and
+ /// leaves its profile below this directory, with the map of what
+ /// each test reached and the combined report; see CoverageReport.
+ std::string coverageDirectory;
unsigned slowest = 0;
/// Created when the run starts and removed when it ends normally, so
/// a file left behind shows that the run ended early.
@@ -1337,6 +1344,61 @@ namespace Progmasoft::Catch3::Runner
// Copyright (c) 2026 Progmasoft.
// SPDX-License-Identifier: MPL-2.0 WITH AdditionRef-Progmasoft-Exception-2.0
+#include <cstdint>
+#include <filesystem>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+
+namespace Progmasoft::Catch3::Runner
+{
+ /// What one test, or the whole run, reached in one source file.
+ struct FileCoverage final
+ {
+ /// Execution count of each instrumented line.
+ std::map<std::size_t, std::uint64_t> lines;
+ /// Count of each branch, by line and by its position on the line.
+ std::map<std::pair<std::size_t, std::size_t>, std::uint64_t> branches;
+ };
+
+ /// Coverage by source file.
+ using CoverageMap = std::map<std::string, FileCoverage>;
+
+ /// Reads an LCOV tracefile: `SF`, `DA` and `BRDA` records.
+ [[nodiscard]] CoverageMap
+ ParseLcov(const std::string &text);
+
+ /// Reads the JSON that `gcov --json-format` writes, adding to `map`.
+ void
+ AddGcovJson(const std::string &text, CoverageMap &map);
+
+ /// Writes `map` as an LCOV tracefile.
+ [[nodiscard]] std::string
+ ToLcov(const CoverageMap &map);
+
+ /// Prepares the directory of a coverage run: the profiles of an earlier
+ /// run below it are removed, because gcov adds to the .gcda files it
+ /// finds instead of replacing them.
+ Status
+ PrepareCoverageDirectory(const std::filesystem::path &directory);
+
+ /// Turns the profiles a coverage run left in `directory` into
+ /// `directory/coverage.json`, the lines and branches each test reached,
+ /// and `directory/coverage.lcov`, the run combined. LLVM profiles are
+ /// read with `llvm-profdata` and `llvm-cov`, gcov data with `gcov`,
+ /// found on PATH or named by CATCH3_LLVM_PROFDATA, CATCH3_LLVM_COV and
+ /// CATCH3_GCOV. Returns what the run should be told: how many profiles
+ /// there were and where the reports are, or why there are none.
+ [[nodiscard]] std::vector<std::string>
+ WriteCoverageReports(const std::filesystem::path &directory,
+ const RunResult &run,
+ const std::string &program);
+} // namespace Progmasoft::Catch3::Runner
+// Copyright (c) 2026 Progmasoft.
+// SPDX-License-Identifier: MPL-2.0 WITH AdditionRef-Progmasoft-Exception-2.0
+
#include <functional>
#include <memory>
#include <string>
@@ -2193,6 +2255,10 @@ namespace Progmasoft::Catch3::Runner::Scheduling
/// Catalog indices this process has run, in order.
std::vector<std::size_t> history;
std::string startupOutput;
+ /// In a coverage run, where the profile of the attempt this process
+ /// was started for goes, without its extension; empty for a process
+ /// that runs other tests first or only probes.
+ std::string coverageProfile;
};
struct Event final
@@ -10864,6 +10930,597 @@ namespace Progmasoft::Catch3::Runner
} // namespace Progmasoft::Catch3::Runner
// Copyright (c) 2026 Progmasoft.
// SPDX-License-Identifier: MPL-2.0 WITH AdditionRef-Progmasoft-Exception-2.0
+#include <algorithm>
+#include <cstdlib>
+#include <optional>
+#include <string_view>
+#include <system_error>
+
+
+namespace Progmasoft::Catch3::Runner
+{
+ namespace
+ {
+ /// Reads a non-negative decimal number; nothing for anything else,
+ /// such as the `-` LCOV writes for a branch never reached.
+ std::optional<std::uint64_t>
+ Number(std::string_view text)
+ {
+ if (text.empty() || text.size() > 19)
+ {
+ return std::nullopt;
+ }
+ std::uint64_t value = 0;
+ for (const char character : text)
+ {
+ if (character < '0' || character > '9')
+ {
+ return std::nullopt;
+ }
+ value
+ = value * 10 + static_cast<std::uint64_t>(character - '0');
+ }
+ return value;
+ }
+
+ std::vector<std::string_view>
+ Split(std::string_view text, char separator)
+ {
+ std::vector<std::string_view> parts;
+ std::size_t start = 0;
+ while (true)
+ {
+ const auto end = text.find(separator, start);
+ parts.push_back(text.substr(start, end - start));
+ if (end == std::string_view::npos)
+ {
+ return parts;
+ }
+ start = end + 1;
+ }
+ }
+
+ /// A tool of a coverage format: the program, or the command that
+ /// runs it, such as `xcrun llvm-cov` on macOS.
+ using Tool = std::vector<std::string>;
+
+ std::optional<Tool>
+ FindTool(const char *variable, const std::string &name)
+ {
+ std::vector<Tool> candidates;
+ if (auto configured = ReadEnvironment(variable);
+ !configured.empty())
+ {
+ candidates.push_back({ std::move(configured) });
+ }
+ candidates.push_back({ name });
+#if defined(__APPLE__)
+ candidates.push_back({ "xcrun", name });
+#endif
+ for (auto &candidate : candidates)
+ {
+ ChildOptions options;
+ options.arguments = candidate;
+ options.arguments.emplace_back("--version");
+ options.searchPath = true;
+ if (auto run = RunAndCapture(options);
+ run && run->status.Succeeded())
+ {
+ return std::move(candidate);
+ }
+ }
+ return std::nullopt;
+ }
+
+ /// Runs `tool` with `arguments`; its output, or why it failed.
+ Expected<std::string>
+ RunTool(const Tool &tool,
+ const std::vector<std::string> &arguments,
+ const std::filesystem::path &directory = {})
+ {
+ ChildOptions options;
+ options.arguments = tool;
+ options.arguments.insert(options.arguments.end(),
+ arguments.begin(),
+ arguments.end());
+ options.searchPath = true;
+ options.workingDirectory = directory;
+ auto run = RunAndCapture(options);
+ if (!run)
+ {
+ return run.GetError();
+ }
+ if (!run->status.Succeeded())
+ {
+ std::string message = run->errors;
+ while (!message.empty()
+ && (message.back() == '\n' || message.back() == '\r'))
+ {
+ message.pop_back();
+ }
+ return Error{ tool.back() + " failed: " + message };
+ }
+ return std::move(run->output);
+ }
+
+ void
+ Add(CoverageMap &total, const CoverageMap &part)
+ {
+ for (const auto &[file, coverage] : part)
+ {
+ FileCoverage &into = total[file];
+ for (const auto &[line, count] : coverage.lines)
+ {
+ into.lines[line] += count;
+ }
+ for (const auto &[branch, count] : coverage.branches)
+ {
+ into.branches[branch] += count;
+ }
+ }
+ }
+
+ /// What one test reached: the lines it ran and, per line, how many
+ /// of its branches it took.
+ JsonValue
+ ReachedJson(const CoverageMap &map)
+ {
+ JsonValue files = JsonValue::Array();
+ for (const auto &[file, coverage] : map)
+ {
+ JsonValue lines = JsonValue::Array();
+ for (const auto &[line, count] : coverage.lines)
+ {
+ if (count > 0)
+ {
+ lines.Append(line);
+ }
+ }
+ JsonValue branches = JsonValue::Array();
+ std::map<std::size_t, std::pair<std::size_t, std::size_t>>
+ perLine;
+ for (const auto &[branch, count] : coverage.branches)
+ {
+ auto &[taken, total] = perLine[branch.first];
+ ++total;
+ if (count > 0)
+ {
+ ++taken;
+ }
+ }
+ for (const auto &[line, counts] : perLine)
+ {
+ if (counts.first == 0)
+ {
+ continue;
+ }
+ branches.Append(
+ JsonValue::Object({ { "line", line },
+ { "taken", counts.first },
+ { "total", counts.second } }));
+ }
+ if (lines.Items().empty())
+ {
+ continue;
+ }
+ files.Append(
+ JsonValue::Object({ { "file", file },
+ { "lines", std::move(lines) },
+ { "branches", std::move(branches) } }));
+ }
+ return files;
+ }
+
+ /// The final attempt of a test that left a profile.
+ const Attempt *
+ ProfiledAttempt(const TestResult &test)
+ {
+ for (auto attempt = test.attempts.rbegin();
+ attempt != test.attempts.rend();
+ ++attempt)
+ {
+ if (!attempt->coverageProfile.empty())
+ {
+ return &*attempt;
+ }
+ }
+ return nullptr;
+ }
+
+ /// The .gcda files gcov wrote below `prefix`, each with the path the
+ /// object was built at, where its .gcno is.
+ std::vector<std::pair<std::filesystem::path, std::filesystem::path>>
+ GcdaFiles(const std::filesystem::path &prefix)
+ {
+ std::vector<std::pair<std::filesystem::path, std::filesystem::path>>
+ files;
+ std::error_code error;
+ for (auto entry
+ = std::filesystem::recursive_directory_iterator(prefix, error);
+ !error
+ && entry != std::filesystem::recursive_directory_iterator();
+ entry.increment(error))
+ {
+ if (!entry->is_regular_file(error)
+ || entry->path().extension() != ".gcda")
+ {
+ continue;
+ }
+ // GCOV_PREFIX is put before the absolute path of the object.
+ const auto relative
+ = std::filesystem::relative(entry->path(), prefix, error);
+ std::filesystem::path original
+ = std::filesystem::path{ "/" } / relative;
+ files.emplace_back(entry->path(), original);
+ }
+ std::sort(files.begin(), files.end());
+ return files;
+ }
+
+ Expected<CoverageMap>
+ GcovCoverage(const Tool &gcov, const std::filesystem::path &prefix)
+ {
+ CoverageMap map;
+ for (const auto &[gcda, original] : GcdaFiles(prefix))
+ {
+ auto gcno = original;
+ gcno.replace_extension(".gcno");
+ auto beside = gcda;
+ beside.replace_extension(".gcno");
+ std::error_code error;
+ std::filesystem::copy_file(
+ gcno,
+ beside,
+ std::filesystem::copy_options::overwrite_existing,
+ error);
+ if (error)
+ {
+ return Error{ "the notes file " + gcno.string()
+ + " could not be read: " + error.message() };
+ }
+ auto json = RunTool(
+ gcov,
+ { "--json-format", "--stdout", gcda.filename().string() },
+ gcda.parent_path());
+ if (!json)
+ {
+ return json.GetError();
+ }
+ // One JSON document per data file, one per line.
+ for (const auto line : Split(*json, '\n'))
+ {
+ if (!line.empty())
+ {
+ AddGcovJson(std::string{ line }, map);
+ }
+ }
+ }
+ return map;
+ }
+ } // namespace
+
+ CoverageMap
+ ParseLcov(const std::string &text)
+ {
+ CoverageMap map;
+ FileCoverage *current = nullptr;
+ for (auto line : Split(text, '\n'))
+ {
+ if (!line.empty() && line.back() == '\r')
+ {
+ line.remove_suffix(1);
+ }
+ if (line.substr(0, 3) == "SF:")
+ {
+ current = &map[std::string{ line.substr(3) }];
+ }
+ else if (line == "end_of_record")
+ {
+ current = nullptr;
+ }
+ else if (current != nullptr && line.substr(0, 3) == "DA:")
+ {
+ const auto fields = Split(line.substr(3), ',');
+ const auto number = Number(fields[0]);
+ const auto count
+ = fields.size() > 1 ? Number(fields[1]) : std::nullopt;
+ if (number && count)
+ {
+ current->lines[static_cast<std::size_t>(*number)] += *count;
+ }
+ }
+ else if (current != nullptr && line.substr(0, 5) == "BRDA:")
+ {
+ const auto fields = Split(line.substr(5), ',');
+ if (fields.size() != 4)
+ {
+ continue;
+ }
+ const auto parsed = Number(fields[0]);
+ if (!parsed)
+ {
+ continue;
+ }
+ const auto number = static_cast<std::size_t>(*parsed);
+ // The branches of a line are numbered in the order they come;
+ // `-` counts as never taken.
+ std::size_t index = 0;
+ for (auto it = current->branches.lower_bound({ number, 0 });
+ it != current->branches.end()
+ && it->first.first == number;
+ ++it)
+ {
+ ++index;
+ }
+ current->branches[{ number, index }]
+ += Number(fields[3]).value_or(0);
+ }
+ }
+ return map;
+ }
+
+ void
+ AddGcovJson(const std::string &text, CoverageMap &map)
+ {
+ auto document = ParseJson(text);
+ if (!document)
+ {
+ return;
+ }
+ for (const auto &file : (*document)["files"].Items())
+ {
+ FileCoverage &coverage = map[file["file"].AsString()];
+ for (const auto &line : file["lines"].Items())
+ {
+ const auto number = static_cast<std::size_t>(
+ line["line_number"].AsUnsigned());
+ coverage.lines[number] += line["count"].AsUnsigned();
+ std::size_t index = 0;
+ for (const auto &branch : line["branches"].Items())
+ {
+ coverage.branches[{ number, index++ }]
+ += branch["count"].AsUnsigned();
+ }
+ }
+ }
+ }
+
+ std::string
+ ToLcov(const CoverageMap &map)
+ {
+ std::string text;
+ for (const auto &[file, coverage] : map)
+ {
+ text += "SF:" + file + "\n";
+ std::size_t linesHit = 0;
+ for (const auto &[line, count] : coverage.lines)
+ {
+ text += "DA:" + std::to_string(line) + ","
+ + std::to_string(count) + "\n";
+ linesHit += count > 0 ? 1 : 0;
+ }
+ std::size_t branchesHit = 0;
+ for (const auto &[branch, count] : coverage.branches)
+ {
+ text += "BRDA:" + std::to_string(branch.first) + ",0,"
+ + std::to_string(branch.second) + ","
+ + (count > 0 ? std::to_string(count) : "-") + "\n";
+ branchesHit += count > 0 ? 1 : 0;
+ }
+ text += "LF:" + std::to_string(coverage.lines.size()) + "\n";
+ text += "LH:" + std::to_string(linesHit) + "\n";
+ text += "BRF:" + std::to_string(coverage.branches.size()) + "\n";
+ text += "BRH:" + std::to_string(branchesHit) + "\n";
+ text += "end_of_record\n";
+ }
+ return text;
+ }
+
+ Status
+ PrepareCoverageDirectory(const std::filesystem::path &directory)
+ {
+ std::error_code error;
+ std::filesystem::remove_all(directory / "profiles", error);
+ if (error)
+ {
+ return Error{ "the profiles of an earlier run in "
+ + directory.string()
+ + " could not be removed: " + error.message() };
+ }
+ std::filesystem::create_directories(directory / "profiles", error);
+ if (error)
+ {
+ return Error{ "the coverage directory " + directory.string()
+ + " could not be created: " + error.message() };
+ }
+ return Status::Ok();
+ }
+
+ std::vector<std::string>
+ WriteCoverageReports(const std::filesystem::path &directory,
+ const RunResult &run,
+ const std::string &program)
+ {
+ std::vector<std::string> notes;
+ std::size_t llvmProfiles = 0;
+ std::size_t gcovProfiles = 0;
+ for (const auto &test : run.tests)
+ {
+ if (const Attempt *attempt = ProfiledAttempt(test))
+ {
+ std::error_code error;
+ llvmProfiles += std::filesystem::exists(attempt->coverageProfile
+ + ".profraw",
+ error)
+ ? 1
+ : 0;
+ gcovProfiles += std::filesystem::exists(attempt->coverageProfile
+ + ".gcov",
+ error)
+ ? 1
+ : 0;
+ }
+ }
+ if (llvmProfiles == 0 && gcovProfiles == 0)
+ {
+ notes.emplace_back(
+ "--coverage: the tests wrote no coverage; build them with "
+ "-fprofile-instr-generate -fcoverage-mapping (Clang) or "
+ "--coverage (GCC)");
+ return notes;
+ }
+ const bool llvm = llvmProfiles >= gcovProfiles;
+ std::optional<Tool> profdata;
+ std::optional<Tool> cov;
+ std::optional<Tool> gcov;
+ if (llvm)
+ {
+ profdata = FindTool("CATCH3_LLVM_PROFDATA", "llvm-profdata");
+ cov = FindTool("CATCH3_LLVM_COV", "llvm-cov");
+ }
+ else
+ {
+ gcov = FindTool("CATCH3_GCOV", "gcov");
+ }
+ if (llvm ? (!profdata || !cov) : !gcov)
+ {
+ notes.push_back(
+ "--coverage: "
+ + std::to_string(llvm ? llvmProfiles : gcovProfiles)
+ + " profile(s) in " + (directory / "profiles").string() + "; "
+ + (llvm ? "llvm-profdata and llvm-cov were" : "gcov was")
+ + " not found, so there is no map of what each test reached");
+ return notes;
+ }
+
+ CoverageMap combined;
+ std::vector<std::string> raw;
+ JsonValue tests = JsonValue::Array();
+ std::vector<std::string> failures;
+ for (const auto &test : run.tests)
+ {
+ const Attempt *attempt = ProfiledAttempt(test);
+ if (attempt == nullptr)
+ {
+ continue;
+ }
+ const std::string base = attempt->coverageProfile;
+ Expected<CoverageMap> reached = CoverageMap{};
+ std::string profile;
+ if (llvm)
+ {
+ profile = base + ".profraw";
+ std::error_code error;
+ if (!std::filesystem::exists(profile, error))
+ {
+ continue;
+ }
+ raw.push_back(profile);
+ auto merged = RunTool(
+ *profdata,
+ { "merge", "-sparse", profile, "-o", base + ".profdata" });
+ if (!merged)
+ {
+ failures.push_back(test.name + ": "
+ + merged.GetError().Message());
+ continue;
+ }
+ auto lcov = RunTool(*cov,
+ { "export",
+ "-format=lcov",
+ "-instr-profile=" + base + ".profdata",
+ program });
+ if (!lcov)
+ {
+ failures.push_back(test.name + ": "
+ + lcov.GetError().Message());
+ continue;
+ }
+ reached = ParseLcov(*lcov);
+ }
+ else
+ {
+ profile = base + ".gcov";
+ std::error_code error;
+ if (!std::filesystem::exists(profile, error))
+ {
+ continue;
+ }
+ reached = GcovCoverage(*gcov, profile);
+ if (!reached)
+ {
+ failures.push_back(test.name + ": "
+ + reached.GetError().Message());
+ continue;
+ }
+ Add(combined, *reached);
+ }
+ tests.Append(
+ JsonValue::Object({ { "name", test.name },
+ { "outcome", OutcomeName(test.outcome) },
+ { "profile", profile },
+ { "files", ReachedJson(*reached) } }));
+ }
+
+ std::string lcovText;
+ if (llvm && !raw.empty())
+ {
+ std::vector<std::string> arguments{ "merge", "-sparse" };
+ arguments.insert(arguments.end(), raw.begin(), raw.end());
+ const std::string all = (directory / "coverage.profdata").string();
+ arguments.emplace_back("-o");
+ arguments.push_back(all);
+ auto merged = RunTool(*profdata, arguments);
+ auto exported = merged ? RunTool(*cov,
+ { "export",
+ "-format=lcov",
+ "-instr-profile=" + all,
+ program })
+ : Expected<std::string>{ merged.GetError() };
+ if (exported)
+ {
+ lcovText = *exported;
+ }
+ else
+ {
+ failures.push_back("the combined report: "
+ + exported.GetError().Message());
+ }
+ }
+ else
+ {
+ lcovText = ToLcov(combined);
+ }
+
+ JsonValue report
+ = JsonValue::Object({ { "version", 1 },
+ { "format", llvm ? "llvm" : "gcov" },
+ { "binary", program },
+ { "tests", std::move(tests) } });
+ const auto json = directory / "coverage.json";
+ const auto lcov = directory / "coverage.lcov";
+ if (auto status = WriteFileAtomically(json, report.ToPrettyString());
+ !status)
+ {
+ failures.push_back(status.GetError().Message());
+ }
+ if (auto status = WriteFileAtomically(lcov, lcovText); !status)
+ {
+ failures.push_back(status.GetError().Message());
+ }
+ notes.push_back(
+ "--coverage: " + std::to_string(llvm ? llvmProfiles : gcovProfiles)
+ + " test profile(s); what each test reached is in " + json.string()
+ + ", the run combined in " + lcov.string());
+ for (const auto &failure : failures)
+ {
+ notes.push_back("--coverage: " + failure);
+ }
+ return notes;
+ }
+} // namespace Progmasoft::Catch3::Runner
+// Copyright (c) 2026 Progmasoft.
+// SPDX-License-Identifier: MPL-2.0 WITH AdditionRef-Progmasoft-Exception-2.0
#include <atomic>
#include <chrono>
#include <cstdio>
@@ -13868,6 +14525,21 @@ namespace Progmasoft::Catch3::Runner
options.tracePath = *value;
return Status::Ok();
}},
+ {"coverage",
+ '\0',
+ Takes::kValue,
+ "DIR",
+ "Output",
+ "run every test in a process of its own and keep its "
+ "coverage in DIR, with a map of what each test reached",
+ [](Options &options, const std::optional<std::string> &value) {
+ if (value->empty())
+ {
+ return Status{ Error{ "--coverage needs a directory" } };
+ }
+ options.coverageDirectory = *value;
+ return Status::Ok();
+ }},
{"premature-exit-guard-file",
'\0',
Takes::kValue,
@@ -14143,6 +14815,11 @@ namespace Progmasoft::Catch3::Runner
return status.GetError();
}
}
+ if (!options.coverageDirectory.empty() && options.inProcess)
+ {
+ return Error{ "--coverage runs every test in a process of its own, "
+ "so it cannot be used with --in-process or --break" };
+ }
return options;
}
@@ -18508,6 +19185,7 @@ namespace Progmasoft::Catch3::Runner
SetText(value, "exitDescription", attempt.exitDescription);
SetText(value, "lastLocation", attempt.lastLocation);
SetText(value, "temporaryDirectory", attempt.temporaryDirectory);
+ SetText(value, "coverageProfile", attempt.coverageProfile);
return value;
}
@@ -18547,6 +19225,7 @@ namespace Progmasoft::Catch3::Runner
attempt.exitDescription = value["exitDescription"].AsString();
attempt.lastLocation = value["lastLocation"].AsString();
attempt.temporaryDirectory = value["temporaryDirectory"].AsString();
+ attempt.coverageProfile = value["coverageProfile"].AsString();
return attempt;
}
@@ -19625,6 +20304,17 @@ namespace Progmasoft::Catch3
}
}
+ if (!options.coverageDirectory.empty())
+ {
+ if (auto status = Runner::PrepareCoverageDirectory(
+ options.coverageDirectory);
+ !status)
+ {
+ PrintError(status.GetError().Message());
+ return Catch::UnspecifiedErrorExitCode;
+ }
+ }
+
const auto started = std::chrono::steady_clock::now();
RunResult run;
run.binary = programName;
@@ -19659,6 +20349,14 @@ namespace Progmasoft::Catch3
run.tests.push_back(std::move(kept));
}
run.notes = std::move(outcome.notes);
+ if (!options.coverageDirectory.empty())
+ {
+ for (auto &note : Runner::WriteCoverageReports(
+ options.coverageDirectory, run, program.string()))
+ {
+ run.notes.push_back(std::move(note));
+ }
+ }
const bool anyFailure
= std::any_of(run.tests.begin(),
@@ -20059,6 +20757,10 @@ namespace Progmasoft::Catch3::Runner
}
attempt.temporaryDirectory
= TemporaryFor(catalogIndex, attempt.number);
+ if (target)
+ {
+ attempt.coverageProfile = worker.coverageProfile;
+ }
worker.running = std::move(running);
if (options_.inProcess)
{
@@ -20686,8 +21388,33 @@ namespace Progmasoft::Catch3::Runner
// Worker processes.
+ /// Where the coverage profile of the next attempt of `job` goes,
+ /// without its extension. Only an attempt that runs alone in its
+ /// process gets one: a job that runs other tests first would
+ /// count their lines as its own.
+ std::string
+ CoverageProfileFor(const Job &job) const
+ {
+ if (options_.coverageDirectory.empty()
+ || job.kind != Job::Kind::kAttempt || !job.before.empty())
+ {
+ return {};
+ }
+ const std::size_t catalogIndex
+ = plan_.tests[job.test].entry->index;
+ const std::size_t attempt
+ = states_[job.test].result.attempts.size() + 1;
+ return (std::filesystem::path{ options_.coverageDirectory }
+ / "profiles"
+ / ("t" + std::to_string(catalogIndex) + "-a"
+ + std::to_string(attempt)))
+ .string();
+ }
+
Worker *
- SpawnWorker(bool dedicated, std::optional<std::uint32_t> seed)
+ SpawnWorker(bool dedicated,
+ std::optional<std::uint32_t> seed,
+ std::string coverageProfile = {})
{
if (infrastructureFailed_)
{
@@ -20707,6 +21434,26 @@ namespace Progmasoft::Catch3::Runner
const std::size_t id = ++workersStarted_;
child.environment.emplace_back("CATCH3_WORKER",
std::to_string(id));
+ if (!options_.coverageDirectory.empty())
+ {
+ // Each runtime reads its own variable: LLVM's profile
+ // runtime the file it writes at exit, gcov the directory
+ // its .gcda files go below. A process that is not one
+ // attempt alone writes beside the profiles, never into
+ // one of them.
+ const std::string base
+ = !coverageProfile.empty()
+ ? coverageProfile
+ : (std::filesystem::path{
+ options_.coverageDirectory }
+ / "profiles"
+ / ("other-w" + std::to_string(id)))
+ .string();
+ child.environment.emplace_back("LLVM_PROFILE_FILE",
+ base + ".profraw");
+ child.environment.emplace_back("GCOV_PREFIX",
+ base + ".gcov");
+ }
child.keptEnvironment = options_.passedEnvironment;
auto process = ChildProcess::Start(child);
if (!process)
@@ -20723,6 +21470,7 @@ namespace Progmasoft::Catch3::Runner
worker->id = id;
worker->dedicated = dedicated;
worker->seed = seed;
+ worker->coverageProfile = std::move(coverageProfile);
worker->started = Clock::now();
worker->process = std::move(*process);
Worker *raw = worker.get();
@@ -20812,8 +21560,12 @@ namespace Progmasoft::Catch3::Runner
return;
}
const PlannedTest &planned = plan_.tests[job->test];
+ // A coverage run gives every attempt a process of its