hegel.h

#pragma once

 
#include "core.h"
#include "settings.h"
#include "test_case.h"
 
#include "generators/builds.h"
#include "generators/collections.h"
#include "generators/combinators.h"
#include "generators/default.h"
#include "generators/formats.h"
#include "generators/numeric.h"
#include "generators/primitives.h"
#include "generators/random.h"
#include "generators/stateful.h"
#include "generators/strings.h"
 
#include <functional>
 
#if defined(__GNUC__) || defined(__clang__) ||                                 \
    (defined(_MSC_VER) && _MSC_VER >= 1927)
#define HEGEL_CALLER_FILE __builtin_FILE()
#define HEGEL_CALLER_FUNCTION __builtin_FUNCTION()
#define HEGEL_CALLER_LINE __builtin_LINE()
#else
#define HEGEL_CALLER_FILE ""
#define HEGEL_CALLER_FUNCTION ""
#define HEGEL_CALLER_LINE 0
#endif

namespace hegel {

    class FailureOrigin {
      public:
        FailureOrigin() = default;
        virtual ~FailureOrigin() = default;
        FailureOrigin(const FailureOrigin&) = default;
        FailureOrigin& operator=(const FailureOrigin&) = default;

        virtual std::string failure_origin() const = 0;
    };

    struct TestLocation {
        std::string name;
        std::string file;
        int line = 0;
    };

    void test(const std::function<void(TestCase&)>& test_fn,
              const Settings& settings = {},
              const std::vector<std::string>& failure_blobs = {},
              const char* caller_file = HEGEL_CALLER_FILE,
              const char* caller_function = HEGEL_CALLER_FUNCTION,
              int caller_line = HEGEL_CALLER_LINE);

    void test(const std::function<void(TestCase&)>& test_fn,
              const TestLocation& location, const Settings& settings = {},
              const std::vector<std::string>& failure_blobs = {});

    namespace internal {
        // How a test framework passes information to Hegel
        struct FrameworkHooks {
            // Names the framework test that runs now, or "" outside one.
            std::string (*current_test_name)() = nullptr;
            // Runs one test-case body, raising the failed assertions the
            // framework recorded.
            void (*run_case)(const std::function<void()>&) = nullptr;
        };
 
        // Makes `hooks` the integration every later run uses. Returns true, so
        // an integration header can install from a variable initializer and
        // have it happen before main().
        bool install_framework_hooks(const FrameworkHooks& hooks);
 
        // add a blob for a test to run
        bool register_blob(const char* name, std::vector<const char*> blobs);
        // look up the failure blobs associated with a test
        std::vector<std::string> reproduce_blobs_for(const char* name);
 
        // What HEGEL_TEST expands to.
        void test_from_macro(const std::function<void(TestCase&)>& test_fn,
                             const TestLocation& location,
                             const Settings& settings,
                             const std::vector<std::string>& failure_blobs);
    } // namespace internal
} // namespace hegel


#define HEGEL_TEST(name, ...)                                                  \
    static void hegel_test_body_##name(::hegel::TestCase&);                    \
    static void name(::hegel::Settings settings =                              \
                         ::hegel::Settings(__VA_ARGS__)) {                     \
        if (!settings.database_key.has_value()) {                              \
            settings.database_key = __FILE__ "::" #name;                       \
        }                                                                      \
        ::hegel::internal::test_from_macro(                                    \
            hegel_test_body_##name,                                            \
            ::hegel::TestLocation{#name, __FILE__, __LINE__}, settings,        \
            ::hegel::internal::reproduce_blobs_for(__FILE__ "::" #name));      \
    }                                                                          \
    static void hegel_test_body_##name

#define HEGEL_REPRODUCE_FAILURE(name, blob, ...)                               \
    [[maybe_unused]] static const bool hegel_reproduce_registered_##name =     \
        ::hegel::internal::register_blob(__FILE__ "::" #name,                  \
                                         {blob, __VA_ARGS__});

 
// GoogleTest integration, picked up when <gtest/gtest.h> is already visible.
// Include <hegel/gtest.h> yourself if this header comes first.
#if defined(GTEST_TEST)
#include "gtest.h"
#endif