shamtest.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/unique_name_macro.hpp"
#include "details/Test.hpp"

namespace shamtest {

    namespace details {

        inline std::vector<Test> static_init_vec_tests{};

        struct TestStaticInit {

            inline explicit TestStaticInit(Test t) {
                static_init_vec_tests.push_back(std::move(t));
            }
        };

        extern TestResult current_test;
 
    } // namespace details

    struct TestConfig {

        bool print_test_list_exit = false;

        bool full_output = false;

        bool output_tex = true;

        std::optional<std::string> json_output = {};
 
        bool run_long_tests = false; 
        bool run_unittest   = true;  
        bool run_validation = true;  
        bool run_benchmark  = false; 
 
        std::optional<std::string> run_only = {}; 
    };

    int run_all_tests(int argc, char *argv[], TestConfig cfg);

    void gen_test_list(std::string_view outfile);

    inline shamtest::details::TestAssertList &asserts() {
        return shamtest::details::current_test.asserts;
    };

    inline shamtest::details::TestDataList &test_data() {
        return shamtest::details::current_test.test_data;
    };

    inline std::string &test_tex_out() { return shamtest::details::current_test.tex_output; }
 
} // namespace shamtest
 
#define ANY_WORLD_SIZE -1
 
#define _internal_new_test(type, name, func_name, func_ptr, class_name, node_cnt)                  \
    static void func_name();                                                                       \
    static void (*func_ptr)() = func_name;                                                         \
    static shamtest::details::TestStaticInit class_name(                                           \
        shamtest::details::Test{type, name, node_cnt, func_ptr});                                  \
    static void func_name()

#define NEW_TEST(type, name, node_cnt)                                                             \
    _internal_new_test(                                                                            \
        type,                                                                                      \
        name,                                                                                      \
        __shamrock_unique_name(test_func_),                                                        \
        __shamrock_unique_name(test_func_ptr_),                                                    \
        __shamrock_unique_name(test_class_),                                                       \
        node_cnt)

#define TEX_REPORT(src) shamtest::details::current_test.tex_output += src;
 
#define STDSTRINGIFY(x) std::string(#x)

// Assert macros
 
// Note : the do-while are here to enforce the presence of a semicolumn after the call to the macros
 
namespace shamtest::details {
     * Otherwise, returns the string with " | " appended
     */
    inline std::string format_assert_name(std::string s) {
        if (s == "") {
            return "";
        }
        return "\"" + s + "\" : ";
    }
} // namespace shamtest::details

 * \endcode
 */
#define REQUIRE_NAMED(name, a)                                                                     \
    do {                                                                                           \
        using namespace shamtest::details;                                                         \
        bool eval               = a;                                                               \
        std::string assert_name = format_assert_name(name) + #a;                                   \
        if (eval) {                                                                                \
            shamtest::asserts().assert_bool_with_log(assert_name, eval, "");                       \
        } else {                                                                                   \
            shamtest::asserts().assert_bool_with_log(                                              \
                assert_name,                                                                       \
                eval,                                                                              \
                STDSTRINGIFY(a) + " evaluated to false\n\n"                                        \
                    + " -> location : " + SourceLocation{}.format_one_line());                     \
        }                                                                                          \
    } while (0)

 * \endcode
 */
#define REQUIRE_EQUAL_CUSTOM_COMP_NAMED(name, _a, _b, comp)                                        \
    do {                                                                                           \
        auto _______a = _a;                                                                        \
        auto _______b = _b;                                                                        \
        using namespace shamtest::details;                                                         \
        bool eval               = comp(_______a, _______b);                                        \
        std::string assert_name = format_assert_name(name) + #_a " == " #_b;                       \
        if (eval) {                                                                                \
            shamtest::asserts().assert_bool_with_log(assert_name, eval, "");                       \
        } else {                                                                                   \
            shamtest::asserts().assert_bool_with_log(                                              \
                assert_name,                                                                       \
                eval,                                                                              \
                assert_name + " evaluated to false\n\n" + " -> " #_a                               \
                    + shambase::format(" = {}", _______a) + "\n" + " -> " #_b                      \
                    + shambase::format(" = {}", _______b) + "\n"                                   \
                    + " -> location : " + SourceLocation{}.format_one_line());                     \
        }                                                                                          \
    } while (0)

 * \endcode
 */
#define REQUIRE_EQUAL_NAMED(name, a, b)                                                            \
    REQUIRE_EQUAL_CUSTOM_COMP_NAMED(name, a, b, [](const auto &p1, const auto &p2) {               \
        return p1 == p2;                                                                           \
    })

 * \endcode
 */
#define REQUIRE_FLOAT_EQUAL_CUSTOM_DIST_NAMED(name, _a, _b, prec, dist)                            \
    do {                                                                                           \
        auto a = _a;                                                                               \
        auto b = _b;                                                                               \
        using namespace shamtest::details;                                                         \
        bool eval = dist((a) - (b)) < prec;                                                        \
        std::string assert_name                                                                    \
            = format_assert_name(name) + #dist "(" #_a ") - (" #_b ") < " #prec;                   \
        if (eval) {                                                                                \
            shamtest::asserts().assert_bool_with_log(assert_name, eval, "");                       \
        } else {                                                                                   \
            shamtest::asserts().assert_bool_with_log(                                              \
                assert_name,                                                                       \
                eval,                                                                              \
                assert_name + " evaluated to false\n\n" + shambase::format(" -> " #_a " = {}", a)  \
                    + "\n" + shambase::format(" -> " #_b " = {}", b) + "\n"                        \
                    + shambase::format(" -> " #prec " = {}", prec) + "\n"                          \
                    + " -> location : " + SourceLocation{}.format_one_line());                     \
        }                                                                                          \
    } while (0)

 * \endcode
 */
#define REQUIRE_FLOAT_EQUAL_NAMED(name, a, b, prec)                                                \
    REQUIRE_FLOAT_EQUAL_CUSTOM_DIST_NAMED(name, a, b, prec, std::abs)

#define REQUIRE(a) REQUIRE_NAMED("", a)

#define REQUIRE_EQUAL_CUSTOM_COMP(a, b, comp) REQUIRE_EQUAL_CUSTOM_COMP_NAMED("", a, b, comp)

#define REQUIRE_EQUAL(a, b) REQUIRE_EQUAL_NAMED("", a, b)

 * \endcode
 */
#define REQUIRE_FLOAT_EQUAL_CUSTOM_DIST(name, a, b, prec, dist)                                    \
    REQUIRE_FLOAT_EQUAL_CUSTOM_DIST_NAMED("", a, b, prec, dist)

 * \endcode
 */
#define REQUIRE_FLOAT_EQUAL(a, b, prec)                                                            \
    REQUIRE_FLOAT_EQUAL_CUSTOM_DIST_NAMED("", a, b, prec, std::abs)

 * @param exception_type Exception type that is expected to be thrown
 */
#define REQUIRE_EXCEPTION_THROW(call, exception_type)                                              \
    do {                                                                                           \
        try {                                                                                      \
            /* Try to call the function that is expected to throw */                               \
            call;                                                                                  \
            /* If no exception is thrown, assert that the test failed */                           \
            shamtest::asserts().assert_bool_with_log(                                              \
                #exception_type " was not thrown",                                                 \
                false,                                                                             \
                "Expected throw of type " #exception_type ", but nothing was thrown\n"             \
                " -> location : "                                                                  \
                    + SourceLocation{}.format_one_line());                                         \
        } catch (const exception_type &ex) {                                                       \
            /* If wanted exception is thrown, assert that the test pass */                         \
            shamtest::asserts().assert_bool_with_log(                                              \
                "Found wanted throw of type " #exception_type, true, "");                          \
        } catch (const std::exception &e) {                                                        \
            /* If another exception type is thrown, assert that the test failed */                 \
            shamtest::asserts().assert_bool_with_log(                                              \
                #exception_type " was not thrown",                                                 \
                false,                                                                             \
                "Expected throw of type " #exception_type ", but got " + std::string(e.what())     \
                    + "\n" + " -> location : " + SourceLocation{}.format_one_line());              \
        } catch (...) {                                                                            \
            /* If an unknown exception is thrown, assert that the test failed */                   \
            shamtest::asserts().assert_bool_with_log(                                              \
                #exception_type " was not thrown",                                                 \
                false,                                                                             \
                "Expected throw of type " #exception_type ", but got unknown exception\n"          \
                " -> location : "                                                                  \
                    + SourceLocation{}.format_one_line());                                         \
        }                                                                                          \
    } while (0)