gtest.h

#pragma once

 
#include <gtest/gtest-spi.h>
#include <gtest/gtest.h>
 
#include "hegel.h"
 
#include <functional>
#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 Failures
            collect_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);
                }
                return out;
            }
 
            // Runs one test-case body and collects GoogleTest assertions, then
            // raises them as one exception.
            inline void run_case(const std::function<void()>& body) {
                if (testing::UnitTest::GetInstance()->current_test_info() ==
                    nullptr) {
                    body();
                    return;
                }
                testing::TestPartResultArray recorded;
                {
                    testing::ScopedFakeTestPartResultReporter reporter(
                        testing::ScopedFakeTestPartResultReporter::
                            INTERCEPT_ONLY_CURRENT_THREAD,
                        &recorded);
                    body();
                }
                Failures failures = collect_failures(recorded);
                if (!failures.message.empty()) {
                    throw GTestFailure("hegel::GTestFailure at " +
                                           failures.origin,
                                       failures.message);
                }
            }
 
        } // 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