settings.h

#pragma once
 
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <optional>
#include <string>
#include <vector>
 
namespace hegel {
    enum class Verbosity {
        Quiet,   
        Normal,  
        Verbose, 
        Debug    
    };

    inline const char* verbosity_to_string(Verbosity v) {
        switch (v) {
        case Verbosity::Quiet:
            return "quiet";
        case Verbosity::Verbose:
            return "verbose";
        case Verbosity::Debug:
            return "debug";
        case Verbosity::Normal:
        default:
            return "normal";
        }
    }

    enum class HealthCheck {
        FilterTooMuch,        
        TooSlow,              
        TestCasesTooLarge,    
        LargeInitialTestCase, 
    };

    inline const char* health_check_to_string(HealthCheck c) {
        switch (c) {
        case HealthCheck::FilterTooMuch:
            return "filter_too_much";
        case HealthCheck::TooSlow:
            return "too_slow";
        case HealthCheck::TestCasesTooLarge:
            return "test_cases_too_large";
        case HealthCheck::LargeInitialTestCase:
            return "large_initial_test_case";
        }
        return "";
    }

    inline std::vector<HealthCheck> all_health_checks() {
        return {HealthCheck::FilterTooMuch, HealthCheck::TooSlow,
                HealthCheck::TestCasesTooLarge,
                HealthCheck::LargeInitialTestCase};
    }

    enum class Phase {
        Explicit, 
        Reuse,    
        Generate, 
        Target,   
        Shrink,   
    };

    inline std::vector<Phase> all_phases() {
        return {Phase::Explicit, Phase::Reuse, Phase::Generate, Phase::Target,
                Phase::Shrink};
    }

    enum class Mode {
        TestRun,        
        SingleTestCase, 
    };

    enum class Backend {
        Auto,    
        Default, 
        Urandom, 
    };

    class Database {
      public:
        enum class Kind {
            Unset, 
            Disabled, 
            Path,     
        };

        static Database unset() { return {Kind::Unset, {}}; }

        static Database disabled() { return {Kind::Disabled, {}}; }

        static Database from_path(std::string path) {
            return {Kind::Path, std::move(path)};
        }

        Kind kind() const { return kind_; }
        const std::string& path() const { return path_; }
 
      private:
        Database(Kind k, std::string p) : kind_(k), path_(std::move(p)) {}
        Kind kind_;
        std::string path_;
    };

    namespace internal {
        // True if a CI environment is detected, by probing the variables the
        // common CI providers set. Used as the default for
        // Settings::derandomize so runs are reproducible under CI.
        inline bool in_ci() {
            // expected == nullptr means "any value present satisfies it".
            struct CiVar {
                const char* name;
                const char* expected;
            };
            static constexpr CiVar ci_vars[] = {
                {"CI", nullptr},
                {"TF_BUILD", "true"},
                {"BUILDKITE", "true"},
                {"CIRCLECI", "true"},
                {"CIRRUS_CI", "true"},
                {"CODEBUILD_BUILD_ID", nullptr},
                {"GITHUB_ACTIONS", "true"},
                {"GITLAB_CI", nullptr},
                {"HEROKU_TEST_RUN_ID", nullptr},
                {"TEAMCITY_VERSION", nullptr},
            };
            for (const CiVar& v : ci_vars) {
                const char* value = std::getenv(v.name);
                if (value == nullptr) {
                    continue;
                }
                if (v.expected == nullptr ||
                    std::strcmp(value, v.expected) == 0) {
                    return true;
                }
            }
            return false;
        }
    } // namespace internal

    struct Settings {
        std::optional<uint64_t> test_cases;

        Verbosity verbosity = Verbosity::Normal;

        std::optional<uint64_t> seed;

        bool derandomize = internal::in_ci();

        bool report_multiple_failures = false;

        bool print_blob = true;

        Database database =
            internal::in_ci() ? Database::disabled() : Database::unset();

        std::optional<std::string> database_key;

        std::vector<HealthCheck> suppress_health_check;

        std::vector<Phase> phases = all_phases();

        Mode mode = Mode::TestRun;

        Backend backend = Backend::Auto;

        int64_t stateful_step_count = 50;
    };
} // namespace hegel