#ifndef DOCTEST_PARTS_PUBLIC_ASSERT_TYPE
#define DOCTEST_PARTS_PUBLIC_ASSERT_TYPE

#include "doctest/parts/public/config.h"

DOCTEST_SUPPRESS_PUBLIC_WARNINGS_PUSH

namespace doctest {
namespace assertType {
enum Enum {
    // macro traits

    is_warn = 1,
    is_check = 2 * is_warn,
    is_require = 2 * is_check,

    is_normal = 2 * is_require,
    is_throws = 2 * is_normal,
    is_throws_as = 2 * is_throws,
    is_throws_with = 2 * is_throws_as,
    is_nothrow = 2 * is_throws_with,

    is_false = 2 * is_nothrow,
    is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types

    is_eq = 2 * is_unary,
    is_ne = 2 * is_eq,

    is_lt = 2 * is_ne,
    is_gt = 2 * is_lt,

    is_ge = 2 * is_gt,
    is_le = 2 * is_ge,

    // macro types

    DT_WARN = is_normal | is_warn,
    DT_CHECK = is_normal | is_check,
    DT_REQUIRE = is_normal | is_require,

    DT_WARN_FALSE = is_normal | is_false | is_warn,
    DT_CHECK_FALSE = is_normal | is_false | is_check,
    DT_REQUIRE_FALSE = is_normal | is_false | is_require,

    DT_WARN_THROWS = is_throws | is_warn,
    DT_CHECK_THROWS = is_throws | is_check,
    DT_REQUIRE_THROWS = is_throws | is_require,

    DT_WARN_THROWS_AS = is_throws_as | is_warn,
    DT_CHECK_THROWS_AS = is_throws_as | is_check,
    DT_REQUIRE_THROWS_AS = is_throws_as | is_require,

    DT_WARN_THROWS_WITH = is_throws_with | is_warn,
    DT_CHECK_THROWS_WITH = is_throws_with | is_check,
    DT_REQUIRE_THROWS_WITH = is_throws_with | is_require,

    DT_WARN_THROWS_WITH_AS = is_throws_with | is_throws_as | is_warn,
    DT_CHECK_THROWS_WITH_AS = is_throws_with | is_throws_as | is_check,
    DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require,

    DT_WARN_NOTHROW = is_nothrow | is_warn,
    DT_CHECK_NOTHROW = is_nothrow | is_check,
    DT_REQUIRE_NOTHROW = is_nothrow | is_require,

    DT_WARN_EQ = is_normal | is_eq | is_warn,
    DT_CHECK_EQ = is_normal | is_eq | is_check,
    DT_REQUIRE_EQ = is_normal | is_eq | is_require,

    DT_WARN_NE = is_normal | is_ne | is_warn,
    DT_CHECK_NE = is_normal | is_ne | is_check,
    DT_REQUIRE_NE = is_normal | is_ne | is_require,

    DT_WARN_GT = is_normal | is_gt | is_warn,
    DT_CHECK_GT = is_normal | is_gt | is_check,
    DT_REQUIRE_GT = is_normal | is_gt | is_require,

    DT_WARN_LT = is_normal | is_lt | is_warn,
    DT_CHECK_LT = is_normal | is_lt | is_check,
    DT_REQUIRE_LT = is_normal | is_lt | is_require,

    DT_WARN_GE = is_normal | is_ge | is_warn,
    DT_CHECK_GE = is_normal | is_ge | is_check,
    DT_REQUIRE_GE = is_normal | is_ge | is_require,

    DT_WARN_LE = is_normal | is_le | is_warn,
    DT_CHECK_LE = is_normal | is_le | is_check,
    DT_REQUIRE_LE = is_normal | is_le | is_require,

    DT_WARN_UNARY = is_normal | is_unary | is_warn,
    DT_CHECK_UNARY = is_normal | is_unary | is_check,
    DT_REQUIRE_UNARY = is_normal | is_unary | is_require,

    DT_WARN_UNARY_FALSE = is_normal | is_false | is_unary | is_warn,
    DT_CHECK_UNARY_FALSE = is_normal | is_false | is_unary | is_check,
    DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require,
};
} // namespace assertType

DOCTEST_INTERFACE const char *assertString(assertType::Enum at);
DOCTEST_INTERFACE const char *failureString(assertType::Enum at);

} // namespace doctest

DOCTEST_SUPPRESS_PUBLIC_WARNINGS_POP

#endif // DOCTEST_PARTS_PUBLIC_ASSERT_TYPE
