gtest.h

#pragma once

 
#include <gtest/gtest-spi.h>
#include <gtest/gtest.h>
 
#include "hegel.h"
 
#include <functional>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace hegel {

    class GTestFailure : public std::runtime_error, public FailureOrigin {
      public:
        GTestFailure(std::string origin, const std::string& message)
            : std::runtime_error(message), origin_(std::move(origin)) {}

        std::string failure_origin() const override { return origin_; }
 
      private:
        std::string origin_;
    };

    namespace internal {
        namespace gtest_hooks {
 
            // "Suite.Name" of the GoogleTest test that runs now.
            inline std::string current_test_name() {
                const testing::TestInfo* info =
                    testing::UnitTest::GetInstance()->current_test_info();
                if (info == nullptr) {
                    return {};
                }
                return std::string(info->test_suite_name()) + "." +
                       info->name();
            }
 
            // Where one failed assertion is written, or "<unknown>" for an
            // assertion GoogleTest could not place.
            inline std::string position(const testing::TestPartResult& part) {
                if (part.file_name() == nullptr) {
                    return "<unknown>";
                }
                return std::string(part.file_name()) + ":" +
                       std::to_string(part.line_number());
            }
 
            struct Failures {
                std::string message;
                std::string origin;
            };
 
            inline void
            raise_failures(const testing::TestPartResultArray& recorded) {
                Failures out;
                for (int i = 0; i < recorded.size(); i++) {
                    const testing::TestPartResult& part =
                        recorded.GetTestPartResult(i);
                    if (!part.failed()) {
                        continue;
                    }
                    if (!out.message.empty()) {
                        out.message += "\n";
                        out.origin += ", ";
                    }
                    out.message += position(part) + ": " + part.message();
                    out.origin += position(part);
                }
 
                if (!out.message.empty()) {
                    throw GTestFailure("hegel::GTestFailure at " + out.origin,
                                       out.message);
                }
            }
 
            // Thrown when an assertion fails fatally.
            struct FatalFailure {};
 
            // Records the assertions of one test case. Without this, ASSERT_*
            // returns only from the function it is in and the test case
            // continues.
            class Reporter : public testing::ScopedFakeTestPartResultReporter {
              public:
                explicit Reporter(testing::TestPartResultArray* recorded)
                    : ScopedFakeTestPartResultReporter(
                          INTERCEPT_ONLY_CURRENT_THREAD, recorded) {}
 
                void ReportTestPartResult(
                    // override makes ASSERT_* instantly throw
                    const testing::TestPartResult& result) override {
                    ScopedFakeTestPartResultReporter::ReportTestPartResult(
                        result);
                    if (result.fatally_failed()) {
                        throw FatalFailure{};
                    }
                }
            };
 
            // Runs one test-case body and collects GoogleTest assertions, then
            // raises them as one exception. A fatal failure stops the body
            // immediately.
            inline void run_case(const std::function<void()>& body) {
                testing::TestPartResultArray recorded;
                {
                    // Outside a GoogleTest test, no assertion is recorded.
                    std::optional<Reporter> reporter;
                    if (testing::UnitTest::GetInstance()->current_test_info() !=
                        nullptr) {
                        reporter.emplace(&recorded);
                    }
                    try {
                        body();
                        // NOLINTNEXTLINE(bugprone-empty-catch)
                    } catch (const FatalFailure&) {
                        // The failure is in recorded. Continue to
                        // raise_failures below.
                    }
                }
                raise_failures(recorded);
            }
 
        } // namespace gtest_hooks
 
        [[maybe_unused]] static const bool hegel_gtest_hooks_installed =
            install_framework_hooks(
                {&gtest_hooks::current_test_name, &gtest_hooks::run_case});
    } // namespace internal
 
} // namespace hegel