detail-inlines.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_INLINES_H_
#define MICRO_TEST_PLUS_DETAIL_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#ifdef __cplusplus
 
// ----------------------------------------------------------------------------
 
#include <charconv>
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif
#endif
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus
{
  namespace detail
  {
    // ========================================================================

    template <class T>
    constexpr auto
    get (const T& t)
    {
      if constexpr (requires { t.get (); })
        return t.get ();
      else
        return t;
    }
 
    // ------------------------------------------------------------------------

    template <class T>
    constexpr unary_op_<T>::unary_op_ (const T& t, bool value)
        : t_{ t }, value_{ value }
    {
    }

    template <class T>
    constexpr unary_op_<T>::
    operator bool () const
    {
      return value_;
    }

    template <class T>
    constexpr auto
    unary_op_<T>::operand () const
    {
      return get (t_);
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr binary_op_<Lhs_T, Rhs_T>::binary_op_ (const Lhs_T& lhs,
                                                    const Rhs_T& rhs,
                                                    bool value)
        : lhs_{ lhs }, rhs_{ rhs }, value_{ value }
    {
    }

    template <class Lhs_T, class Rhs_T>
    constexpr binary_op_<Lhs_T, Rhs_T>::
    operator bool () const
    {
      return value_;
    }

    template <class Lhs_T, class Rhs_T>
    constexpr auto
    binary_op_<Lhs_T, Rhs_T>::lhs (void) const
    {
      return get (lhs_);
    }

    template <class Lhs_T, class Rhs_T>
    constexpr auto
    binary_op_<Lhs_T, Rhs_T>::rhs (void) const
    {
      return get (rhs_);
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr eq_<Lhs_T, Rhs_T>::eq_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        // This lambda is called in the constructor to evaluate the
        // comparison. Its result is implicitly converted to bool via
        // the operator bool() of whatever type the branch returns.
        // This is intentional: all result types (integral_constant,
        // comparator objects, plain bool) define operator bool().
        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<Lhs_T>
                      and type_traits::has_value<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<Lhs_T>
                           and type_traits::has_epsilon<Rhs_T>)
          {
            // If both values have precision, compare them using
            // the smallest precision.
            return math::abs (get (lhs) - get (rhs))
                   < math::min_value (lhs.epsilon, rhs.epsilon);
          }
        else if constexpr (type_traits::has_epsilon<Lhs_T>)
          {
            // If only the left operand has precision, use it.
            return math::abs (get (lhs) - get (rhs)) < lhs.epsilon;
          }
        else if constexpr (type_traits::has_epsilon<Rhs_T>)
          {
            // If only the right operand has precision, use it.
            return math::abs (get (lhs) - get (rhs)) < rhs.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
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr ne_<Lhs_T, Rhs_T>::ne_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        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<Lhs_T>
                      and type_traits::has_value<Rhs_T>)
          {
            return Lhs_T::value != Rhs_T::value;
          }
        else if constexpr (type_traits::has_epsilon<Lhs_T>
                           and type_traits::has_epsilon<Rhs_T>)
          {
            return math::abs (get (lhs) - get (rhs))
                   >= math::min_value (lhs.epsilon, rhs.epsilon);
          }
        else if constexpr (type_traits::has_epsilon<Lhs_T>)
          {
            return math::abs (get (lhs) - get (rhs)) >= lhs.epsilon;
          }
        else if constexpr (type_traits::has_epsilon<Rhs_T>)
          {
            return math::abs (get (lhs) - get (rhs)) >= rhs.epsilon;
          }
        else
          {
            return get (lhs) != get (rhs);
          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr gt_<Lhs_T, Rhs_T>::gt_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        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<Lhs_T>
                      and type_traits::has_value<Rhs_T>)
          {
            return Lhs_T::value > Rhs_T::value;
          }
        else
          {
            return get (lhs) > get (rhs);
          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr ge_<Lhs_T, Rhs_T>::ge_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        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<Lhs_T>
                      and type_traits::has_value<Rhs_T>)
          {
            return Lhs_T::value >= Rhs_T::value;
          }
        else
          {
            return get (lhs) >= get (rhs);
          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr lt_<Lhs_T, Rhs_T>::lt_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        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<Lhs_T>
                      and type_traits::has_value<Rhs_T>)
          {
            return Lhs_T::value < Rhs_T::value;
          }
        else
          {
            return get (lhs) < get (rhs);
          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr le_<Lhs_T, Rhs_T>::le_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{ lhs, rhs, [&]
      {
        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<Lhs_T>
                      and type_traits::has_value<Rhs_T>)
          {
            return Lhs_T::value <= Rhs_T::value;
          }
        else
          {
            return get (lhs) <= get (rhs);
          }
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr and_<Lhs_T, Rhs_T>::and_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{
            lhs, rhs, static_cast<bool> (lhs) and static_cast<bool> (rhs)
          }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Lhs_T, class Rhs_T>
    constexpr or_<Lhs_T, Rhs_T>::or_ (const Lhs_T& lhs, const Rhs_T& rhs)
        : binary_op_<Lhs_T, Rhs_T>{
            lhs, rhs, static_cast<bool> (lhs) or static_cast<bool> (rhs)
          }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class T>
    constexpr not_<T>::not_ (const T& t)
        : unary_op_<T>{ t, not static_cast<bool> (t) }
    {
    }
 
    // ------------------------------------------------------------------------
 
#if defined(__cpp_exceptions)

    constexpr callable_op_::callable_op_ (bool value) : value_{ value }
    {
    }

    constexpr callable_op_::
    operator bool () const
    {
      return value_;
    }
 
    // ------------------------------------------------------------------------

    template <class Callable_T, class Exception_T>
    constexpr throws_<Callable_T, Exception_T>::throws_ (
        const Callable_T& func)
        : callable_op_{ [&func]
      {
        try
          {
            func ();
          }
        catch (const Exception_T&)
          {
            return true;
          }
        catch (...)
          {
            return false;
          }
        return false;
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Callable_T>
    constexpr throws_<Callable_T, void>::throws_ (const Callable_T& func)
        : callable_op_{ [&func]
      {
        try
          {
            func ();
          }
        catch (...)
          {
            return true;
          }
        return false;
      }() }
    {
    }
 
    // ------------------------------------------------------------------------

    template <class Callable_T>
    constexpr nothrow_<Callable_T>::nothrow_ (const Callable_T& func)
        : callable_op_{ [&func]
      {
        try
          {
            func ();
          }
        catch (...)
          {
            return false;
          }
        return true;
      }() }
    {
    }
 
#endif // defined(__cpp_exceptions)
 
    // ------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif

    template <class T>
      requires std::is_arithmetic_v<T>
    void
    append_number_ (std::string& buffer, const T v)
    {
      char buf[32];
      if constexpr (std::is_same_v<T, long double>)
        {
#if defined(_WIN32) \
    || (defined(__SIZEOF_LONG_DOUBLE__) \
        && __SIZEOF_LONG_DOUBLE__ == __SIZEOF_DOUBLE__)
          // On Windows (all toolchains: MinGW, Clang, MSVC), the C runtime
          // does not handle the %Lg printf specifier correctly for 80-bit
          // long double, producing garbage output. On platforms where long
          // double has the same width as double (ARM, RISC-V), the cast is
          // lossless. In both cases, cast to double and use std::to_chars.
          const auto [ptr, ec] = std::to_chars (buf, buf + sizeof (buf),
                                                static_cast<double> (v));
          if (ec == std::errc{})
            buffer.append (buf, ptr);
#else
          // On x86-64 Linux/macOS with 80-bit extended-precision long double,
          // std::to_chars for long double may be unavailable (e.g., with lld).
          // Use snprintf as a portable fallback; %Lg is supported correctly
          // by glibc and libc++ on these platforms.
          snprintf (buf, sizeof (buf), "%Lg", v);
          buffer.append (buf);
#endif
        }
      else
        {
          const auto [ptr, ec] = std::to_chars (buf, buf + sizeof (buf), v);
          if (ec == std::errc{})
            buffer.append (buf, ptr);
        }
    }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
    // ------------------------------------------------------------------------
 
  } // namespace detail
 
  // --------------------------------------------------------------------------
 
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// ----------------------------------------------------------------------------
 
#endif // __cplusplus
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_TEST_PLUS_DETAIL_INLINES_H_
 
// ----------------------------------------------------------------------------