detail.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can be
 * obtained from https://opensource.org/licenses/mit.
 *
 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
 * released under the terms of the Boost Version 1.0 Software License,
 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_TEST_PLUS_DETAIL_H_
#define MICRO_TEST_PLUS_DETAIL_H_
 
// ----------------------------------------------------------------------------
 
#ifdef __cplusplus
 
// ----------------------------------------------------------------------------
 
#include <stdio.h>
#include <string>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpadded"
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
#endif
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  namespace detail
  {
    template <class Expr_T>
    struct assertion
    {
      Expr_T expr{};

      reflection::source_location location{};
    };
 
    // ------------------------------------------------------------------------
 
    // in C++14/17/20, a function template with a deduced return type
    // (auto) cannot be used before its definition is visible.
    // Therefore it is not possible to split definitions.

    template <class T>
    [[nodiscard]] constexpr auto
    get_impl (const T& t, int) -> decltype (t.get ())
    {
      return t.get ();
    }

    template <class T>
    [[nodiscard]] constexpr auto
    get_impl (const T& t, ...) -> decltype (auto)
    {
      return t;
    }

    template <class T>
    [[nodiscard]] constexpr auto
    get (const T& t)
    {
      // Call the variadic function, basically to force it return `t`.
      return get_impl<T> (t, 0);
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct eq_ : type_traits::op
    {
      constexpr eq_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs }, value_{
              [&]
                {
                  // This lambda is called in the constructor to
                  // evaluate the comparison.
                  using std::operator==;
                  using std::operator<;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                  if constexpr (type_traits::has_value_v<Lhs_T>
                                and type_traits::has_value_v<Rhs_T>)
                    {
                      // If both types have values (like numeric constants),
                      // compare them directly.
                      return Lhs_T::value == Rhs_T::value;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
                                     and type_traits::has_epsilon_v<Rhs_T>)
                    {
                      // If both values have precision, compare them using
                      // the smalles precision.
                      return math::abs (get (lhs) - get (rhs))
                             < math::min_value (Lhs_T::epsilon,
                                                Rhs_T::epsilon);
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
                    {
                      // If only the left operand has precision, use it.
                      return math::abs (get (lhs) - get (rhs))
                             < Lhs_T::epsilon;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
                    {
                      // If only the right operand has precision, use it.
                      return math::abs (get (lhs) - get (rhs))
                             < Rhs_T::epsilon;
                    }
                  else
                    {
                      // Call the generic getters, which might
                      // either call the type get() or return the value.
                      return get (lhs) == get (rhs);
                    }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                }()
            }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    eq_ (const Lhs_T&, const Rhs_T&) -> eq_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct ne_ : type_traits::op
    {
      constexpr ne_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs }, value_{
              [&]
                {
                  using std::operator==;
                  using std::operator!=;
                  using std::operator>;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                  if constexpr (type_traits::has_value_v<Lhs_T>
                                and type_traits::has_value_v<Rhs_T>)
                    {
                      return Lhs_T::value != Rhs_T::value;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>
                                     and type_traits::has_epsilon_v<Rhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > math::min_value (Lhs_T::epsilon,
                                                Rhs_T::epsilon);
                    }
                  else if constexpr (type_traits::has_epsilon_v<Lhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > Lhs_T::epsilon;
                    }
                  else if constexpr (type_traits::has_epsilon_v<Rhs_T>)
                    {
                      return math::abs (get (lhs_) - get (rhs_))
                             > Rhs_T::epsilon;
                    }
                  else
                    {
                      return get (lhs_) != get (rhs_);
                    }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                }()
            }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    ne_ (const Lhs_T&, const Rhs_T&) -> ne_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct gt_ : type_traits::op
    {
      constexpr gt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ [&]
                      {
                        using std::operator>;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                        if constexpr (type_traits::has_value_v<Lhs_T>
                                      and type_traits::has_value_v<Rhs_T>)
                          {
                            return Lhs_T::value > Rhs_T::value;
                          }
                        else
                          {
                            return get (lhs_) > get (rhs_);
                          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }
      [[nodiscard]] constexpr auto

      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    gt_ (const Lhs_T&, const Rhs_T&) -> gt_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct ge_ : type_traits::op
    {
      constexpr ge_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ [&]
                      {
                        using std::operator>=;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                        if constexpr (type_traits::has_value_v<Lhs_T>
                                      and type_traits::has_value_v<Rhs_T>)
                          {
                            return Lhs_T::value >= Rhs_T::value;
                          }
                        else
                          {
                            return get (lhs_) >= get (rhs_);
                          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    ge_ (const Lhs_T&, const Rhs_T&) -> ge_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct lt_ : type_traits::op
    {
      constexpr lt_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ [&]
                      {
                        using std::operator<;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                        if constexpr (type_traits::has_value_v<Lhs_T>
                                      and type_traits::has_value_v<Rhs_T>)
                          {
                            return Lhs_T::value < Rhs_T::value;
                          }
                        else
                          {
                            return get (lhs_) < get (rhs_);
                          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }
 
    private:
      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    lt_ (const Lhs_T&, const Rhs_T&) -> lt_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct le_ : type_traits::op
    {
      constexpr le_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ [&]
                      {
                        using std::operator<=;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#pragma GCC diagnostic ignored "-Wsign-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"
#pragma clang diagnostic ignored "-Wpedantic"
#endif
#endif
                        if constexpr (type_traits::has_value_v<Lhs_T>
                                      and type_traits::has_value_v<Rhs_T>)
                          {
                            return Lhs_T::value <= Rhs_T::value;
                          }
                        else
                          {
                            return get (lhs_) <= get (rhs_);
                          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

 
      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    le_ (const Lhs_T&, const Rhs_T&) -> le_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct and_ : type_traits::op
    {
      constexpr and_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ static_cast<bool> (lhs) and static_cast<bool> (rhs) }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    and_ (const Lhs_T&, const Rhs_T&) -> and_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    struct or_ : type_traits::op
    {
      constexpr or_ (const Lhs_T& lhs = {}, const Rhs_T& rhs = {})
          : lhs_{ lhs }, rhs_{ rhs },
            value_{ static_cast<bool> (lhs) or static_cast<bool> (rhs) }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      lhs (void) const
      {
        return get (lhs_);
      }

      [[nodiscard]] constexpr auto
      rhs (void) const
      {
        return get (rhs_);
      }

      const Lhs_T lhs_{};

      const Rhs_T rhs_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename Lhs_T, typename Rhs_T>
    or_ (const Lhs_T&, const Rhs_T&) -> or_<Lhs_T, Rhs_T>;
 
    // ------------------------------------------------------------------------

    template <class T>
    struct not_ : type_traits::op
    {
      explicit constexpr not_ (const T& t = {})
          : t_{ t }, value_{ not static_cast<bool> (t) }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      [[nodiscard]] constexpr auto
      value () const
      {
        return get (t_);
      }

      const T t_{};

      const bool value_{};
    };
 
    // Deduction guide.
    template <typename T>
    not_ (const T&) -> not_<T>;
 
    // ------------------------------------------------------------------------
 
#if defined(__cpp_exceptions)

    template <class Callable_T, class Exception_T = void>
    struct throws_ : type_traits::op
    {
      constexpr explicit throws_ (const Callable_T& func)
          : value_{ [&func]
                      {
                        try
                          {
                            func ();
                          }
                        catch (const Exception_T&)
                          {
                            return true;
                          }
                        catch (...)
                          {
                            return false;
                          }
                        return false;
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      const bool value_{};
    };
 
    // ------------------------------------------------------------------------

    template <class Callable_T>
    struct throws_<Callable_T, void> : type_traits::op
    {
      constexpr explicit throws_ (const Callable_T& func)
          : value_{ [&func]
                      {
                        try
                          {
                            func ();
                          }
                        catch (...)
                          {
                            return true;
                          }
                        return false;
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      const bool value_{};
    };
 
    // ------------------------------------------------------------------------

    template <class Callable_T>
    struct nothrow_ : type_traits::op
    {
      constexpr explicit nothrow_ (const Callable_T& func)
          : value_{ [&func]
                      {
                        try
                          {
                            func ();
                          }
                        catch (...)
                          {
                            return false;
                          }
                        return true;
                      }() }
      {
      }

      [[nodiscard]] constexpr
      operator bool () const
      {
        return value_;
      }

      const bool value_{};
    };
 
#endif
 
    // ------------------------------------------------------------------------

    class deferred_reporter_base
    {
    public:
      deferred_reporter_base (bool value,
                              const reflection::source_location location);

      ~deferred_reporter_base ();

      template <class T>
      auto&
      operator<< (const T& msg);

      [[nodiscard]] constexpr bool
      value () const
      {
        return value_;
      }
 
    protected:
      bool value_{};

      bool abort_ = false;

      const reflection::source_location location_{};

      std::string message_{};
    };
 
    // ------------------------------------------------------------------------

    template <class Expr_T>
    class deferred_reporter : public deferred_reporter_base
    {
    public:
      constexpr explicit deferred_reporter (
          const Expr_T& expr, bool abort,
          const reflection::source_location& location);

      ~deferred_reporter ();
 
    protected:
      const Expr_T expr_{};
    };
 
    // ------------------------------------------------------------------------
  } // namespace detail
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// ----------------------------------------------------------------------------
 
#endif // __cplusplus
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_TEST_PLUS_DETAIL_H_
 
// ----------------------------------------------------------------------------