Replace Catch2's runner with the Catch3 runner

Catch3 keeps Catch2's API for writing tests (test cases, sections,
assertions, matchers, generators, listeners, benchmarks) and replaces its
session, command line and reporters with a runner of its own.

The runner starts the test binary again as worker processes that take the
next test when they are free. A crash, an exit or a hang ends one test, not
the run. On top of that it adds:

- retries that tell deterministic, flaky and order-dependent failures
  apart, and a bisection that names the test leaving state behind;
- a history of verdicts and durations, kept under a file lock, that drives
  automatic quarantine, adaptive time limits, predictive ordering,
  incremental runs, failure replay and analytics;
- selection by change, past failure or prediction, dependency closure,
  and sharding by a stable hash or by recorded durations;
- tags for serial and isolated tests, shared resources, dependencies,
  time limits and retries;
- a failure category, a signature, an analysis and a replay command for
  every failure;
- console, JUnit XML (with flakyFailure and rerunFailure), JSON and Chrome
  trace reports, and a versioned discovery listing (--list=json);
- a temporary directory per test (TMPDIR, TMP, TEMP and
  TestTemporaryDirectory());
- Bazel's test environment: XML output file, test filter, sharding, seed,
  premature exit file and undeclared outputs.

The command line is parsed by a hand-written, typed parser. Catch::Session
remains as a thin facade over the runner for custom main functions.

The result model in Progmasoft/Catch3/Results.hpp was rewritten around
tests and attempts, and the JUnit writer now writes it. The property
engine's example database is updated under a file lock with an atomic
rename, so parallel workers can write it at the same time.

Removed: Clara, the command-line and reporter-spec parsers, every reporter
and CATCH_REGISTER_REPORTER, listing, text flow, console colour and width,
the JSON and XML writers, sharding in the test registry, approval tests and
their baselines, Conan packaging, and the unused third_party/clara.hpp.
Listeners keep working; reporters' list and skip events are gone.

The Catch2 library is now compiled as C++20; code that includes only
Catch2's headers still needs C++14. Duplicate test cases are still refused
at start-up. Version 0.3.0.

ExtraTests now turn exceptions off for clang-cl with MSVC-style options,
which -fno-exceptions did not do.

1 files changed, 918 insertions, 0 deletions

diff --git a/src/Progmasoft/Runner/Json.cpp b/src/Progmasoft/Runner/Json.cpp
new file mode 100644
index 00000000..46f1d18a
--- /dev/null
+++ b/src/Progmasoft/Runner/Json.cpp
@@ -0,0 +1,918 @@
+// Copyright (c) 2026 Progmasoft.
+// SPDX-License-Identifier: MPL-2.0 WITH AdditionRef-Progmasoft-Exception-1.1
+#include "Json.hpp"
+
+#include <clocale>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <limits>
+#include <optional>
+
+namespace Progmasoft::Catch3::Runner
+{
+    namespace
+    {
+        // The empty values that accessors return for a value of another
+        // kind. They are never destroyed, so that no destructor runs at exit
+        // while a worker may still be reading a message.
+        const std::string &
+        EmptyString()
+        {
+            static const auto *value = new std::string();
+            return *value;
+        }
+
+        const std::vector<JsonValue> &
+        EmptyItems()
+        {
+            static const auto *value = new std::vector<JsonValue>();
+            return *value;
+        }
+
+        const JsonMembers &
+        EmptyMembers()
+        {
+            static const auto *value = new JsonMembers();
+            return *value;
+        }
+
+        const JsonValue &
+        NullValue()
+        {
+            static const auto *value = new JsonValue();
+            return *value;
+        }
+
+        /// Documents nested deeper than this are refused, so a hostile or
+        /// broken file cannot exhaust the stack of the parser.
+        constexpr int kMaximumDepth = 256;
+
+        void
+        AppendUtf8(std::string &output, std::uint32_t codePoint)
+        {
+            if (codePoint < 0x80)
+            {
+                output.push_back(static_cast<char>(codePoint));
+            }
+            else if (codePoint < 0x800)
+            {
+                output.push_back(static_cast<char>(0xC0 | (codePoint >> 6)));
+                output.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+            }
+            else if (codePoint < 0x10000)
+            {
+                output.push_back(static_cast<char>(0xE0 | (codePoint >> 12)));
+                output.push_back(
+                    static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
+                output.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+            }
+            else
+            {
+                output.push_back(static_cast<char>(0xF0 | (codePoint >> 18)));
+                output.push_back(
+                    static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F)));
+                output.push_back(
+                    static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
+                output.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+            }
+        }
+
+        /// Reads a JSON number exactly. The grammar is checked here; strtod
+        /// does the rounding, with the point replaced by the decimal
+        /// separator of the current locale, which a test may have changed.
+        std::optional<double>
+        ToDouble(std::string_view digits)
+        {
+            std::size_t index = 0;
+            const auto skipDigits = [&] {
+                const std::size_t start = index;
+                while (index < digits.size() && digits[index] >= '0' &&
+                       digits[index] <= '9')
+                {
+                    ++index;
+                }
+                return index > start;
+            };
+            if (index < digits.size() && digits[index] == '-')
+            {
+                ++index;
+            }
+            if (!skipDigits())
+            {
+                return std::nullopt;
+            }
+            std::size_t point = std::string_view::npos;
+            if (index < digits.size() && digits[index] == '.')
+            {
+                point = index++;
+                if (!skipDigits())
+                {
+                    return std::nullopt;
+                }
+            }
+            if (index < digits.size() &&
+                (digits[index] == 'e' || digits[index] == 'E'))
+            {
+                ++index;
+                if (index < digits.size() &&
+                    (digits[index] == '+' || digits[index] == '-'))
+                {
+                    ++index;
+                }
+                if (!skipDigits())
+                {
+                    return std::nullopt;
+                }
+            }
+            if (index != digits.size())
+            {
+                return std::nullopt;
+            }
+            std::string copy{digits};
+            if (point != std::string_view::npos)
+            {
+                const char *separator = std::localeconv()->decimal_point;
+                copy.replace(point,
+                             1,
+                             separator == nullptr || *separator == '\0'
+                                 ? "."
+                                 : separator);
+            }
+            return std::strtod(copy.c_str(), nullptr);
+        }
+
+        class Parser final
+        {
+        public:
+            explicit Parser(std::string_view text)
+                : text_{text}
+            {
+            }
+
+            Expected<JsonValue>
+            ParseDocument()
+            {
+                SkipWhitespace();
+                auto value = ParseValue(0);
+                if (!value)
+                {
+                    return value;
+                }
+                SkipWhitespace();
+                if (position_ != text_.size())
+                {
+                    return Fail("unexpected text after the value");
+                }
+                return value;
+            }
+
+        private:
+            Error
+            Fail(const std::string &message) const
+            {
+                return Error{"invalid JSON at offset " +
+                             std::to_string(position_) + ": " + message};
+            }
+
+            void
+            SkipWhitespace()
+            {
+                while (position_ < text_.size())
+                {
+                    const char character = text_[position_];
+                    if (character != ' ' && character != '\t' &&
+                        character != '\n' && character != '\r')
+                    {
+                        return;
+                    }
+                    ++position_;
+                }
+            }
+
+            bool
+            Consume(std::string_view word)
+            {
+                if (text_.substr(position_, word.size()) == word)
+                {
+                    position_ += word.size();
+                    return true;
+                }
+                return false;
+            }
+
+            Expected<JsonValue>
+            ParseValue(int depth)
+            {
+                if (depth > kMaximumDepth)
+                {
+                    return Fail("nested too deeply");
+                }
+                if (position_ >= text_.size())
+                {
+                    return Fail("a value was expected");
+                }
+                const char character = text_[position_];
+                if (character == '{')
+                {
+                    return ParseObject(depth);
+                }
+                if (character == '[')
+                {
+                    return ParseArray(depth);
+                }
+                if (character == '"')
+                {
+                    auto text = ParseString();
+                    if (!text)
+                    {
+                        return text.GetError();
+                    }
+                    return JsonValue{std::move(*text)};
+                }
+                if (Consume("true"))
+                {
+                    return JsonValue{true};
+                }
+                if (Consume("false"))
+                {
+                    return JsonValue{false};
+                }
+                if (Consume("null"))
+                {
+                    return JsonValue{};
+                }
+                return ParseNumber();
+            }
+
+            Expected<JsonValue>
+            ParseNumber()
+            {
+                const std::size_t start = position_;
+                if (position_ < text_.size() && text_[position_] == '-')
+                {
+                    ++position_;
+                }
+                while (position_ < text_.size())
+                {
+                    const char character = text_[position_];
+                    const bool numeric =
+                        (character >= '0' && character <= '9') ||
+                        character == '.' || character == 'e' ||
+                        character == 'E' || character == '+' ||
+                        character == '-';
+                    if (!numeric)
+                    {
+                        break;
+                    }
+                    ++position_;
+                }
+                if (position_ == start)
+                {
+                    return Fail("a value was expected");
+                }
+                const std::string_view digits =
+                    text_.substr(start, position_ - start);
+                const auto value = ToDouble(digits);
+                if (!value)
+                {
+                    position_ = start;
+                    return Fail("malformed number");
+                }
+                return JsonValue{*value};
+            }
+
+            Expected<std::uint32_t>
+            ParseHexQuad()
+            {
+                if (position_ + 4 > text_.size())
+                {
+                    return Fail("truncated \\u escape");
+                }
+                std::uint32_t value = 0;
+                for (int index = 0; index < 4; ++index)
+                {
+                    const char character = text_[position_++];
+                    value <<= 4;
+                    if (character >= '0' && character <= '9')
+                    {
+                        value |= static_cast<std::uint32_t>(character - '0');
+                    }
+                    else if (character >= 'a' && character <= 'f')
+                    {
+                        value |=
+                            static_cast<std::uint32_t>(character - 'a' + 10);
+                    }
+                    else if (character >= 'A' && character <= 'F')
+                    {
+                        value |=
+                            static_cast<std::uint32_t>(character - 'A' + 10);
+                    }
+                    else
+                    {
+                        return Fail("malformed \\u escape");
+                    }
+                }
+                return value;
+            }
+
+            Expected<std::string>
+            ParseString()
+            {
+                ++position_; // The opening quote.
+                std::string result;
+                while (position_ < text_.size())
+                {
+                    const char character = text_[position_++];
+                    if (character == '"')
+                    {
+                        return result;
+                    }
+                    if (static_cast<unsigned char>(character) < 0x20)
+                    {
+                        return Fail("control character in a string");
+                    }
+                    if (character != '\\')
+                    {
+                        result.push_back(character);
+                        continue;
+                    }
+                    if (position_ >= text_.size())
+                    {
+                        break;
+                    }
+                    const char escape = text_[position_++];
+                    switch (escape)
+                    {
+                        case '"':
+                        case '\\':
+                        case '/':
+                            result.push_back(escape);
+                            break;
+                        case 'b':
+                            result.push_back('\b');
+                            break;
+                        case 'f':
+                            result.push_back('\f');
+                            break;
+                        case 'n':
+                            result.push_back('\n');
+                            break;
+                        case 'r':
+                            result.push_back('\r');
+                            break;
+                        case 't':
+                            result.push_back('\t');
+                            break;
+                        case 'u':
+                        {
+                            auto high = ParseHexQuad();
+                            if (!high)
+                            {
+                                return high.GetError();
+                            }
+                            std::uint32_t codePoint = *high;
+                            if (codePoint >= 0xD800 && codePoint <= 0xDBFF &&
+                                Consume("\\u"))
+                            {
+                                auto low = ParseHexQuad();
+                                if (!low)
+                                {
+                                    return low.GetError();
+                                }
+                                if (*low >= 0xDC00 && *low <= 0xDFFF)
+                                {
+                                    codePoint = 0x10000 +
+                                                ((codePoint - 0xD800) << 10) +
+                                                (*low - 0xDC00);
+                                }
+                            }
+                            AppendUtf8(result, codePoint);
+                            break;
+                        }
+                        default:
+                            return Fail("unknown escape");
+                    }
+                }
+                return Fail("unterminated string");
+            }
+
+            Expected<JsonValue>
+            ParseArray(int depth)
+            {
+                ++position_;
+                JsonValue array = JsonValue::Array();
+                SkipWhitespace();
+                if (Consume("]"))
+                {
+                    return array;
+                }
+                while (true)
+                {
+                    SkipWhitespace();
+                    auto item = ParseValue(depth + 1);
+                    if (!item)
+                    {
+                        return item;
+                    }
+                    array.Append(std::move(*item));
+                    SkipWhitespace();
+                    if (Consume("]"))
+                    {
+                        return array;
+                    }
+                    if (!Consume(","))
+                    {
+                        return Fail("',' or ']' was expected");
+                    }
+                }
+            }
+
+            Expected<JsonValue>
+            ParseObject(int depth)
+            {
+                ++position_;
+                JsonValue object = JsonValue::Object();
+                SkipWhitespace();
+                if (Consume("}"))
+                {
+                    return object;
+                }
+                while (true)
+                {
+                    SkipWhitespace();
+                    if (position_ >= text_.size() || text_[position_] != '"')
+                    {
+                        return Fail("a member name was expected");
+                    }
+                    auto key = ParseString();
+                    if (!key)
+                    {
+                        return key.GetError();
+                    }
+                    SkipWhitespace();
+                    if (!Consume(":"))
+                    {
+                        return Fail("':' was expected");
+                    }
+                    SkipWhitespace();
+                    auto value = ParseValue(depth + 1);
+                    if (!value)
+                    {
+                        return value;
+                    }
+                    object.MutableMembers().emplace_back(std::move(*key),
+                                                         std::move(*value));
+                    SkipWhitespace();
+                    if (Consume("}"))
+                    {
+                        return object;
+                    }
+                    if (!Consume(","))
+                    {
+                        return Fail("',' or '}' was expected");
+                    }
+                }
+            }
+
+            std::string_view text_;
+            std::size_t position_ = 0;
+        };
+
+        void
+        AppendNumber(std::string &output, double value)
+        {
+            if (!std::isfinite(value))
+            {
+                // JSON has no infinities; null is the conventional stand-in.
+                output += "null";
+                return;
+            }
+            if (std::fabs(value) < 9.007199254740992e15)
+            {
+                const auto integral = static_cast<long long>(value);
+                if (std::fabs(value - static_cast<double>(integral)) < 1e-9)
+                {
+                    output += std::to_string(integral);
+                    return;
+                }
+            }
+            char buffer[64];
+            std::snprintf(buffer, sizeof(buffer), "%.17g", value);
+            // The C library writes the decimal separator of the current
+            // locale, which a test may have changed.
+            for (char &character : buffer)
+            {
+                if (character == ',')
+                {
+                    character = '.';
+                }
+            }
+            output += buffer;
+        }
+
+        void
+        AppendIndent(std::string &output, int indent, int depth)
+        {
+            if (indent <= 0)
+            {
+                return;
+            }
+            output.push_back('\n');
+            output.append(static_cast<std::size_t>(indent * depth), ' ');
+        }
+    } // namespace
+
+    JsonValue::JsonValue(bool value)
+        : kind_{Kind::kBoolean}
+        , boolean_{value}
+    {
+    }
+
+    JsonValue::JsonValue(double value)
+        : kind_{Kind::kNumber}
+        , number_{value}
+    {
+    }
+
+    JsonValue::JsonValue(int value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(unsigned value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(long value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(unsigned long value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(long long value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(unsigned long long value)
+        : JsonValue{static_cast<double>(value)}
+    {
+    }
+
+    JsonValue::JsonValue(const char *value)
+        : kind_{Kind::kString}
+        , string_{value == nullptr ? "" : value}
+    {
+    }
+
+    JsonValue::JsonValue(std::string value)
+        : kind_{Kind::kString}
+        , string_{std::move(value)}
+    {
+    }
+
+    JsonValue::JsonValue(std::string_view value)
+        : kind_{Kind::kString}
+        , string_{value}
+    {
+    }
+
+    JsonValue::JsonValue(const JsonValue &other)
+    {
+        CopyFrom(other);
+    }
+
+    JsonValue::JsonValue(JsonValue &&other) noexcept
+    {
+        MoveFrom(std::move(other));
+    }
+
+    JsonValue &
+    JsonValue::operator=(const JsonValue &other)
+    {
+        if (this != &other)
+        {
+            JsonValue copy{other};
+            Destroy();
+            MoveFrom(std::move(copy));
+        }
+        return *this;
+    }
+
+    JsonValue &
+    JsonValue::operator=(JsonValue &&other) noexcept
+    {
+        if (this != &other)
+        {
+            Destroy();
+            MoveFrom(std::move(other));
+        }
+        return *this;
+    }
+
+    JsonValue::~JsonValue() = default;
+
+    void
+    JsonValue::Destroy() noexcept
+    {
+        kind_ = Kind::kNull;
+        boolean_ = false;
+        number_ = 0.0;
+        string_.clear();
+        items_.reset();
+        members_.reset();
+    }
+
+    void
+    JsonValue::CopyFrom(const JsonValue &other)
+    {
+        kind_ = other.kind_;
+        boolean_ = other.boolean_;
+        number_ = other.number_;
+        string_ = other.string_;
+        if (other.items_)
+        {
+            items_ = std::make_unique<std::vector<JsonValue>>(*other.items_);
+        }
+        if (other.members_)
+        {
+            members_ = std::make_unique<JsonMembers>(*other.members_);
+        }
+    }
+
+    void
+    JsonValue::MoveFrom(JsonValue &&other) noexcept
+    {
+        kind_ = other.kind_;
+        boolean_ = other.boolean_;
+        number_ = other.number_;
+        string_ = std::move(other.string_);
+        items_ = std::move(other.items_);
+        members_ = std::move(other.members_);
+        other.kind_ = Kind::kNull;
+    }
+
+    JsonValue
+    JsonValue::Array(std::vector<JsonValue> items)
+    {
+        JsonValue value;
+        value.kind_ = Kind::kArray;
+        value.items_ = std::make_unique<std::vector<JsonValue>>(std::move(items));
+        return value;
+    }
+
+    JsonValue
+    JsonValue::Object(JsonMembers members)
+    {
+        JsonValue value;
+        value.kind_ = Kind::kObject;
+        value.members_ = std::make_unique<JsonMembers>(std::move(members));
+        return value;
+    }
+
+    bool
+    JsonValue::AsBoolean(bool fallback) const noexcept
+    {
+        return kind_ == Kind::kBoolean ? boolean_ : fallback;
+    }
+
+    double
+    JsonValue::AsNumber(double fallback) const noexcept
+    {
+        return kind_ == Kind::kNumber ? number_ : fallback;
+    }
+
+    std::int64_t
+    JsonValue::AsInteger(std::int64_t fallback) const noexcept
+    {
+        if (kind_ != Kind::kNumber || !std::isfinite(number_) ||
+            number_ < -9.2e18 || number_ > 9.2e18)
+        {
+            return fallback;
+        }
+        return static_cast<std::int64_t>(number_);
+    }
+
+    std::uint64_t
+    JsonValue::AsUnsigned(std::uint64_t fallback) const noexcept
+    {
+        if (kind_ != Kind::kNumber || !std::isfinite(number_) ||
+            number_ < 0.0 || number_ > 1.8e19)
+        {
+            return fallback;
+        }
+        return static_cast<std::uint64_t>(number_);
+    }
+
+    const std::string &
+    JsonValue::AsString() const noexcept
+    {
+        return kind_ == Kind::kString ? string_ : EmptyString();
+    }
+
+    const std::vector<JsonValue> &
+    JsonValue::Items() const noexcept
+    {
+        return kind_ == Kind::kArray && items_ ? *items_ : EmptyItems();
+    }
+
+    std::vector<JsonValue> &
+    JsonValue::MutableItems()
+    {
+        if (kind_ != Kind::kArray || !items_)
+        {
+            *this = Array();
+        }
+        return *items_;
+    }
+
+    const JsonMembers &
+    JsonValue::Members() const noexcept
+    {
+        return kind_ == Kind::kObject && members_ ? *members_ : EmptyMembers();
+    }
+
+    JsonMembers &
+    JsonValue::MutableMembers()
+    {
+        if (kind_ != Kind::kObject || !members_)
+        {
+            *this = Object();
+        }
+        return *members_;
+    }
+
+    const JsonValue &
+    JsonValue::operator[](std::string_view key) const noexcept
+    {
+        for (const auto &[name, value] : Members())
+        {
+            if (name == key)
+            {
+                return value;
+            }
+        }
+        return NullValue();
+    }
+
+    JsonValue &
+    JsonValue::Set(std::string_view key, JsonValue value)
+    {
+        auto &members = MutableMembers();
+        for (auto &[name, existing] : members)
+        {
+            if (name == key)
+            {
+                existing = std::move(value);
+                return existing;
+            }
+        }
+        members.emplace_back(std::string{key}, std::move(value));
+        return members.back().second;
+    }
+
+    void
+    JsonValue::Append(JsonValue value)
+    {
+        MutableItems().push_back(std::move(value));
+    }
+
+    std::string
+    JsonValue::ToString() const
+    {
+        std::string output;
+        Write(output, 0, 0);
+        return output;
+    }
+
+    std::string
+    JsonValue::ToPrettyString() const
+    {
+        std::string output;
+        Write(output, 2, 0);
+        output.push_back('\n');
+        return output;
+    }
+
+    void
+    JsonValue::Write(std::string &output, int indent, int depth) const
+    {
+        switch (kind_)
+        {
+            case Kind::kNull:
+                output += "null";
+                return;
+            case Kind::kBoolean:
+                output += boolean_ ? "true" : "false";
+                return;
+            case Kind::kNumber:
+                AppendNumber(output, number_);
+                return;
+            case Kind::kString:
+                AppendJsonString(output, string_);
+                return;
+            case Kind::kArray:
+            {
+                const auto &items = Items();
+                output.push_back('[');
+                for (std::size_t index = 0; index < items.size(); ++index)
+                {
+                    if (index > 0)
+                    {
+                        output.push_back(',');
+                    }
+                    AppendIndent(output, indent, depth + 1);
+                    items[index].Write(output, indent, depth + 1);
+                }
+                if (!items.empty())
+                {
+                    AppendIndent(output, indent, depth);
+                }
+                output.push_back(']');
+                return;
+            }
+            case Kind::kObject:
+            {
+                const auto &members = Members();
+                output.push_back('{');
+                for (std::size_t index = 0; index < members.size(); ++index)
+                {
+                    if (index > 0)
+                    {
+                        output.push_back(',');
+                    }
+                    AppendIndent(output, indent, depth + 1);
+                    AppendJsonString(output, members[index].first);
+                    output += indent > 0 ? ": " : ":";
+                    members[index].second.Write(output, indent, depth + 1);
+                }
+                if (!members.empty())
+                {
+                    AppendIndent(output, indent, depth);
+                }
+                output.push_back('}');
+                return;
+            }
+        }
+    }
+
+    Expected<JsonValue>
+    ParseJson(std::string_view text)
+    {
+        return Parser{text}.ParseDocument();
+    }
+
+    void
+    AppendJsonString(std::string &output, std::string_view text)
+    {
+        output.push_back('"');
+        for (const char character : text)
+        {
+            switch (character)
+            {
+                case '"':
+                    output += "\\\"";
+                    break;
+                case '\\':
+                    output += "\\\\";
+                    break;
+                case '\n':
+                    output += "\\n";
+                    break;
+                case '\r':
+                    output += "\\r";
+                    break;
+                case '\t':
+                    output += "\\t";
+                    break;
+                case '\b':
+                    output += "\\b";
+                    break;
+                case '\f':
+                    output += "\\f";
+                    break;
+                default:
+                    if (static_cast<unsigned char>(character) < 0x20)
+                    {
+                        char buffer[8];
+                        std::snprintf(buffer,
+                                      sizeof(buffer),
+                                      "\\u%04x",
+                                      static_cast<unsigned>(character));
+                        output += buffer;
+                    }
+                    else
+                    {
+                        output.push_back(character);
+                    }
+            }
+        }
+        output.push_back('"');
+    }
+} // namespace Progmasoft::Catch3::Runner