TestAssertList.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/SourceLocation.hpp"
#include "shambase/string.hpp"
#include "TestAssert.hpp"
#include "shambackends/sycl.hpp"
#include <utility>
 
namespace shamtest::details {

    struct TestAssertList {

        std::vector<TestAssert> asserts;
 
        // define member function here
        // to register asserts
 
        inline void assert_bool_with_log(std::string assert_name, bool v, std::string log) {
            asserts.push_back(
                TestAssert{.value = v, .name = std::move(assert_name), .comment = std::move(log)});
        }

        inline static std::string gen_comment(std::string s, SourceLocation loc) {
            return s + "\n" + loc.format_multiline();
        }

        [[deprecated("Please use the supplied testing macros instead")]]
        inline void assert_bool(
            std::string assert_name, bool v, SourceLocation loc = SourceLocation{}) {
 
            asserts.push_back(
                TestAssert{
                    .value   = v,
                    .name    = std::move(assert_name),
                    .comment = "failed assert location : " + loc.format_one_line()});
        }

        template<class T1, class T2>
        [[deprecated("Please use the supplied testing macros instead")]]
        inline void assert_equal(
            std::string assert_name, T1 a, T2 b, SourceLocation loc = SourceLocation{}) {
 
            bool t              = a == b;
            std::string comment = "";
 
            if (!t) {
                comment = "left=" + std::to_string(a) + " right=" + std::to_string(b);
            }
 
            asserts.push_back(
                TestAssert{
                    .value   = t,
                    .name    = std::move(assert_name),
                    .comment = gen_comment(comment, loc)});
        }

        template<class Acca, class Accb>
        [[deprecated("Please use the supplied testing macros instead")]]
        inline void assert_equal_array(
            std::string assert_name,
            Acca &acc_a,
            Accb &acc_b,
            u32 len,
            SourceLocation loc = SourceLocation{}) {
 
            bool t              = true;
            std::string comment = "";
 
            for (u32 i = 0; i < len; i++) {
                t = t && (acc_a[i] == acc_b[i]);
            }
 
            if (!t) {
                comment += "left : \n";
                comment += shambase::format_array(acc_a, len, 16, "{} ");
                comment += "right : \n";
                comment += shambase::format_array(acc_b, len, 16, "{} ");
            }
 
            asserts.push_back(
                TestAssert{
                    .value   = t,
                    .name    = std::move(assert_name),
                    .comment = gen_comment(comment, loc)});
        }

        [[deprecated("Please use the supplied testing macros instead")]]
        inline void assert_float_equal(
            std::string assert_name, f64 a, f64 b, f64 eps, SourceLocation loc = SourceLocation{}) {
            f64 diff = sycl::fabs(a - b);
 
            bool t              = diff < eps;
            std::string comment = "";
 
            if (!t) {
                comment = "left=" + std::to_string(a) + " right=" + std::to_string(b)
                          + " diff=" + std::to_string(diff);
            }
 
            asserts.push_back(
                TestAssert{
                    .value   = t,
                    .name    = std::move(assert_name),
                    .comment = gen_comment(comment, loc)});
        }

        inline void assert_add_comment(
            std::string assert_name,
            bool v,
            std::string comment,
            SourceLocation loc = SourceLocation{}) {
            asserts.push_back(
                TestAssert{
                    .value   = v,
                    .name    = std::move(assert_name),
                    .comment = gen_comment(std::move(comment), loc)});
        }

        std::string serialize_json();
        void serialize(std::basic_stringstream<byte> &stream);
        static TestAssertList deserialize(std::basic_stringstream<byte> &reader);

        inline u32 get_assert_count() { return asserts.size(); }

        inline u32 get_assert_success_count() {
            u32 cnt = 0;
            for (TestAssert &a : asserts) {
                if (a.value) {
                    cnt++;
                }
            }
            return cnt;
        }
    };
} // namespace shamtest::details